From 274aca01da577455ee4241b412ec8d43cb351f82 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:32:48 +0200 Subject: [PATCH 01/15] ruff linter configuration --- ruff.toml | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 ruff.toml diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 0000000000..fd240d1de4 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,20 @@ +# To be replaced by pyproject.toml when it is introduced in the project +#[tool.ruff] +target-version = "py39" # to be replaced by project:requires-python after switch to pyproject.toml + +#[tool.ruff.lint] +[lint] +select = [ + # "D", # TODO to be enabled after fixing all issues + "E", "F", "I", "UP", + "TCH005", +] +ignore = [ + "D100", "D105", "D107", "D200", "D202", "D203", "D205", "D212", "D400", "D401", "D415", + "E501", +] + +#[tool.ruff.lint.per-file-ignores] +[lint.per-file-ignores] +"__init__.py" = ["F401"] +"test/**" = ["D", "F403", "F405"] From 440e87f518fc8ac73e67104d418e0c3d46e29409 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:37:45 +0200 Subject: [PATCH 02/15] explicitly sort rich and nest_asyncio imports in bittensor.__init__ --- bittensor/__init__.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bittensor/__init__.py b/bittensor/__init__.py index 8ec8019728..0ae6ded6da 100644 --- a/bittensor/__init__.py +++ b/bittensor/__init__.py @@ -17,12 +17,9 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from rich.console import Console -from rich.traceback import install - # Install and apply nest asyncio to allow the async functions # to run in a .ipynb -import nest_asyncio +import nest_asyncio # noqa: F401 nest_asyncio.apply() @@ -37,6 +34,9 @@ ) __new_signature_version__ = 360 +from rich.console import Console # noqa: F401, E402 +from rich.traceback import install # noqa: F401, E402 + # Rich console. __console__ = Console() __use_console__ = True From 2eca5745801aba3001f3b681f0c3b535a8623600 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:38:09 +0200 Subject: [PATCH 03/15] apply `ruff check . --fix` --- bittensor/__init__.py | 121 +++++++++--------- bittensor/axon.py | 31 ++--- bittensor/btlogging/__init__.py | 1 - bittensor/btlogging/defines.py | 2 +- bittensor/btlogging/format.py | 7 +- bittensor/btlogging/helpers.py | 2 +- bittensor/btlogging/loggingmachine.py | 14 +- bittensor/chain_data.py | 12 +- bittensor/cli.py | 11 +- bittensor/commands/__init__.py | 84 ++++++------ bittensor/commands/delegates.py | 67 ++++------ bittensor/commands/identity.py | 5 +- bittensor/commands/inspect.py | 20 +-- bittensor/commands/list.py | 10 +- bittensor/commands/metagraph.py | 54 ++++---- bittensor/commands/misc.py | 6 +- bittensor/commands/network.py | 23 ++-- bittensor/commands/overview.py | 69 +++++----- bittensor/commands/register.py | 10 +- bittensor/commands/root.py | 38 +++--- bittensor/commands/senate.py | 45 +++---- bittensor/commands/stake.py | 19 ++- bittensor/commands/transfer.py | 17 ++- bittensor/commands/unstake.py | 11 +- bittensor/commands/utils.py | 19 +-- bittensor/commands/wallets.py | 21 +-- bittensor/commands/weights.py | 21 +-- bittensor/config.py | 15 ++- bittensor/dendrite.py | 11 +- bittensor/errors.py | 4 +- bittensor/extrinsics/commit_weights.py | 6 +- bittensor/extrinsics/delegation.py | 103 ++++++--------- bittensor/extrinsics/network.py | 11 +- bittensor/extrinsics/prometheus.py | 29 ++--- bittensor/extrinsics/registration.py | 53 +++----- bittensor/extrinsics/root.py | 33 ++--- bittensor/extrinsics/senate.py | 23 ++-- bittensor/extrinsics/serving.py | 22 ++-- bittensor/extrinsics/set_weights.py | 17 ++- bittensor/extrinsics/staking.py | 88 ++++--------- bittensor/extrinsics/transfer.py | 28 ++-- bittensor/extrinsics/unstaking.py | 86 ++++--------- bittensor/keyfile.py | 57 ++++----- bittensor/metagraph.py | 17 ++- bittensor/mock/keyfile_mock.py | 8 +- bittensor/mock/subtensor_mock.py | 30 ++--- bittensor/mock/wallet_mock.py | 4 +- bittensor/stream.py | 14 +- bittensor/subnets.py | 5 +- bittensor/subtensor.py | 57 ++++----- bittensor/synapse.py | 3 +- bittensor/tensor.py | 8 +- bittensor/threadpool.py | 19 ++- bittensor/utils/__init__.py | 16 +-- bittensor/utils/_register_cuda.py | 5 +- bittensor/utils/formatting.py | 2 +- bittensor/utils/networking.py | 5 +- bittensor/utils/registration.py | 6 +- bittensor/utils/subtensor.py | 8 +- bittensor/utils/version.py | 13 +- bittensor/utils/wallet_utils.py | 5 +- bittensor/utils/weight_utils.py | 18 ++- bittensor/wallet.py | 20 +-- setup.py | 9 +- tests/e2e_tests/conftest.py | 11 +- .../e2e_tests/multistep/test_last_tx_block.py | 3 +- .../delegation/test_set_delegate_take.py | 3 +- .../subcommands/wallet/test_transfer.py | 2 +- .../weights/test_commit_weights.py | 4 +- tests/e2e_tests/utils.py | 4 +- tests/helpers/__init__.py | 7 +- tests/helpers/helpers.py | 10 +- tests/integration_tests/test_cli.py | 29 ++--- .../integration_tests/test_cli_no_network.py | 11 +- .../test_metagraph_integration.py | 8 +- .../test_subtensor_integration.py | 8 +- .../unit_tests/extrinsics/test_delegation.py | 20 +-- tests/unit_tests/extrinsics/test_network.py | 10 +- .../unit_tests/extrinsics/test_prometheus.py | 8 +- .../extrinsics/test_registration.py | 14 +- tests/unit_tests/extrinsics/test_root.py | 6 +- tests/unit_tests/extrinsics/test_senate.py | 4 +- tests/unit_tests/extrinsics/test_serving.py | 9 +- .../unit_tests/extrinsics/test_set_weights.py | 6 +- tests/unit_tests/extrinsics/test_staking.py | 8 +- tests/unit_tests/extrinsics/test_unstaking.py | 8 +- tests/unit_tests/test_axon.py | 4 +- tests/unit_tests/test_chain_data.py | 3 +- tests/unit_tests/test_dendrite.py | 20 +-- tests/unit_tests/test_keyfile.py | 45 ++++--- tests/unit_tests/test_logging.py | 8 +- tests/unit_tests/test_metagraph.py | 8 +- tests/unit_tests/test_subtensor.py | 4 +- tests/unit_tests/test_synapse.py | 6 +- tests/unit_tests/test_tensor.py | 7 +- tests/unit_tests/test_wallet.py | 20 +-- tests/unit_tests/utils/test_balance.py | 7 +- tests/unit_tests/utils/test_networking.py | 6 +- tests/unit_tests/utils/test_subtensor.py | 2 +- tests/unit_tests/utils/test_utils.py | 3 +- tests/unit_tests/utils/test_version.py | 9 +- tests/unit_tests/utils/test_weight_utils.py | 2 +- 102 files changed, 894 insertions(+), 1051 deletions(-) diff --git a/bittensor/__init__.py b/bittensor/__init__.py index 0ae6ded6da..a4b3d8dd6e 100644 --- a/bittensor/__init__.py +++ b/bittensor/__init__.py @@ -206,6 +206,30 @@ def debug(on: bool = True): }, } +from substrateinterface import Keypair # noqa: F401 + +# Allows avoiding name spacing conflicts and continue access to the `subtensor` module with `subtensor_module` name +from . import subtensor as subtensor_module +from .axon import axon as axon +from .btlogging import logging +from .chain_data import ( + AxonInfo, + DelegateInfo, + DelegateInfoLite, + IPInfo, + NeuronInfo, + NeuronInfoLite, + PrometheusInfo, + ProposalCallData, + ProposalVoteData, + StakeInfo, + SubnetHyperparameters, + SubnetInfo, +) +from .cli import COMMANDS as ALL_COMMANDS +from .cli import cli as cli +from .config import DefaultConfig, InvalidConfigFile, T, config +from .dendrite import dendrite as dendrite from .errors import ( BlacklistedException, ChainConnectionError, @@ -232,85 +256,54 @@ def debug(on: bool = True): UnknownSynapseError, UnstakeError, ) - -from substrateinterface import Keypair # noqa: F401 -from .config import InvalidConfigFile, DefaultConfig, config, T from .keyfile import ( - serialized_keypair_to_keyfile_data, - deserialize_keypair_from_keyfile_data, - validate_password, + Mockkeyfile, ask_password_to_encrypt, - keyfile_data_is_encrypted_nacl, - keyfile_data_is_encrypted_ansible, - keyfile_data_is_encrypted_legacy, - keyfile_data_is_encrypted, - keyfile_data_encryption_method, - legacy_encrypt_keyfile_data, + decrypt_keyfile_data, + deserialize_keypair_from_keyfile_data, encrypt_keyfile_data, get_coldkey_password_from_environment, - decrypt_keyfile_data, keyfile, - Mockkeyfile, + keyfile_data_encryption_method, + keyfile_data_is_encrypted, + keyfile_data_is_encrypted_ansible, + keyfile_data_is_encrypted_legacy, + keyfile_data_is_encrypted_nacl, + legacy_encrypt_keyfile_data, + serialized_keypair_to_keyfile_data, + validate_password, ) -from .wallet import display_mnemonic_msg, wallet +from .metagraph import metagraph as metagraph +from .mock.keyfile_mock import MockKeyfile as MockKeyfile +from .mock.subtensor_mock import MockSubtensor as MockSubtensor +from .mock.wallet_mock import MockWallet as MockWallet +from .stream import StreamingSynapse +from .subnets import SubnetsAPI as SubnetsAPI +# Double import allows using class `Subtensor` by referencing `bittensor.Subtensor` and `bittensor.subtensor`. +# This will be available for a while until we remove reference `bittensor.subtensor` +from .subtensor import Subtensor +from .subtensor import Subtensor as subtensor +from .synapse import Synapse, TerminalInfo +from .tensor import Tensor, tensor +from .threadpool import PriorityThreadPoolExecutor as PriorityThreadPoolExecutor from .utils import ( - ss58_to_vec_u8, - unbiased_topk, - version_checking, - strtobool, - strtobool_with_default, - get_explorer_root_url_by_network_from_map, + U16_NORMALIZED_FLOAT, + U64_NORMALIZED_FLOAT, get_explorer_root_url_by_network_from_map, get_explorer_url_for_network, + hash, ss58_address_to_bytes, - U16_NORMALIZED_FLOAT, - U64_NORMALIZED_FLOAT, + ss58_to_vec_u8, + strtobool, + strtobool_with_default, u8_key_to_ss58, - hash, + unbiased_topk, + version_checking, wallet_utils, ) - from .utils.balance import Balance as Balance -from .chain_data import ( - AxonInfo, - NeuronInfo, - NeuronInfoLite, - PrometheusInfo, - DelegateInfo, - DelegateInfoLite, - StakeInfo, - SubnetInfo, - SubnetHyperparameters, - IPInfo, - ProposalCallData, - ProposalVoteData, -) - -# Allows avoiding name spacing conflicts and continue access to the `subtensor` module with `subtensor_module` name -from . import subtensor as subtensor_module - -# Double import allows using class `Subtensor` by referencing `bittensor.Subtensor` and `bittensor.subtensor`. -# This will be available for a while until we remove reference `bittensor.subtensor` -from .subtensor import Subtensor -from .subtensor import Subtensor as subtensor - -from .cli import cli as cli, COMMANDS as ALL_COMMANDS -from .btlogging import logging -from .metagraph import metagraph as metagraph -from .threadpool import PriorityThreadPoolExecutor as PriorityThreadPoolExecutor - -from .synapse import TerminalInfo, Synapse -from .stream import StreamingSynapse -from .tensor import tensor, Tensor -from .axon import axon as axon -from .dendrite import dendrite as dendrite - -from .mock.keyfile_mock import MockKeyfile as MockKeyfile -from .mock.subtensor_mock import MockSubtensor as MockSubtensor -from .mock.wallet_mock import MockWallet as MockWallet - -from .subnets import SubnetsAPI as SubnetsAPI +from .wallet import display_mnemonic_msg, wallet configs = [ axon.config(), diff --git a/bittensor/axon.py b/bittensor/axon.py index 7f4aff1c73..913a9e137e 100644 --- a/bittensor/axon.py +++ b/bittensor/axon.py @@ -31,11 +31,12 @@ import traceback import typing import uuid -from inspect import signature, Signature, Parameter -from typing import List, Optional, Tuple, Callable, Any, Dict, Awaitable +from collections.abc import Awaitable +from inspect import Parameter, Signature, signature +from typing import Any, Callable, Dict, List, Optional, Tuple import uvicorn -from fastapi import FastAPI, APIRouter, Depends +from fastapi import APIRouter, Depends, FastAPI from fastapi.responses import JSONResponse from fastapi.routing import serialize_response from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint @@ -45,15 +46,15 @@ import bittensor from bittensor.errors import ( + BlacklistedException, InvalidRequestNameError, - SynapseDendriteNoneException, - SynapseParsingError, - UnknownSynapseError, NotVerifiedException, - BlacklistedException, - PriorityException, PostProcessException, + PriorityException, + SynapseDendriteNoneException, SynapseException, + SynapseParsingError, + UnknownSynapseError, ) from bittensor.threadpool import PriorityThreadPoolExecutor from bittensor.utils import networking @@ -521,23 +522,17 @@ async def endpoint(*args, **kwargs): ) assert ( signature(blacklist_fn) == blacklist_sig - ), "The blacklist_fn function must have the signature: blacklist( synapse: {} ) -> Tuple[bool, str]".format( - request_name - ) + ), f"The blacklist_fn function must have the signature: blacklist( synapse: {request_name} ) -> Tuple[bool, str]" if priority_fn: priority_sig = Signature(expected_params, return_annotation=float) assert ( signature(priority_fn) == priority_sig - ), "The priority_fn function must have the signature: priority( synapse: {} ) -> float".format( - request_name - ) + ), f"The priority_fn function must have the signature: priority( synapse: {request_name} ) -> float" if verify_fn: verify_sig = Signature(expected_params, return_annotation=None) assert ( signature(verify_fn) == verify_sig - ), "The verify_fn function must have the signature: verify( synapse: {} ) -> None".format( - request_name - ) + ), f"The verify_fn function must have the signature: verify( synapse: {request_name} ) -> None" # Store functions in appropriate attribute dictionaries self.forward_class_types[request_name] = param_class @@ -1164,7 +1159,7 @@ async def preprocess(self, request: Request) -> bittensor.Synapse: try: synapse = request_synapse.from_headers(request.headers) # type: ignore - except Exception as e: + except Exception: raise SynapseParsingError( f"Improperly formatted request. Could not parse headers {request.headers} into synapse of type {request_name}." ) diff --git a/bittensor/btlogging/__init__.py b/bittensor/btlogging/__init__.py index 6bf6d2bf35..ab76ebb9df 100644 --- a/bittensor/btlogging/__init__.py +++ b/bittensor/btlogging/__init__.py @@ -24,5 +24,4 @@ from bittensor.btlogging.loggingmachine import LoggingMachine - logging = LoggingMachine(LoggingMachine.config()) diff --git a/bittensor/btlogging/defines.py b/bittensor/btlogging/defines.py index c87177ffd0..88e0429779 100644 --- a/bittensor/btlogging/defines.py +++ b/bittensor/btlogging/defines.py @@ -19,7 +19,7 @@ BASE_LOG_FORMAT = "%(asctime)s | %(levelname)s | %(message)s" TRACE_LOG_FORMAT = ( - f"%(asctime)s | %(levelname)s | %(name)s:%(filename)s:%(lineno)s | %(message)s" + "%(asctime)s | %(levelname)s | %(name)s:%(filename)s:%(lineno)s | %(message)s" ) DATE_FORMAT = "%Y-%m-%d %H:%M:%S" BITTENSOR_LOGGER_NAME = "bittensor" diff --git a/bittensor/btlogging/format.py b/bittensor/btlogging/format.py index 5f2c8cb866..3ab0021bd8 100644 --- a/bittensor/btlogging/format.py +++ b/bittensor/btlogging/format.py @@ -25,8 +25,7 @@ import time from typing import Dict -from colorama import init, Fore, Back, Style - +from colorama import Back, Fore, Style, init init(autoreset=True) @@ -134,7 +133,7 @@ def formatTime(self, record, datefmt=None) -> str: s = time.strftime(datefmt, created) else: s = time.strftime("%Y-%m-%d %H:%M:%S", created) - s += ".{:03d}".format(int(record.msecs)) + s += f".{int(record.msecs):03d}" return s def format(self, record) -> str: @@ -205,7 +204,7 @@ def formatTime(self, record, datefmt=None) -> str: s = time.strftime(datefmt, created) else: s = time.strftime("%Y-%m-%d %H:%M:%S", created) - s += ".{:03d}".format(int(record.msecs)) + s += f".{int(record.msecs):03d}" return s def format(self, record) -> str: diff --git a/bittensor/btlogging/helpers.py b/bittensor/btlogging/helpers.py index 532c1f7166..f31b3e261e 100644 --- a/bittensor/btlogging/helpers.py +++ b/bittensor/btlogging/helpers.py @@ -20,7 +20,7 @@ """ import logging -from typing import Generator +from collections.abc import Generator def all_loggers() -> Generator[logging.Logger, None, None]: diff --git a/bittensor/btlogging/loggingmachine.py b/bittensor/btlogging/loggingmachine.py index 1c6aad3bb6..45f5bae320 100644 --- a/bittensor/btlogging/loggingmachine.py +++ b/bittensor/btlogging/loggingmachine.py @@ -31,18 +31,18 @@ from logging.handlers import QueueHandler, QueueListener, RotatingFileHandler from typing import NamedTuple -from statemachine import StateMachine, State +from statemachine import State, StateMachine import bittensor.config from bittensor.btlogging.defines import ( - TRACE_LOG_FORMAT, - DATE_FORMAT, BITTENSOR_LOGGER_NAME, + DATE_FORMAT, + DEFAULT_LOG_BACKUP_COUNT, DEFAULT_LOG_FILE_NAME, DEFAULT_MAX_ROTATING_LOG_FILE_SIZE, - DEFAULT_LOG_BACKUP_COUNT, + TRACE_LOG_FORMAT, ) -from bittensor.btlogging.format import BtStreamFormatter, BtFileFormatter +from bittensor.btlogging.format import BtFileFormatter, BtStreamFormatter from bittensor.btlogging.helpers import all_loggers @@ -260,7 +260,7 @@ def after_transition(self, event, state): # Default Logging def before_enable_default(self): """Logs status before enable Default.""" - self._logger.info(f"Enabling default logging.") + self._logger.info("Enabling default logging.") self._logger.setLevel(stdlogging.INFO) for logger in all_loggers(): if logger.name in self._primary_loggers: @@ -284,7 +284,7 @@ def after_enable_trace(self): def before_disable_trace(self): """Logs status before disable Trace.""" - self._logger.info(f"Disabling trace.") + self._logger.info("Disabling trace.") self._stream_formatter.set_trace(False) self.enable_default() diff --git a/bittensor/chain_data.py b/bittensor/chain_data.py index 6edc7116cc..c93dc4776e 100644 --- a/bittensor/chain_data.py +++ b/bittensor/chain_data.py @@ -21,9 +21,9 @@ """ import json -from dataclasses import dataclass, asdict +from dataclasses import asdict, dataclass from enum import Enum -from typing import List, Tuple, Dict, Optional, Any, TypedDict, Union +from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union from scalecodec.base import RuntimeConfiguration, ScaleBytes from scalecodec.type_registry import load_type_registry_preset @@ -31,7 +31,9 @@ from scalecodec.utils.ss58 import ss58_encode import bittensor -from .utils import networking as net, RAOPERTAO, U16_NORMALIZED_FLOAT + +from .utils import RAOPERTAO, U16_NORMALIZED_FLOAT +from .utils import networking as net from .utils.balance import Balance from .utils.registration import torch, use_torch @@ -230,9 +232,7 @@ def __eq__(self, other: "AxonInfo"): return False def __str__(self): - return "AxonInfo( {}, {}, {}, {} )".format( - str(self.ip_str()), str(self.hotkey), str(self.coldkey), self.version - ) + return f"AxonInfo( {str(self.ip_str())}, {str(self.hotkey)}, {str(self.coldkey)}, {self.version} )" def __repr__(self): return self.__str__() diff --git a/bittensor/cli.py b/bittensor/cli.py index 931c5d8d14..b7e7ee7a1b 100644 --- a/bittensor/cli.py +++ b/bittensor/cli.py @@ -15,13 +15,17 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +import argparse import sys +from typing import List, Optional + import shtab -import argparse + import bittensor -from typing import List, Optional + from .commands import ( AutocompleteCommand, + CommitWeightCommand, DelegateStakeCommand, DelegateUnstakeCommand, GetIdentityCommand, @@ -43,6 +47,7 @@ RegenHotkeyCommand, RegisterCommand, RegisterSubnetworkCommand, + RevealWeightCommand, RootGetWeightsCommand, RootList, RootRegisterCommand, @@ -68,8 +73,6 @@ VoteCommand, WalletBalanceCommand, WalletCreateCommand, - CommitWeightCommand, - RevealWeightCommand, ) # Create a console instance for CLI display. diff --git a/bittensor/commands/__init__.py b/bittensor/commands/__init__.py index 2ccea346a4..fd5dbcdf75 100644 --- a/bittensor/commands/__init__.py +++ b/bittensor/commands/__init__.py @@ -62,63 +62,63 @@ } ) -from .stake import StakeCommand, StakeShow -from .unstake import UnStakeCommand -from .overview import OverviewCommand -from .register import ( - PowRegisterCommand, - RegisterCommand, - RunFaucetCommand, - SwapHotkeyCommand, -) from .delegates import ( - NominateCommand, - ListDelegatesCommand, - ListDelegatesLiteCommand, DelegateStakeCommand, DelegateUnstakeCommand, + ListDelegatesCommand, + ListDelegatesLiteCommand, MyDelegatesCommand, + NominateCommand, SetTakeCommand, ) -from .wallets import ( - NewColdkeyCommand, - NewHotkeyCommand, - RegenColdkeyCommand, - RegenColdkeypubCommand, - RegenHotkeyCommand, - UpdateWalletCommand, - WalletCreateCommand, - WalletBalanceCommand, - GetWalletHistoryCommand, -) -from .weights import CommitWeightCommand, RevealWeightCommand -from .transfer import TransferCommand +from .identity import GetIdentityCommand, SetIdentityCommand from .inspect import InspectCommand -from .metagraph import MetagraphCommand from .list import ListCommand -from .misc import UpdateCommand, AutocompleteCommand -from .senate import ( - SenateCommand, - ProposalsCommand, - ShowVotesCommand, - SenateRegisterCommand, - SenateLeaveCommand, - VoteCommand, -) +from .metagraph import MetagraphCommand +from .misc import AutocompleteCommand, UpdateCommand from .network import ( RegisterSubnetworkCommand, - SubnetLockCostCommand, + SubnetGetHyperparamsCommand, + SubnetHyperparamsCommand, SubnetListCommand, + SubnetLockCostCommand, SubnetSudoCommand, - SubnetHyperparamsCommand, - SubnetGetHyperparamsCommand, +) +from .overview import OverviewCommand +from .register import ( + PowRegisterCommand, + RegisterCommand, + RunFaucetCommand, + SwapHotkeyCommand, ) from .root import ( - RootRegisterCommand, - RootList, - RootSetWeightsCommand, RootGetWeightsCommand, + RootList, + RootRegisterCommand, RootSetBoostCommand, RootSetSlashCommand, + RootSetWeightsCommand, ) -from .identity import GetIdentityCommand, SetIdentityCommand +from .senate import ( + ProposalsCommand, + SenateCommand, + SenateLeaveCommand, + SenateRegisterCommand, + ShowVotesCommand, + VoteCommand, +) +from .stake import StakeCommand, StakeShow +from .transfer import TransferCommand +from .unstake import UnStakeCommand +from .wallets import ( + GetWalletHistoryCommand, + NewColdkeyCommand, + NewHotkeyCommand, + RegenColdkeyCommand, + RegenColdkeypubCommand, + RegenHotkeyCommand, + UpdateWalletCommand, + WalletBalanceCommand, + WalletCreateCommand, +) +from .weights import CommitWeightCommand, RevealWeightCommand diff --git a/bittensor/commands/delegates.py b/bittensor/commands/delegates.py index 344b2bfcea..2d48bafe08 100644 --- a/bittensor/commands/delegates.py +++ b/bittensor/commands/delegates.py @@ -18,18 +18,19 @@ import argparse import os import sys -from typing import List, Dict, Optional +from typing import Dict, List, Optional from rich.console import Text -from rich.prompt import Prompt, FloatPrompt, Confirm +from rich.prompt import Confirm, FloatPrompt, Prompt from rich.table import Table from substrateinterface.exceptions import SubstrateRequestException from tqdm import tqdm import bittensor + from . import defaults from .identity import SetIdentityCommand -from .utils import get_delegates_details, DelegatesDetails +from .utils import DelegatesDetails, get_delegates_details def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: @@ -287,13 +288,9 @@ def show_delegates( / float(prev_stake) ) if rate_change_in_stake > 0: - rate_change_in_stake_str = "[green]{:.2f}%[/green]".format( - rate_change_in_stake - ) + rate_change_in_stake_str = f"[green]{rate_change_in_stake:.2f}%[/green]" elif rate_change_in_stake < 0: - rate_change_in_stake_str = "[red]{:.2f}%[/red]".format( - rate_change_in_stake - ) + rate_change_in_stake_str = f"[red]{rate_change_in_stake:.2f}%[/red]" else: rate_change_in_stake_str = "[grey0]0%[/grey0]" else: @@ -424,9 +421,7 @@ def check_config(config: "bittensor.config"): if len(delegates) == 0: console.print( - ":cross_mark: [red]There are no delegates on {}[/red]".format( - subtensor.network - ) + f":cross_mark: [red]There are no delegates on {subtensor.network}[/red]" ) sys.exit(1) @@ -435,7 +430,7 @@ def check_config(config: "bittensor.config"): delegate_index = Prompt.ask("Enter delegate index") config.delegate_ss58key = str(delegates[int(delegate_index)].hotkey_ss58) console.print( - "Selected: [yellow]{}[/yellow]".format(config.delegate_ss58key) + f"Selected: [yellow]{config.delegate_ss58key}[/yellow]" ) if not config.is_set("wallet.name") and not config.no_prompt: @@ -454,9 +449,7 @@ def check_config(config: "bittensor.config"): config.amount = float(amount) except ValueError: console.print( - ":cross_mark: [red]Invalid Tao amount[/red] [bold white]{}[/bold white]".format( - amount - ) + f":cross_mark: [red]Invalid Tao amount[/red] [bold white]{amount}[/bold white]" ) sys.exit() else: @@ -569,9 +562,7 @@ def check_config(config: "bittensor.config"): if len(delegates) == 0: console.print( - ":cross_mark: [red]There are no delegates on {}[/red]".format( - subtensor.network - ) + f":cross_mark: [red]There are no delegates on {subtensor.network}[/red]" ) sys.exit(1) @@ -580,7 +571,7 @@ def check_config(config: "bittensor.config"): delegate_index = Prompt.ask("Enter delegate index") config.delegate_ss58key = str(delegates[int(delegate_index)].hotkey_ss58) console.print( - "Selected: [yellow]{}[/yellow]".format(config.delegate_ss58key) + f"Selected: [yellow]{config.delegate_ss58key}[/yellow]" ) # Get amount. @@ -595,9 +586,7 @@ def check_config(config: "bittensor.config"): config.amount = float(amount) except ValueError: console.print( - ":cross_mark: [red]Invalid Tao amount[/red] [bold white]{}[/bold white]".format( - amount - ) + f":cross_mark: [red]Invalid Tao amount[/red] [bold white]{amount}[/bold white]" ) sys.exit() else: @@ -832,39 +821,31 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Check if the hotkey is already a delegate. if subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address): bittensor.__console__.print( - "Aborting: Hotkey {} is already a delegate.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} is already a delegate." ) return result: bool = subtensor.nominate(wallet) if not result: bittensor.__console__.print( - "Could not became a delegate on [white]{}[/white]".format( - subtensor.network - ) + f"Could not became a delegate on [white]{subtensor.network}[/white]" ) else: # Check if we are a delegate. is_delegate: bool = subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address) if not is_delegate: bittensor.__console__.print( - "Could not became a delegate on [white]{}[/white]".format( - subtensor.network - ) + f"Could not became a delegate on [white]{subtensor.network}[/white]" ) return bittensor.__console__.print( - "Successfully became a delegate on [white]{}[/white]".format( - subtensor.network - ) + f"Successfully became a delegate on [white]{subtensor.network}[/white]" ) # Prompt use to set identity on chain. if not cli.config.no_prompt: do_set_identity = Prompt.ask( - f"Subnetwork registered successfully. Would you like to set your identity? [y/n]", + "Subnetwork registered successfully. Would you like to set your identity? [y/n]", choices=["y", "n"], ) @@ -1080,7 +1061,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) bittensor.__console__.print(table) - bittensor.__console__.print("Total delegated Tao: {}".format(total_delegated)) + bittensor.__console__.print(f"Total delegated Tao: {total_delegated}") @staticmethod def add_args(parser: argparse.ArgumentParser): @@ -1158,16 +1139,14 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Check if the hotkey is not a delegate. if not subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address): bittensor.__console__.print( - "Aborting: Hotkey {} is NOT a delegate.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} is NOT a delegate." ) return # Prompt user for take value. new_take_str = config.get("take") if new_take_str == None: - new_take = FloatPrompt.ask(f"Enter take value (0.18 for 18%)") + new_take = FloatPrompt.ask("Enter take value (0.18 for 18%)") else: new_take = float(new_take_str) @@ -1187,13 +1166,11 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): is_delegate: bool = subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address) if not is_delegate: bittensor.__console__.print( - "Could not set the take [white]{}[/white]".format(subtensor.network) + f"Could not set the take [white]{subtensor.network}[/white]" ) return bittensor.__console__.print( - "Successfully set the take on [white]{}[/white]".format( - subtensor.network - ) + f"Successfully set the take on [white]{subtensor.network}[/white]" ) @staticmethod diff --git a/bittensor/commands/identity.py b/bittensor/commands/identity.py index 15232c4440..e075940bba 100644 --- a/bittensor/commands/identity.py +++ b/bittensor/commands/identity.py @@ -1,8 +1,9 @@ import argparse -from rich.table import Table -from rich.prompt import Prompt from sys import getsizeof +from rich.prompt import Prompt +from rich.table import Table + import bittensor diff --git a/bittensor/commands/inspect.py b/bittensor/commands/inspect.py index 4ef0e84c4e..c04a0714ab 100644 --- a/bittensor/commands/inspect.py +++ b/bittensor/commands/inspect.py @@ -16,24 +16,28 @@ # DEALINGS IN THE SOFTWARE. import argparse -import bittensor -from tqdm import tqdm -from rich.table import Table + from rich.prompt import Prompt +from rich.table import Table +from tqdm import tqdm + +import bittensor + +from . import defaults from .utils import ( - get_delegates_details, DelegatesDetails, - get_hotkey_wallets_for_wallet, - get_all_wallets_for_path, filter_netuids_by_registered_hotkeys, + get_all_wallets_for_path, + get_delegates_details, + get_hotkey_wallets_for_wallet, ) -from . import defaults console = bittensor.__console__ import os +from typing import Dict, List, Optional, Tuple + import bittensor -from typing import List, Tuple, Optional, Dict def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: diff --git a/bittensor/commands/list.py b/bittensor/commands/list.py index 6079112ed1..9cd6211238 100644 --- a/bittensor/commands/list.py +++ b/bittensor/commands/list.py @@ -15,12 +15,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import os import argparse -import bittensor +import os + from rich import print from rich.tree import Tree +import bittensor + console = bittensor.__console__ @@ -72,7 +74,7 @@ def run(cli): coldkeypub_str = "?" wallet_tree = root.add( - "\n[bold white]{} ({})".format(w_name, coldkeypub_str) + f"\n[bold white]{w_name} ({coldkeypub_str})" ) hotkeys_path = os.path.join(cli.config.wallet.path, w_name, "hotkeys") try: @@ -92,7 +94,7 @@ def run(cli): hotkey_str = "?" except: hotkey_str = "?" - wallet_tree.add("[bold grey]{} ({})".format(h_name, hotkey_str)) + wallet_tree.add(f"[bold grey]{h_name} ({hotkey_str})") except: continue diff --git a/bittensor/commands/metagraph.py b/bittensor/commands/metagraph.py index 1075f50d31..aad70c341b 100644 --- a/bittensor/commands/metagraph.py +++ b/bittensor/commands/metagraph.py @@ -16,8 +16,11 @@ # DEALINGS IN THE SOFTWARE. import argparse -import bittensor + from rich.table import Table + +import bittensor + from .utils import check_netuid_set console = bittensor.__console__ # type: ignore @@ -86,9 +89,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""Prints an entire metagraph.""" console = bittensor.__console__ console.print( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - cli.config.subtensor.network - ) + f":satellite: Syncing with chain: [white]{cli.config.subtensor.network}[/white] ..." ) metagraph: bittensor.metagraph = subtensor.metagraph(netuid=cli.config.netuid) metagraph.save() @@ -112,16 +113,16 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ep = metagraph.axons[uid] row = [ str(neuron.uid), - "{:.5f}".format(metagraph.total_stake[uid]), - "{:.5f}".format(metagraph.ranks[uid]), - "{:.5f}".format(metagraph.trust[uid]), - "{:.5f}".format(metagraph.consensus[uid]), - "{:.5f}".format(metagraph.incentive[uid]), - "{:.5f}".format(metagraph.dividends[uid]), - "{}".format(int(metagraph.emission[uid] * 1000000000)), - "{:.5f}".format(metagraph.validator_trust[uid]), + f"{metagraph.total_stake[uid]:.5f}", + f"{metagraph.ranks[uid]:.5f}", + f"{metagraph.trust[uid]:.5f}", + f"{metagraph.consensus[uid]:.5f}", + f"{metagraph.incentive[uid]:.5f}", + f"{metagraph.dividends[uid]:.5f}", + f"{int(metagraph.emission[uid] * 1000000000)}", + f"{metagraph.validator_trust[uid]:.5f}", "*" if metagraph.validator_permit[uid] else "", - str((metagraph.block.item() - metagraph.last_update[uid].item())), + str(metagraph.block.item() - metagraph.last_update[uid].item()), str(metagraph.active[uid].item()), ( ep.ip + ":" + str(ep.port) @@ -142,16 +143,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): TABLE_DATA.append(row) total_neurons = len(metagraph.uids) table = Table(show_footer=False) - table.title = "[white]Metagraph: net: {}:{}, block: {}, N: {}/{}, stake: {}, issuance: {}, difficulty: {}".format( - subtensor.network, - metagraph.netuid, - metagraph.block.item(), - sum(metagraph.active.tolist()), - metagraph.n.item(), - bittensor.Balance.from_tao(total_stake), - total_issuance, - difficulty, - ) + table.title = f"[white]Metagraph: net: {subtensor.network}:{metagraph.netuid}, block: {metagraph.block.item()}, N: {sum(metagraph.active.tolist())}/{metagraph.n.item()}, stake: {bittensor.Balance.from_tao(total_stake)}, issuance: {total_issuance}, difficulty: {difficulty}" table.add_column( "[overline white]UID", str(total_neurons), @@ -160,7 +152,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]STAKE(\u03c4)", - "\u03c4{:.5f}".format(total_stake), + f"\u03c4{total_stake:.5f}", footer_style="overline white", justify="right", style="green", @@ -168,7 +160,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]RANK", - "{:.5f}".format(total_rank), + f"{total_rank:.5f}", footer_style="overline white", justify="right", style="green", @@ -176,7 +168,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]TRUST", - "{:.5f}".format(total_trust), + f"{total_trust:.5f}", footer_style="overline white", justify="right", style="green", @@ -184,7 +176,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]CONSENSUS", - "{:.5f}".format(total_consensus), + f"{total_consensus:.5f}", footer_style="overline white", justify="right", style="green", @@ -192,7 +184,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]INCENTIVE", - "{:.5f}".format(total_incentive), + f"{total_incentive:.5f}", footer_style="overline white", justify="right", style="green", @@ -200,7 +192,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]DIVIDENDS", - "{:.5f}".format(total_dividends), + f"{total_dividends:.5f}", footer_style="overline white", justify="right", style="green", @@ -208,7 +200,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]EMISSION(\u03c1)", - "\u03c1{}".format(int(total_emission)), + f"\u03c1{int(total_emission)}", footer_style="overline white", justify="right", style="green", @@ -216,7 +208,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]VTRUST", - "{:.5f}".format(total_validator_trust), + f"{total_validator_trust:.5f}", footer_style="overline white", justify="right", style="green", diff --git a/bittensor/commands/misc.py b/bittensor/commands/misc.py index ded1c78042..269eb486a3 100644 --- a/bittensor/commands/misc.py +++ b/bittensor/commands/misc.py @@ -15,12 +15,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import os import argparse -import bittensor +import os + from rich.prompt import Prompt from rich.table import Table +import bittensor + console = bittensor.__console__ diff --git a/bittensor/commands/network.py b/bittensor/commands/network.py index f20eac67a6..38c40fb05b 100644 --- a/bittensor/commands/network.py +++ b/bittensor/commands/network.py @@ -16,13 +16,16 @@ # DEALINGS IN THE SOFTWARE. import argparse -import bittensor -from . import defaults +from typing import Dict, List, Optional + from rich.prompt import Prompt from rich.table import Table -from typing import List, Optional, Dict -from .utils import get_delegates_details, DelegatesDetails, check_netuid_set + +import bittensor + +from . import defaults from .identity import SetIdentityCommand +from .utils import DelegatesDetails, check_netuid_set, get_delegates_details console = bittensor.__console__ @@ -85,7 +88,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): if success and not cli.config.no_prompt: # Prompt for user to set identity. do_set_identity = Prompt.ask( - f"Subnetwork registered successfully. Would you like to set your identity? [y/n]", + "Subnetwork registered successfully. Would you like to set your identity? [y/n]", choices=["y", "n"], ) @@ -267,7 +270,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): box=None, show_edge=True, ) - table.title = "[white]Subnets - {}".format(subtensor.network) + table.title = f"[white]Subnets - {subtensor.network}" table.add_column( "[overline white]NETUID", str(len(subnets)), @@ -486,9 +489,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): box=None, show_edge=True, ) - table.title = "[white]Subnet Hyperparameters - NETUID: {} - {}".format( - cli.config.netuid, subtensor.network - ) + table.title = f"[white]Subnet Hyperparameters - NETUID: {cli.config.netuid} - {subtensor.network}" table.add_column("[overline white]HYPERPARAMETER", style="bold white") table.add_column("[overline white]VALUE", style="green") @@ -590,9 +591,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): box=None, show_edge=True, ) - table.title = "[white]Subnet Hyperparameters - NETUID: {} - {}".format( - cli.config.netuid, subtensor.network - ) + table.title = f"[white]Subnet Hyperparameters - NETUID: {cli.config.netuid} - {subtensor.network}" table.add_column("[overline white]HYPERPARAMETER", style="white") table.add_column("[overline white]VALUE", style="green") diff --git a/bittensor/commands/overview.py b/bittensor/commands/overview.py index b572847e49..d4715085b7 100644 --- a/bittensor/commands/overview.py +++ b/bittensor/commands/overview.py @@ -16,22 +16,25 @@ # DEALINGS IN THE SOFTWARE. import argparse -import bittensor -from tqdm import tqdm -from concurrent.futures import ProcessPoolExecutor from collections import defaultdict +from concurrent.futures import ProcessPoolExecutor +from typing import Dict, List, Optional, Tuple + from fuzzywuzzy import fuzz from rich.align import Align -from rich.table import Table from rich.prompt import Prompt -from typing import List, Optional, Dict, Tuple +from rich.table import Table +from tqdm import tqdm + +import bittensor + +from . import defaults from .utils import ( - get_hotkey_wallets_for_wallet, - get_coldkey_wallets_for_path, - get_all_wallets_for_path, filter_netuids_by_registered_hotkeys, + get_all_wallets_for_path, + get_coldkey_wallets_for_path, + get_hotkey_wallets_for_wallet, ) -from . import defaults console = bittensor.__console__ @@ -283,9 +286,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): coldkeys_to_check.append(coldkey_wallet) alerts_table.add_row( - "Found {} stake with coldkey {} that is not registered.".format( - difference, coldkey_wallet.coldkeypub.ss58_address - ) + f"Found {difference} stake with coldkey {coldkey_wallet.coldkeypub.ss58_address} that is not registered." ) if coldkeys_to_check: @@ -351,9 +352,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): title: str = "" if not cli.config.get("all", d=None): - title = "[bold white italic]Wallet - {}:{}".format( - cli.config.wallet.name, wallet.coldkeypub.ss58_address - ) + title = f"[bold white italic]Wallet - {cli.config.wallet.name}:{wallet.coldkeypub.ss58_address}" else: title = "[bold whit italic]All Wallets:" @@ -404,14 +403,14 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): hotwallet.hotkey_str, str(uid), str(active), - "{:.5f}".format(stake), - "{:.5f}".format(rank), - "{:.5f}".format(trust), - "{:.5f}".format(consensus), - "{:.5f}".format(incentive), - "{:.5f}".format(dividends), - "{:_}".format(emission), - "{:.5f}".format(validator_trust), + f"{stake:.5f}", + f"{rank:.5f}", + f"{trust:.5f}", + f"{consensus:.5f}", + f"{incentive:.5f}", + f"{dividends:.5f}", + f"{emission:_}", + f"{validator_trust:.5f}", "*" if validator_permit else "", str(last_update), ( @@ -432,7 +431,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): total_emission += emission total_validator_trust += validator_trust - if not (nn.hotkey, nn.coldkey) in hotkeys_seen: + if (nn.hotkey, nn.coldkey) not in hotkeys_seen: # Don't double count stake on hotkey-coldkey pairs. hotkeys_seen.add((nn.hotkey, nn.coldkey)) total_stake += stake @@ -445,7 +444,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Add subnet header if netuid == "-1": - grid.add_row(f"Deregistered Neurons") + grid.add_row("Deregistered Neurons") else: grid.add_row(f"Subnet: [bold white]{netuid}[/bold white]") @@ -484,7 +483,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): if last_subnet: table.add_column( "[overline white]STAKE(\u03c4)", - "\u03c4{:.5f}".format(total_stake), + f"\u03c4{total_stake:.5f}", footer_style="overline white", justify="right", style="green", @@ -500,7 +499,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]RANK", - "{:.5f}".format(total_rank), + f"{total_rank:.5f}", footer_style="overline white", justify="right", style="green", @@ -508,7 +507,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]TRUST", - "{:.5f}".format(total_trust), + f"{total_trust:.5f}", footer_style="overline white", justify="right", style="green", @@ -516,7 +515,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]CONSENSUS", - "{:.5f}".format(total_consensus), + f"{total_consensus:.5f}", footer_style="overline white", justify="right", style="green", @@ -524,7 +523,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]INCENTIVE", - "{:.5f}".format(total_incentive), + f"{total_incentive:.5f}", footer_style="overline white", justify="right", style="green", @@ -532,7 +531,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]DIVIDENDS", - "{:.5f}".format(total_dividends), + f"{total_dividends:.5f}", footer_style="overline white", justify="right", style="green", @@ -540,7 +539,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]EMISSION(\u03c1)", - "\u03c1{:_}".format(total_emission), + f"\u03c1{total_emission:_}", footer_style="overline white", justify="right", style="green", @@ -548,7 +547,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table.add_column( "[overline white]VTRUST", - "{:.5f}".format(total_validator_trust), + f"{total_validator_trust:.5f}", footer_style="overline white", justify="right", style="green", @@ -633,7 +632,7 @@ def _get_neurons_for_netuid( nn = all_neurons[uid] result.append(nn) except Exception as e: - return netuid, [], "Error: {}".format(e) + return netuid, [], f"Error: {e}" finally: if "subtensor" in locals(): subtensor.close() @@ -682,7 +681,7 @@ def _filter_stake_info(stake_info: "bittensor.StakeInfo") -> bool: ] except Exception as e: - return coldkey_wallet, [], "Error: {}".format(e) + return coldkey_wallet, [], f"Error: {e}" finally: if "subtensor" in locals(): subtensor.close() diff --git a/bittensor/commands/register.py b/bittensor/commands/register.py index 8b21a33304..804c791f8f 100644 --- a/bittensor/commands/register.py +++ b/bittensor/commands/register.py @@ -15,14 +15,16 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import sys import argparse -import bittensor -from rich.prompt import Prompt, Confirm -from .utils import check_netuid_set, check_for_cuda_reg_config +import sys from copy import deepcopy +from rich.prompt import Confirm, Prompt + +import bittensor + from . import defaults +from .utils import check_for_cuda_reg_config, check_netuid_set console = bittensor.__console__ diff --git a/bittensor/commands/root.py b/bittensor/commands/root.py index 5607921b19..8aaa2d5624 100644 --- a/bittensor/commands/root.py +++ b/bittensor/commands/root.py @@ -15,17 +15,19 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +import argparse import re import typing -import argparse +from typing import Dict, List, Optional + import numpy as np -import bittensor -from typing import List, Optional, Dict from rich.prompt import Prompt from rich.table import Table -from .utils import get_delegates_details, DelegatesDetails + +import bittensor from . import defaults +from .utils import DelegatesDetails, get_delegates_details console = bittensor.__console__ @@ -139,9 +141,7 @@ def run(cli: "bittensor.cli"): def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""List the root network""" console.print( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ) senate_members = subtensor.get_senate_members() @@ -196,9 +196,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): else "" ), neuron_data.hotkey, - "{:.5f}".format( - float(subtensor.get_total_stake_for_hotkey(neuron_data.hotkey)) - ), + f"{float(subtensor.get_total_stake_for_hotkey(neuron_data.hotkey)):.5f}", "Yes" if neuron_data.hotkey in senate_members else "No", ) @@ -288,7 +286,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): my_uid = root.hotkeys.index(wallet.hotkey.ss58_address) except ValueError: bittensor.__console__.print( - "Wallet hotkey: {} not found in root metagraph".format(wallet.hotkey) + f"Wallet hotkey: {wallet.hotkey} not found in root metagraph" ) exit() my_weights = root.weights[my_uid] @@ -332,9 +330,9 @@ def check_config(config: "bittensor.config"): hotkey = Prompt.ask("Enter hotkey name", default=defaults.wallet.hotkey) config.wallet.hotkey = str(hotkey) if not config.is_set("netuid") and not config.no_prompt: - config.netuid = int(Prompt.ask(f"Enter netuid (e.g. 1)")) + config.netuid = int(Prompt.ask("Enter netuid (e.g. 1)")) if not config.is_set("amount") and not config.no_prompt: - config.amount = float(Prompt.ask(f"Enter amount (e.g. 0.01)")) + config.amount = float(Prompt.ask("Enter amount (e.g. 0.01)")) class RootSetSlashCommand: @@ -401,16 +399,14 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): wallet = bittensor.wallet(config=cli.config) bittensor.__console__.print( - "Slashing weight for subnet: {} by amount: {}".format( - cli.config.netuid, cli.config.amount - ) + f"Slashing weight for subnet: {cli.config.netuid} by amount: {cli.config.amount}" ) root = subtensor.metagraph(0, lite=False) try: my_uid = root.hotkeys.index(wallet.hotkey.ss58_address) except ValueError: bittensor.__console__.print( - "Wallet hotkey: {} not found in root metagraph".format(wallet.hotkey) + f"Wallet hotkey: {wallet.hotkey} not found in root metagraph" ) exit() my_weights = root.weights[my_uid] @@ -448,9 +444,9 @@ def check_config(config: "bittensor.config"): hotkey = Prompt.ask("Enter hotkey name", default=defaults.wallet.hotkey) config.wallet.hotkey = str(hotkey) if not config.is_set("netuid") and not config.no_prompt: - config.netuid = int(Prompt.ask(f"Enter netuid (e.g. 1)")) + config.netuid = int(Prompt.ask("Enter netuid (e.g. 1)")) if not config.is_set("amount") and not config.no_prompt: - config.amount = float(Prompt.ask(f"Enter decrease amount (e.g. 0.01)")) + config.amount = float(Prompt.ask("Enter decrease amount (e.g. 0.01)")) class RootSetWeightsCommand: @@ -507,7 +503,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): map( str, [ - "{:.2f}".format(float(1 / len(subnets))) + f"{float(1 / len(subnets)):.2f}" for subnet in subnets ][:3], ) @@ -655,7 +651,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): for netuid in netuids: if netuid in uid_weights: normalized_weight = uid_weights[netuid] - row.append("{:0.2f}%".format(normalized_weight * 100)) + row.append(f"{normalized_weight * 100:0.2f}%") else: row.append("-") table.add_row(*row) diff --git a/bittensor/commands/senate.py b/bittensor/commands/senate.py index 03a73cde5b..4a66217bb7 100644 --- a/bittensor/commands/senate.py +++ b/bittensor/commands/senate.py @@ -17,12 +17,15 @@ import argparse -import bittensor -from rich.prompt import Prompt, Confirm +from typing import Dict, Optional + +from rich.prompt import Confirm, Prompt from rich.table import Table -from typing import Optional, Dict -from .utils import get_delegates_details, DelegatesDetails + +import bittensor + from . import defaults +from .utils import DelegatesDetails, get_delegates_details console = bittensor.__console__ @@ -64,9 +67,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""View Bittensor's governance protocol proposals""" console = bittensor.__console__ console.print( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - cli.config.subtensor.network - ) + f":satellite: Syncing with chain: [white]{cli.config.subtensor.network}[/white] ..." ) senate_members = subtensor.get_senate_members() @@ -203,9 +204,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""View Bittensor's governance protocol proposals""" console = bittensor.__console__ console.print( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ) senate_members = subtensor.get_senate_members() @@ -217,9 +216,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): table = Table(show_footer=False) table.title = ( - "[white]Proposals\t\tActive Proposals: {}\t\tSenate Size: {}".format( - len(proposals), len(senate_members) - ) + f"[white]Proposals\t\tActive Proposals: {len(proposals)}\t\tSenate Size: {len(senate_members)}" ) table.add_column( "[overline white]HASH", @@ -325,9 +322,7 @@ def run(cli: "bittensor.cli"): def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""View Bittensor's governance protocol proposals active votes""" console.print( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - cli.config.subtensor.network - ) + f":satellite: Syncing with chain: [white]{cli.config.subtensor.network}[/white] ..." ) proposal_hash = cli.config.proposal_hash @@ -347,7 +342,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table = Table(show_footer=False) - table.title = "[white]Votes for Proposal {}".format(proposal_hash) + table.title = f"[white]Votes for Proposal {proposal_hash}" table.add_column( "[overline white]ADDRESS", footer_style="overline white", @@ -437,17 +432,13 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Check if the hotkey is a delegate. if not subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address): console.print( - "Aborting: Hotkey {} isn't a delegate.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} isn't a delegate." ) return if subtensor.is_senate_member(hotkey_ss58=wallet.hotkey.ss58_address): console.print( - "Aborting: Hotkey {} is already a senate member.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} is already a senate member." ) return @@ -518,9 +509,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.cli"): if not subtensor.is_senate_member(hotkey_ss58=wallet.hotkey.ss58_address): console.print( - "Aborting: Hotkey {} isn't a senate member.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} isn't a senate member." ) return @@ -595,9 +584,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): if not subtensor.is_senate_member(hotkey_ss58=wallet.hotkey.ss58_address): console.print( - "Aborting: Hotkey {} isn't a senate member.".format( - wallet.hotkey.ss58_address - ) + f"Aborting: Hotkey {wallet.hotkey.ss58_address} isn't a senate member." ) return diff --git a/bittensor/commands/stake.py b/bittensor/commands/stake.py index 1bc2cf2786..e98ecc3c15 100644 --- a/bittensor/commands/stake.py +++ b/bittensor/commands/stake.py @@ -18,7 +18,7 @@ import argparse import os import sys -from typing import List, Union, Optional, Dict, Tuple +from typing import Dict, List, Optional, Tuple, Union from rich.prompt import Confirm, Prompt from rich.table import Table @@ -26,12 +26,13 @@ import bittensor from bittensor.utils.balance import Balance + +from . import defaults from .utils import ( - get_hotkey_wallets_for_wallet, - get_delegates_details, DelegatesDetails, + get_delegates_details, + get_hotkey_wallets_for_wallet, ) -from . import defaults console = bittensor.__console__ @@ -250,9 +251,7 @@ def check_config(cls, config: "bittensor.config"): config.amount = float(amount) except ValueError: console.print( - ":cross_mark:[red]Invalid Tao amount[/red] [bold white]{}[/bold white]".format( - amount - ) + f":cross_mark:[red]Invalid Tao amount[/red] [bold white]{amount}[/bold white]" ) sys.exit() else: @@ -515,7 +514,7 @@ def get_all_wallet_accounts( ) table.add_column( "[overline white]Balance", - "\u03c4{:.5f}".format(total_balance), + f"\u03c4{total_balance:.5f}", footer_style="overline white", style="green", ) @@ -524,13 +523,13 @@ def get_all_wallet_accounts( ) table.add_column( "[overline white]Stake", - "\u03c4{:.5f}".format(total_stake), + f"\u03c4{total_stake:.5f}", footer_style="overline white", style="green", ) table.add_column( "[overline white]Rate", - "\u03c4{:.5f}/d".format(total_rate), + f"\u03c4{total_rate:.5f}/d", footer_style="overline white", style="green", ) diff --git a/bittensor/commands/transfer.py b/bittensor/commands/transfer.py index 24c6e78402..f23f33471d 100644 --- a/bittensor/commands/transfer.py +++ b/bittensor/commands/transfer.py @@ -16,10 +16,13 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import sys import argparse -import bittensor +import sys + from rich.prompt import Prompt + +import bittensor + from . import defaults console = bittensor.__console__ @@ -95,7 +98,7 @@ def check_config(config: "bittensor.config"): with bittensor.__console__.status(":satellite: Checking Balance..."): account_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) bittensor.__console__.print( - "Balance: [green]{}[/green]".format(account_balance) + f"Balance: [green]{account_balance}[/green]" ) # Get amount. @@ -106,16 +109,12 @@ def check_config(config: "bittensor.config"): config.amount = float(amount) except ValueError: console.print( - ":cross_mark:[red] Invalid TAO amount[/red] [bold white]{}[/bold white]".format( - amount - ) + f":cross_mark:[red] Invalid TAO amount[/red] [bold white]{amount}[/bold white]" ) sys.exit() else: console.print( - ":cross_mark:[red] Invalid TAO amount[/red] [bold white]{}[/bold white]".format( - amount - ) + f":cross_mark:[red] Invalid TAO amount[/red] [bold white]{amount}[/bold white]" ) sys.exit(1) diff --git a/bittensor/commands/unstake.py b/bittensor/commands/unstake.py index 87d13aab91..2634ec90c2 100644 --- a/bittensor/commands/unstake.py +++ b/bittensor/commands/unstake.py @@ -16,13 +16,16 @@ # DEALINGS IN THE SOFTWARE. import sys -import bittensor -from tqdm import tqdm +from typing import List, Optional, Tuple, Union + from rich.prompt import Confirm, Prompt +from tqdm import tqdm + +import bittensor from bittensor.utils.balance import Balance -from typing import List, Union, Optional, Tuple -from .utils import get_hotkey_wallets_for_wallet + from . import defaults +from .utils import get_hotkey_wallets_for_wallet console = bittensor.__console__ diff --git a/bittensor/commands/utils.py b/bittensor/commands/utils.py index 4ea8fa3dd1..cf5fe25aaf 100644 --- a/bittensor/commands/utils.py +++ b/bittensor/commands/utils.py @@ -15,14 +15,17 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import sys import os -import bittensor +import sys +from dataclasses import dataclass +from typing import Any, Dict, List, Optional + import requests -from bittensor.utils.registration import torch -from typing import List, Dict, Any, Optional from rich.prompt import Confirm, PromptBase -from dataclasses import dataclass + +import bittensor +from bittensor.utils.registration import torch + from . import defaults console = bittensor.__console__ @@ -98,7 +101,7 @@ def check_for_cuda_reg_config(config: "bittensor.config") -> None: console.print("Available CUDA devices:") choices_str: str = "" for i, device in enumerate(devices): - choices_str += " {}: {}\n".format(device, device_names[i]) + choices_str += f" {device}: {device_names[i]}\n" console.print(choices_str) dev_id = IntListPrompt.ask( "Which GPU(s) would you like to use? Please list one, or comma-separated", @@ -117,9 +120,7 @@ def check_for_cuda_reg_config(config: "bittensor.config") -> None: ] except ValueError: console.log( - ":cross_mark:[red]Invalid GPU device[/red] [bold white]{}[/bold white]\nAvailable CUDA devices:{}".format( - dev_id, choices_str - ) + f":cross_mark:[red]Invalid GPU device[/red] [bold white]{dev_id}[/bold white]\nAvailable CUDA devices:{choices_str}" ) sys.exit(1) config.pow_register.cuda.dev_id = dev_id diff --git a/bittensor/commands/wallets.py b/bittensor/commands/wallets.py index 0f665db7e4..8c3b2b184c 100644 --- a/bittensor/commands/wallets.py +++ b/bittensor/commands/wallets.py @@ -16,15 +16,18 @@ # DEALINGS IN THE SOFTWARE. import argparse -import bittensor import os import sys -from rich.prompt import Prompt, Confirm -from rich.table import Table -from typing import Optional, List, Tuple -from . import defaults +from typing import List, Optional, Tuple + import requests +from rich.prompt import Confirm, Prompt +from rich.table import Table + +import bittensor + from ..utils import RAOPERTAO +from . import defaults class RegenColdkeyCommand: @@ -63,8 +66,8 @@ def run(cli): if cli.config.get("json"): file_name: str = cli.config.get("json") if not os.path.exists(file_name) or not os.path.isfile(file_name): - raise ValueError("File {} does not exist".format(file_name)) - with open(cli.config.get("json"), "r") as f: + raise ValueError(f"File {file_name} does not exist") + with open(cli.config.get("json")) as f: json_str = f.read() # Password can be "", assume if None json_password = cli.config.get("json_password", "") @@ -275,8 +278,8 @@ def run(cli): if cli.config.get("json"): file_name: str = cli.config.get("json") if not os.path.exists(file_name) or not os.path.isfile(file_name): - raise ValueError("File {} does not exist".format(file_name)) - with open(cli.config.get("json"), "r") as f: + raise ValueError(f"File {file_name} does not exist") + with open(cli.config.get("json")) as f: json_str = f.read() # Password can be "", assume if None diff --git a/bittensor/commands/weights.py b/bittensor/commands/weights.py index ac4d9dfc36..218ae7c627 100644 --- a/bittensor/commands/weights.py +++ b/bittensor/commands/weights.py @@ -24,10 +24,11 @@ import re import numpy as np -from rich.prompt import Prompt, Confirm +from rich.prompt import Confirm, Prompt import bittensor import bittensor.utils.weight_utils as weight_utils + from . import defaults # type: ignore @@ -70,13 +71,13 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Get values if not set if not cli.config.is_set("netuid"): - cli.config.netuid = int(Prompt.ask(f"Enter netuid")) + cli.config.netuid = int(Prompt.ask("Enter netuid")) if not cli.config.is_set("uids"): - cli.config.uids = Prompt.ask(f"Enter UIDs (comma-separated)") + cli.config.uids = Prompt.ask("Enter UIDs (comma-separated)") if not cli.config.is_set("weights"): - cli.config.weights = Prompt.ask(f"Enter weights (comma-separated)") + cli.config.weights = Prompt.ask("Enter weights (comma-separated)") # Parse from string netuid = cli.config.netuid @@ -120,7 +121,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Result if success: - bittensor.__console__.print(f"Weights committed successfully") + bittensor.__console__.print("Weights committed successfully") else: bittensor.__console__.print(f"Failed to commit weights: {message}") @@ -201,16 +202,16 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Get values if not set. if not cli.config.is_set("netuid"): - cli.config.netuid = int(Prompt.ask(f"Enter netuid")) + cli.config.netuid = int(Prompt.ask("Enter netuid")) if not cli.config.is_set("uids"): - cli.config.uids = Prompt.ask(f"Enter UIDs (comma-separated)") + cli.config.uids = Prompt.ask("Enter UIDs (comma-separated)") if not cli.config.is_set("weights"): - cli.config.weights = Prompt.ask(f"Enter weights (comma-separated)") + cli.config.weights = Prompt.ask("Enter weights (comma-separated)") if not cli.config.is_set("salt"): - cli.config.salt = Prompt.ask(f"Enter salt (comma-separated)") + cli.config.salt = Prompt.ask("Enter salt (comma-separated)") # Parse from string netuid = cli.config.netuid @@ -245,7 +246,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) if success: - bittensor.__console__.print(f"Weights revealed successfully") + bittensor.__console__.print("Weights revealed successfully") else: bittensor.__console__.print(f"Failed to reveal weights: {message}") diff --git a/bittensor/config.py b/bittensor/config.py index 59ad4451b8..a390312d91 100644 --- a/bittensor/config.py +++ b/bittensor/config.py @@ -20,14 +20,15 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +import argparse +import copy import os import sys -import yaml -import copy from copy import deepcopy +from typing import Any, Dict, List, Optional, Type, TypeVar + +import yaml from munch import DefaultMunch -from typing import List, Optional, Dict, Any, TypeVar, Type -import argparse class InvalidConfigFile(Exception): @@ -138,7 +139,7 @@ def __init__( + "/" + vars(parser.parse_known_args(args)[0])["config"] ) - except Exception as e: + except Exception: config_file_path = None # Parse args not strict @@ -153,10 +154,10 @@ def __init__( try: with open(config_file_path) as f: params_config = yaml.safe_load(f) - print("Loading config defaults from: {}".format(config_file_path)) + print(f"Loading config defaults from: {config_file_path}") parser.set_defaults(**params_config) except Exception as e: - print("Error in loading: {} using default parser settings".format(e)) + print(f"Error in loading: {e} using default parser settings") # 2. Continue with loading in params. params = config.__parse_args__(args=args, parser=parser, strict=strict) diff --git a/bittensor/dendrite.py b/bittensor/dendrite.py index 47a3ba6f95..16de67c921 100644 --- a/bittensor/dendrite.py +++ b/bittensor/dendrite.py @@ -20,11 +20,14 @@ from __future__ import annotations import asyncio -import uuid import time +import uuid +from collections.abc import AsyncGenerator +from typing import Any, List, Optional, Union + import aiohttp + import bittensor -from typing import Optional, List, Union, AsyncGenerator, Any from bittensor.utils.registration import torch, use_torch @@ -745,7 +748,7 @@ def __str__(self) -> str: Returns: str: The string representation of the Dendrite object in the format :func:`dendrite()`. """ - return "dendrite({})".format(self.keypair.ss58_address) + return f"dendrite({self.keypair.ss58_address})" def __repr__(self) -> str: """ @@ -815,7 +818,7 @@ def __del__(self): # For back-compatibility with torch -BaseModel: Union["torch.nn.Module", object] = torch.nn.Module if use_torch() else object +BaseModel: Union[torch.nn.Module, object] = torch.nn.Module if use_torch() else object class dendrite(DendriteMixin, BaseModel): # type: ignore diff --git a/bittensor/errors.py b/bittensor/errors.py index b8366ee681..6bbf3e2f89 100644 --- a/bittensor/errors.py +++ b/bittensor/errors.py @@ -120,7 +120,7 @@ class InvalidRequestNameError(Exception): class SynapseException(Exception): def __init__( - self, message="Synapse Exception", synapse: "bittensor.Synapse" | None = None + self, message="Synapse Exception", synapse: bittensor.Synapse | None = None ): self.message = message self.synapse = synapse @@ -179,7 +179,7 @@ class SynapseDendriteNoneException(SynapseException): def __init__( self, message="Synapse Dendrite is None", - synapse: "bittensor.Synapse" | None = None, + synapse: bittensor.Synapse | None = None, ): self.message = message super().__init__(self.message, synapse) diff --git a/bittensor/extrinsics/commit_weights.py b/bittensor/extrinsics/commit_weights.py index 2a526f5e96..e9bbd91a7a 100644 --- a/bittensor/extrinsics/commit_weights.py +++ b/bittensor/extrinsics/commit_weights.py @@ -18,7 +18,7 @@ """Module commit weights and reveal weights extrinsic.""" -from typing import Tuple, List +from typing import List, Tuple from rich.prompt import Confirm @@ -51,7 +51,7 @@ def commit_weights_extrinsic( This function provides a user-friendly interface for committing weights to the Bittensor blockchain, ensuring proper error handling and user interaction when required. """ - if prompt and not Confirm.ask(f"Would you like to commit weights?"): + if prompt and not Confirm.ask("Would you like to commit weights?"): return False, "User cancelled the operation." success, error_message = subtensor._do_commit_weights( @@ -103,7 +103,7 @@ def reveal_weights_extrinsic( error handling and user interaction when required. """ - if prompt and not Confirm.ask(f"Would you like to reveal weights?"): + if prompt and not Confirm.ask("Would you like to reveal weights?"): return False, "User cancelled the operation." success, error_message = subtensor._do_reveal_weights( diff --git a/bittensor/extrinsics/delegation.py b/bittensor/extrinsics/delegation.py index 9583b80a76..60813622d4 100644 --- a/bittensor/extrinsics/delegation.py +++ b/bittensor/extrinsics/delegation.py @@ -17,7 +17,14 @@ # DEALINGS IN THE SOFTWARE. import logging +from typing import Optional, Union + +from rich.prompt import Confirm + import bittensor +from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME +from bittensor.utils.balance import Balance + from ..errors import ( NominationError, NotDelegateError, @@ -25,10 +32,6 @@ StakeError, TakeError, ) -from rich.prompt import Confirm -from typing import Union, Optional -from bittensor.utils.balance import Balance -from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME logger = logging.getLogger(BITTENSOR_LOGGER_NAME) @@ -53,14 +56,12 @@ def nominate_extrinsic( # Check if the hotkey is already a delegate. if subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address): logger.error( - "Hotkey {} is already a delegate.".format(wallet.hotkey.ss58_address) + f"Hotkey {wallet.hotkey.ss58_address} is already a delegate." ) return False with bittensor.__console__.status( - ":satellite: Sending nominate call on [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Sending nominate call on [white]{subtensor.network}[/white] ..." ): try: success = subtensor._do_nominate( @@ -83,14 +84,14 @@ def nominate_extrinsic( except Exception as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) except NominationError as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) @@ -127,7 +128,7 @@ def delegate_extrinsic( # Decrypt keys, wallet.coldkey if not subtensor.is_hotkey_delegate(delegate_ss58): - raise NotDelegateError("Hotkey: {} is not a delegate.".format(delegate_ss58)) + raise NotDelegateError(f"Hotkey: {delegate_ss58} is not a delegate.") # Get state. my_prev_coldkey_balance = subtensor.get_balance(wallet.coldkey.ss58_address) @@ -155,26 +156,20 @@ def delegate_extrinsic( # Check enough balance to stake. if staking_balance > my_prev_coldkey_balance: bittensor.__console__.print( - ":cross_mark: [red]Not enough balance[/red]:[bold white]\n balance:{}\n amount: {}\n coldkey: {}[/bold white]".format( - my_prev_coldkey_balance, staking_balance, wallet.name - ) + f":cross_mark: [red]Not enough balance[/red]:[bold white]\n balance:{my_prev_coldkey_balance}\n amount: {staking_balance}\n coldkey: {wallet.name}[/bold white]" ) return False # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to delegate:[bold white]\n amount: {}\n to: {}\n owner: {}[/bold white]".format( - staking_balance, delegate_ss58, delegate_owner - ) + f"Do you want to delegate:[bold white]\n amount: {staking_balance}\n to: {delegate_ss58}\n owner: {delegate_owner}[/bold white]" ): return False try: with bittensor.__console__.status( - ":satellite: Staking to: [bold white]{}[/bold white] ...".format( - subtensor.network - ) + f":satellite: Staking to: [bold white]{subtensor.network}[/bold white] ..." ): staking_response: bool = subtensor._do_delegation( wallet=wallet, @@ -193,9 +188,7 @@ def delegate_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) with bittensor.__console__.status( - ":satellite: Checking Balance on: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: [white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance(address=wallet.coldkey.ss58_address) block = subtensor.get_current_block() @@ -206,14 +199,10 @@ def delegate_extrinsic( ) # Get current stake bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - my_prev_coldkey_balance, new_balance - ) + f"Balance:\n [blue]{my_prev_coldkey_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) bittensor.__console__.print( - "Stake:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - my_prev_delegated_stake, new_delegate_stake - ) + f"Stake:\n [blue]{my_prev_delegated_stake}[/blue] :arrow_right: [green]{new_delegate_stake}[/green]" ) return True else: @@ -222,15 +211,13 @@ def delegate_extrinsic( ) return False - except NotRegisteredError as e: + except NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format( - wallet.hotkey_str - ) + f":cross_mark: [red]Hotkey: {wallet.hotkey_str} is not registered.[/red]" ) return False except StakeError as e: - bittensor.__console__.print(":cross_mark: [red]Stake Error: {}[/red]".format(e)) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") return False @@ -262,7 +249,7 @@ def undelegate_extrinsic( # Decrypt keys, wallet.coldkey if not subtensor.is_hotkey_delegate(delegate_ss58): - raise NotDelegateError("Hotkey: {} is not a delegate.".format(delegate_ss58)) + raise NotDelegateError(f"Hotkey: {delegate_ss58} is not a delegate.") # Get state. my_prev_coldkey_balance = subtensor.get_balance(wallet.coldkey.ss58_address) @@ -286,26 +273,20 @@ def undelegate_extrinsic( # Check enough stake to unstake. if unstaking_balance > my_prev_delegated_stake: bittensor.__console__.print( - ":cross_mark: [red]Not enough delegated stake[/red]:[bold white]\n stake:{}\n amount: {}\n coldkey: {}[/bold white]".format( - my_prev_delegated_stake, unstaking_balance, wallet.name - ) + f":cross_mark: [red]Not enough delegated stake[/red]:[bold white]\n stake:{my_prev_delegated_stake}\n amount: {unstaking_balance}\n coldkey: {wallet.name}[/bold white]" ) return False # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to un-delegate:[bold white]\n amount: {}\n from: {}\n owner: {}[/bold white]".format( - unstaking_balance, delegate_ss58, delegate_owner - ) + f"Do you want to un-delegate:[bold white]\n amount: {unstaking_balance}\n from: {delegate_ss58}\n owner: {delegate_owner}[/bold white]" ): return False try: with bittensor.__console__.status( - ":satellite: Unstaking from: [bold white]{}[/bold white] ...".format( - subtensor.network - ) + f":satellite: Unstaking from: [bold white]{subtensor.network}[/bold white] ..." ): staking_response: bool = subtensor._do_undelegation( wallet=wallet, @@ -324,9 +305,7 @@ def undelegate_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) with bittensor.__console__.status( - ":satellite: Checking Balance on: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: [white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance(address=wallet.coldkey.ss58_address) block = subtensor.get_current_block() @@ -337,14 +316,10 @@ def undelegate_extrinsic( ) # Get current stake bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - my_prev_coldkey_balance, new_balance - ) + f"Balance:\n [blue]{my_prev_coldkey_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) bittensor.__console__.print( - "Stake:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - my_prev_delegated_stake, new_delegate_stake - ) + f"Stake:\n [blue]{my_prev_delegated_stake}[/blue] :arrow_right: [green]{new_delegate_stake}[/green]" ) return True else: @@ -353,15 +328,13 @@ def undelegate_extrinsic( ) return False - except NotRegisteredError as e: + except NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format( - wallet.hotkey_str - ) + f":cross_mark: [red]Hotkey: {wallet.hotkey_str} is not registered.[/red]" ) return False except StakeError as e: - bittensor.__console__.print(":cross_mark: [red]Stake Error: {}[/red]".format(e)) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") return False @@ -390,9 +363,7 @@ def decrease_take_extrinsic( wallet.hotkey with bittensor.__console__.status( - ":satellite: Sending decrease_take_extrinsic call on [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Sending decrease_take_extrinsic call on [white]{subtensor.network}[/white] ..." ): try: success = subtensor._do_decrease_take( @@ -416,7 +387,7 @@ def decrease_take_extrinsic( except (TakeError, Exception) as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) @@ -450,9 +421,7 @@ def increase_take_extrinsic( wallet.hotkey with bittensor.__console__.status( - ":satellite: Sending increase_take_extrinsic call on [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Sending increase_take_extrinsic call on [white]{subtensor.network}[/white] ..." ): try: success = subtensor._do_increase_take( @@ -476,14 +445,14 @@ def increase_take_extrinsic( except Exception as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) except TakeError as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) diff --git a/bittensor/extrinsics/network.py b/bittensor/extrinsics/network.py index 3e0c3d8661..def25a210e 100644 --- a/bittensor/extrinsics/network.py +++ b/bittensor/extrinsics/network.py @@ -16,10 +16,11 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. import time -import bittensor from rich.prompt import Confirm +import bittensor + def register_subnetwork_extrinsic( subtensor: "bittensor.subtensor", @@ -86,9 +87,7 @@ def register_subnetwork_extrinsic( response.process_events() if not response.is_success: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format( - response.error_message - ) + f":cross_mark: [red]Failed[/red]: error:{response.error_message}" ) time.sleep(0.5) @@ -198,9 +197,7 @@ def set_hyperparameter_extrinsic( response.process_events() if not response.is_success: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format( - response.error_message - ) + f":cross_mark: [red]Failed[/red]: error:{response.error_message}" ) time.sleep(0.5) diff --git a/bittensor/extrinsics/prometheus.py b/bittensor/extrinsics/prometheus.py index 350817e11f..1ebd0c7661 100644 --- a/bittensor/extrinsics/prometheus.py +++ b/bittensor/extrinsics/prometheus.py @@ -15,9 +15,9 @@ # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor - import json + +import bittensor import bittensor.utils.networking as net @@ -58,18 +58,14 @@ def prometheus_extrinsic( try: external_ip = net.get_external_ip() bittensor.__console__.print( - ":white_heavy_check_mark: [green]Found external ip: {}[/green]".format( - external_ip - ) + f":white_heavy_check_mark: [green]Found external ip: {external_ip}[/green]" ) bittensor.logging.success( - prefix="External IP", suffix="{}".format(external_ip) + prefix="External IP", suffix=f"{external_ip}" ) except Exception as E: raise RuntimeError( - "Unable to attain your external ip. Check your internet connection. error: {}".format( - E - ) + f"Unable to attain your external ip. Check your internet connection. error: {E}" ) from E else: external_ip = ip @@ -104,8 +100,7 @@ def prometheus_extrinsic( bittensor.__console__.print( ":white_heavy_check_mark: [white]Prometheus already served.[/white]".format( - external_ip - ) + ) ) return True @@ -113,9 +108,7 @@ def prometheus_extrinsic( call_params["netuid"] = netuid with bittensor.__console__.status( - ":satellite: Serving prometheus on: [white]{}:{}[/white] ...".format( - subtensor.network, netuid - ) + f":satellite: Serving prometheus on: [white]{subtensor.network}:{netuid}[/white] ..." ): success, err = subtensor._do_serve_prometheus( wallet=wallet, @@ -127,16 +120,12 @@ def prometheus_extrinsic( if wait_for_inclusion or wait_for_finalization: if success == True: bittensor.__console__.print( - ":white_heavy_check_mark: [green]Served prometheus[/green]\n [bold white]{}[/bold white]".format( - json.dumps(call_params, indent=4, sort_keys=True) - ) + f":white_heavy_check_mark: [green]Served prometheus[/green]\n [bold white]{json.dumps(call_params, indent=4, sort_keys=True)}[/bold white]" ) return True else: bittensor.__console__.print( - ":cross_mark: [green]Failed to serve prometheus[/green] error: {}".format( - err - ) + f":cross_mark: [green]Failed to serve prometheus[/green] error: {err}" ) return False else: diff --git a/bittensor/extrinsics/registration.py b/bittensor/extrinsics/registration.py index 879214ad92..26d5f1d473 100644 --- a/bittensor/extrinsics/registration.py +++ b/bittensor/extrinsics/registration.py @@ -16,15 +16,17 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor import time +from typing import List, Optional, Tuple, Union + from rich.prompt import Confirm -from typing import List, Union, Optional, Tuple + +import bittensor from bittensor.utils.registration import ( POWSolution, create_pow, - torch, log_no_torch_error, + torch, ) @@ -77,9 +79,7 @@ def register_extrinsic( """ if not subtensor.subnet_exists(netuid): bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error: [bold white]subnet:{}[/bold white] does not exist.".format( - netuid - ) + f":cross_mark: [red]Failed[/red]: error: [bold white]subnet:{netuid}[/bold white] does not exist." ) return False @@ -97,11 +97,7 @@ def register_extrinsic( if prompt: if not Confirm.ask( - "Continue Registration?\n hotkey: [bold white]{}[/bold white]\n coldkey: [bold white]{}[/bold white]\n network: [bold white]{}[/bold white]".format( - wallet.hotkey.ss58_address, - wallet.coldkeypub.ss58_address, - subtensor.network, - ) + f"Continue Registration?\n hotkey: [bold white]{wallet.hotkey.ss58_address}[/bold white]\n coldkey: [bold white]{wallet.coldkeypub.ss58_address}[/bold white]\n network: [bold white]{subtensor.network}[/bold white]" ): return False @@ -113,7 +109,7 @@ def register_extrinsic( attempts = 1 while True: bittensor.__console__.print( - ":satellite: Registering...({}/{})".format(attempts, max_allowed_attempts) + f":satellite: Registering...({attempts}/{max_allowed_attempts})" ) # Solve latest POW. if cuda: @@ -180,7 +176,7 @@ def register_extrinsic( return True bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(err_msg) + f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) time.sleep(0.5) @@ -211,9 +207,7 @@ def register_extrinsic( # Failed registration, retry pow attempts += 1 bittensor.__console__.print( - ":satellite: Failed registration, retrying pow ...({}/{})".format( - attempts, max_allowed_attempts - ) + f":satellite: Failed registration, retrying pow ...({attempts}/{max_allowed_attempts})" ) else: # Failed to register after max attempts. @@ -248,9 +242,7 @@ def burned_register_extrinsic( """ if not subtensor.subnet_exists(netuid): bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error: [bold white]subnet:{}[/bold white] does not exist.".format( - netuid - ) + f":cross_mark: [red]Failed[/red]: error: [bold white]subnet:{netuid}[/bold white] does not exist." ) return False @@ -268,12 +260,10 @@ def burned_register_extrinsic( if not neuron.is_null: bittensor.__console__.print( ":white_heavy_check_mark: [green]Already Registered[/green]:\n" - "uid: [bold white]{}[/bold white]\n" - "netuid: [bold white]{}[/bold white]\n" - "hotkey: [bold white]{}[/bold white]\n" - "coldkey: [bold white]{}[/bold white]".format( - neuron.uid, neuron.netuid, neuron.hotkey, neuron.coldkey - ) + f"uid: [bold white]{neuron.uid}[/bold white]\n" + f"netuid: [bold white]{neuron.netuid}[/bold white]\n" + f"hotkey: [bold white]{neuron.hotkey}[/bold white]\n" + f"coldkey: [bold white]{neuron.coldkey}[/bold white]" ) return True @@ -292,7 +282,7 @@ def burned_register_extrinsic( if success != True or success == False: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(err_msg) + f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) time.sleep(0.5) return False @@ -305,9 +295,7 @@ def burned_register_extrinsic( ) bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_balance, new_balance - ) + f"Balance:\n [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) is_registered = subtensor.is_hotkey_registered( netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address @@ -379,10 +367,7 @@ def run_faucet_extrinsic( """ if prompt: if not Confirm.ask( - "Run Faucet ?\n coldkey: [bold white]{}[/bold white]\n network: [bold white]{}[/bold white]".format( - wallet.coldkeypub.ss58_address, - subtensor.network, - ) + f"Run Faucet ?\n coldkey: [bold white]{wallet.coldkeypub.ss58_address}[/bold white]\n network: [bold white]{subtensor.network}[/bold white]" ): return False, "" @@ -508,7 +493,7 @@ def swap_hotkey_extrinsic( if success != True or success == False: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(err_msg) + f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) time.sleep(0.5) return False diff --git a/bittensor/extrinsics/root.py b/bittensor/extrinsics/root.py index 2cb11bbd69..41d91d7138 100644 --- a/bittensor/extrinsics/root.py +++ b/bittensor/extrinsics/root.py @@ -16,17 +16,18 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor - -import time import logging +import time +from typing import List, Union + import numpy as np from numpy.typing import NDArray from rich.prompt import Confirm -from typing import Union, List + +import bittensor import bittensor.utils.weight_utils as weight_utils from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME -from bittensor.utils.registration import torch, legacy_torch_api_compat +from bittensor.utils.registration import legacy_torch_api_compat, torch logger = logging.getLogger(BITTENSOR_LOGGER_NAME) @@ -61,13 +62,13 @@ def root_register_extrinsic( ) if is_registered: bittensor.__console__.print( - f":white_heavy_check_mark: [green]Already registered on root network.[/green]" + ":white_heavy_check_mark: [green]Already registered on root network.[/green]" ) return True if prompt: # Prompt user for confirmation. - if not Confirm.ask(f"Register to root network?"): + if not Confirm.ask("Register to root network?"): return False with bittensor.__console__.status(":satellite: Registering to root network..."): @@ -79,7 +80,7 @@ def root_register_extrinsic( if success != True or success == False: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(err_msg) + f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) time.sleep(0.5) @@ -148,9 +149,7 @@ def set_root_weights_extrinsic( non_zero_weights = weights[non_zero_weight_idx] if non_zero_weights.size < min_allowed_weights: raise ValueError( - "The minimum number of weights required to set weights is {}, got {}".format( - min_allowed_weights, non_zero_weights.size - ) + f"The minimum number of weights required to set weights is {min_allowed_weights}, got {non_zero_weights.size}" ) # Normalize the weights to max value. @@ -164,16 +163,12 @@ def set_root_weights_extrinsic( # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to set the following root weights?:\n[bold white] weights: {}\n uids: {}[/bold white ]?".format( - formatted_weights, netuids - ) + f"Do you want to set the following root weights?:\n[bold white] weights: {formatted_weights}\n uids: {netuids}[/bold white ]?" ): return False with bittensor.__console__.status( - ":satellite: Setting root weights on [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Setting root weights on [white]{subtensor.network}[/white] ..." ): try: weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit( @@ -205,7 +200,7 @@ def set_root_weights_extrinsic( return True else: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(error_message) + f":cross_mark: [red]Failed[/red]: error:{error_message}" ) bittensor.logging.warning( prefix="Set weights", @@ -216,7 +211,7 @@ def set_root_weights_extrinsic( except Exception as e: # TODO( devs ): lets remove all of the bittensor.__console__ calls and replace with the bittensor logger. bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) diff --git a/bittensor/extrinsics/senate.py b/bittensor/extrinsics/senate.py index 233a78d614..493eeb8043 100644 --- a/bittensor/extrinsics/senate.py +++ b/bittensor/extrinsics/senate.py @@ -17,11 +17,12 @@ # DEALINGS IN THE SOFTWARE. # Imports -import bittensor - import time + from rich.prompt import Confirm +import bittensor + def register_senate_extrinsic( subtensor: "bittensor.subtensor", @@ -50,7 +51,7 @@ def register_senate_extrinsic( if prompt: # Prompt user for confirmation. - if not Confirm.ask(f"Register delegate hotkey to senate?"): + if not Confirm.ask("Register delegate hotkey to senate?"): return False with bittensor.__console__.status(":satellite: Registering with senate..."): @@ -78,9 +79,7 @@ def register_senate_extrinsic( response.process_events() if not response.is_success: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format( - response.error_message - ) + f":cross_mark: [red]Failed[/red]: error:{response.error_message}" ) time.sleep(0.5) @@ -127,7 +126,7 @@ def leave_senate_extrinsic( if prompt: # Prompt user for confirmation. - if not Confirm.ask(f"Remove delegate hotkey from senate?"): + if not Confirm.ask("Remove delegate hotkey from senate?"): return False with bittensor.__console__.status(":satellite: Leaving senate..."): @@ -155,9 +154,7 @@ def leave_senate_extrinsic( response.process_events() if not response.is_success: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format( - response.error_message - ) + f":cross_mark: [red]Failed[/red]: error:{response.error_message}" ) time.sleep(0.5) @@ -207,7 +204,7 @@ def vote_senate_extrinsic( if prompt: # Prompt user for confirmation. - if not Confirm.ask("Cast a vote of {}?".format(vote)): + if not Confirm.ask(f"Cast a vote of {vote}?"): return False with bittensor.__console__.status(":satellite: Casting vote.."): @@ -240,9 +237,7 @@ def vote_senate_extrinsic( response.process_events() if not response.is_success: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format( - response.error_message - ) + f":cross_mark: [red]Failed[/red]: error:{response.error_message}" ) time.sleep(0.5) diff --git a/bittensor/extrinsics/serving.py b/bittensor/extrinsics/serving.py index 1aefa091ad..1d1dcf8607 100644 --- a/bittensor/extrinsics/serving.py +++ b/bittensor/extrinsics/serving.py @@ -16,9 +16,12 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. import json + +from rich.prompt import Confirm + import bittensor import bittensor.utils.networking as net -from rich.prompt import Confirm + from ..errors import MetadataError @@ -106,9 +109,7 @@ def serve_extrinsic( output["coldkey"] = wallet.coldkeypub.ss58_address output["hotkey"] = wallet.hotkey.ss58_address if not Confirm.ask( - "Do you want to serve axon:\n [bold white]{}[/bold white]".format( - json.dumps(output, indent=4, sort_keys=True) - ) + f"Do you want to serve axon:\n [bold white]{json.dumps(output, indent=4, sort_keys=True)}[/bold white]" ): return False @@ -171,18 +172,14 @@ def serve_axon_extrinsic( try: external_ip = net.get_external_ip() bittensor.__console__.print( - ":white_heavy_check_mark: [green]Found external ip: {}[/green]".format( - external_ip - ) + f":white_heavy_check_mark: [green]Found external ip: {external_ip}[/green]" ) bittensor.logging.success( - prefix="External IP", suffix="{}".format(external_ip) + prefix="External IP", suffix=f"{external_ip}" ) except Exception as E: raise RuntimeError( - "Unable to attain your external ip. Check your internet connection. error: {}".format( - E - ) + f"Unable to attain your external ip. Check your internet connection. error: {E}" ) from E else: external_ip = axon.external_ip @@ -262,9 +259,10 @@ def publish_metadata( raise MetadataError(response.error_message) -from retry import retry from typing import Optional +from retry import retry + def get_metadata(self, netuid: int, hotkey: str, block: Optional[int] = None) -> str: @retry(delay=2, tries=3, backoff=2, max_delay=4) diff --git a/bittensor/extrinsics/set_weights.py b/bittensor/extrinsics/set_weights.py index 5db0a1a7a9..b9ee35e555 100644 --- a/bittensor/extrinsics/set_weights.py +++ b/bittensor/extrinsics/set_weights.py @@ -16,13 +16,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor - import logging +from typing import Tuple, Union + import numpy as np from numpy.typing import NDArray from rich.prompt import Confirm -from typing import Union, Tuple + +import bittensor import bittensor.utils.weight_utils as weight_utils from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME from bittensor.utils.registration import torch, use_torch @@ -86,14 +87,12 @@ def set_weights_extrinsic( # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to set weights:\n[bold white] weights: {}\n uids: {}[/bold white ]?".format( - [float(v / 65535) for v in weight_vals], weight_uids - ) + f"Do you want to set weights:\n[bold white] weights: {[float(v / 65535) for v in weight_vals]}\n uids: {weight_uids}[/bold white ]?" ): return False, "Prompt refused." with bittensor.__console__.status( - ":satellite: Setting weights on [white]{}[/white] ...".format(subtensor.network) + f":satellite: Setting weights on [white]{subtensor.network}[/white] ..." ): try: success, error_message = subtensor._do_set_weights( @@ -120,7 +119,7 @@ def set_weights_extrinsic( return True, "Successfully set weights and Finalized." else: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(error_message) + f":cross_mark: [red]Failed[/red]: error:{error_message}" ) bittensor.logging.warning( prefix="Set weights", @@ -130,7 +129,7 @@ def set_weights_extrinsic( except Exception as e: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(e) + f":cross_mark: [red]Failed[/red]: error:{e}" ) bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) diff --git a/bittensor/extrinsics/staking.py b/bittensor/extrinsics/staking.py index f3249a8b1c..aa6ce47da2 100644 --- a/bittensor/extrinsics/staking.py +++ b/bittensor/extrinsics/staking.py @@ -16,10 +16,12 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor -from rich.prompt import Confirm from time import sleep -from typing import List, Union, Optional +from typing import List, Optional, Union + +from rich.prompt import Confirm + +import bittensor from bittensor.utils.balance import Balance @@ -68,9 +70,7 @@ def add_stake_extrinsic( own_hotkey: bool with bittensor.__console__.status( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ): old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) # Get hotkey owner @@ -80,7 +80,7 @@ def add_stake_extrinsic( # This is not the wallet's own hotkey so we are delegating. if not subtensor.is_hotkey_delegate(hotkey_ss58): raise bittensor.errors.NotDelegateError( - "Hotkey: {} is not a delegate.".format(hotkey_ss58) + f"Hotkey: {hotkey_ss58} is not a delegate." ) # Get hotkey take @@ -109,9 +109,7 @@ def add_stake_extrinsic( # Check enough to stake. if staking_balance > old_balance: bittensor.__console__.print( - ":cross_mark: [red]Not enough stake[/red]:[bold white]\n balance:{}\n amount: {}\n coldkey: {}[/bold white]".format( - old_balance, staking_balance, wallet.name - ) + f":cross_mark: [red]Not enough stake[/red]:[bold white]\n balance:{old_balance}\n amount: {staking_balance}\n coldkey: {wallet.name}[/bold white]" ) return False @@ -120,24 +118,18 @@ def add_stake_extrinsic( if not own_hotkey: # We are delegating. if not Confirm.ask( - "Do you want to delegate:[bold white]\n amount: {}\n to: {}\n take: {}\n owner: {}[/bold white]".format( - staking_balance, wallet.hotkey_str, hotkey_take, hotkey_owner - ) + f"Do you want to delegate:[bold white]\n amount: {staking_balance}\n to: {wallet.hotkey_str}\n take: {hotkey_take}\n owner: {hotkey_owner}[/bold white]" ): return False else: if not Confirm.ask( - "Do you want to stake:[bold white]\n amount: {}\n to: {}[/bold white]".format( - staking_balance, wallet.hotkey_str - ) + f"Do you want to stake:[bold white]\n amount: {staking_balance}\n to: {wallet.hotkey_str}[/bold white]" ): return False try: with bittensor.__console__.status( - ":satellite: Staking to: [bold white]{}[/bold white] ...".format( - subtensor.network - ) + f":satellite: Staking to: [bold white]{subtensor.network}[/bold white] ..." ): staking_response: bool = __do_add_stake_single( subtensor=subtensor, @@ -157,9 +149,7 @@ def add_stake_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) with bittensor.__console__.status( - ":satellite: Checking Balance on: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: [white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance( address=wallet.coldkeypub.ss58_address @@ -172,14 +162,10 @@ def add_stake_extrinsic( ) # Get current stake bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_balance, new_balance - ) + f"Balance:\n [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) bittensor.__console__.print( - "Stake:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_stake, new_stake - ) + f"Stake:\n [blue]{old_stake}[/blue] :arrow_right: [green]{new_stake}[/green]" ) return True else: @@ -188,15 +174,13 @@ def add_stake_extrinsic( ) return False - except bittensor.errors.NotRegisteredError as e: + except bittensor.errors.NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format( - wallet.hotkey_str - ) + f":cross_mark: [red]Hotkey: {wallet.hotkey_str} is not registered.[/red]" ) return False except bittensor.errors.StakeError as e: - bittensor.__console__.print(":cross_mark: [red]Stake Error: {}[/red]".format(e)) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") return False @@ -264,9 +248,7 @@ def add_stake_multiple_extrinsic( old_stakes = [] with bittensor.__console__.status( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ): old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) @@ -317,18 +299,14 @@ def add_stake_multiple_extrinsic( # Check enough to stake if staking_balance > old_balance: bittensor.__console__.print( - ":cross_mark: [red]Not enough balance[/red]: [green]{}[/green] to stake: [blue]{}[/blue] from coldkey: [white]{}[/white]".format( - old_balance, staking_balance, wallet.name - ) + f":cross_mark: [red]Not enough balance[/red]: [green]{old_balance}[/green] to stake: [blue]{staking_balance}[/blue] from coldkey: [white]{wallet.name}[/white]" ) continue # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to stake:\n[bold white] amount: {}\n hotkey: {}[/bold white ]?".format( - staking_balance, wallet.hotkey_str - ) + f"Do you want to stake:\n[bold white] amount: {staking_balance}\n hotkey: {wallet.hotkey_str}[/bold white ]?" ): continue @@ -350,9 +328,7 @@ def add_stake_multiple_extrinsic( tx_rate_limit_blocks = subtensor.tx_rate_limit() if tx_rate_limit_blocks > 0: bittensor.__console__.print( - ":hourglass: [yellow]Waiting for tx rate limit: [white]{}[/white] blocks[/yellow]".format( - tx_rate_limit_blocks - ) + f":hourglass: [yellow]Waiting for tx rate limit: [white]{tx_rate_limit_blocks}[/white] blocks[/yellow]" ) sleep(tx_rate_limit_blocks * 12) # 12 seconds per block @@ -379,9 +355,7 @@ def add_stake_multiple_extrinsic( wallet.coldkeypub.ss58_address, block=block ) bittensor.__console__.print( - "Stake ({}): [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - hotkey_ss58, old_stake, new_stake - ) + f"Stake ({hotkey_ss58}): [blue]{old_stake}[/blue] :arrow_right: [green]{new_stake}[/green]" ) old_balance = new_balance successful_stakes += 1 @@ -395,30 +369,24 @@ def add_stake_multiple_extrinsic( ) continue - except bittensor.errors.NotRegisteredError as e: + except bittensor.errors.NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format( - hotkey_ss58 - ) + f":cross_mark: [red]Hotkey: {hotkey_ss58} is not registered.[/red]" ) continue except bittensor.errors.StakeError as e: bittensor.__console__.print( - ":cross_mark: [red]Stake Error: {}[/red]".format(e) + f":cross_mark: [red]Stake Error: {e}[/red]" ) continue if successful_stakes != 0: with bittensor.__console__.status( - ":satellite: Checking Balance on: ([white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: ([white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) bittensor.__console__.print( - "Balance: [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_balance, new_balance - ) + f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) return True @@ -471,7 +439,7 @@ def __do_add_stake_single( # Verify that the hotkey is a delegate. if not subtensor.is_hotkey_delegate(hotkey_ss58=hotkey_ss58): raise bittensor.errors.NotDelegateError( - "Hotkey: {} is not a delegate.".format(hotkey_ss58) + f"Hotkey: {hotkey_ss58} is not a delegate." ) success = subtensor._do_stake( diff --git a/bittensor/extrinsics/transfer.py b/bittensor/extrinsics/transfer.py index ae09803199..aa7e02afb0 100644 --- a/bittensor/extrinsics/transfer.py +++ b/bittensor/extrinsics/transfer.py @@ -16,12 +16,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor +from typing import Union from rich.prompt import Confirm -from typing import Union -from ..utils.balance import Balance + +import bittensor + from ..utils import is_valid_bittensor_address_or_public_key +from ..utils.balance import Balance def transfer_extrinsic( @@ -58,9 +60,7 @@ def transfer_extrinsic( # Validate destination address. if not is_valid_bittensor_address_or_public_key(dest): bittensor.__console__.print( - ":cross_mark: [red]Invalid destination address[/red]:[bold white]\n {}[/bold white]".format( - dest - ) + f":cross_mark: [red]Invalid destination address[/red]:[bold white]\n {dest}[/bold white]" ) return False @@ -95,18 +95,14 @@ def transfer_extrinsic( # Check if we have enough balance. if account_balance < (transfer_balance + fee + existential_deposit): bittensor.__console__.print( - ":cross_mark: [red]Not enough balance[/red]:[bold white]\n balance: {}\n amount: {}\n for fee: {}[/bold white]".format( - account_balance, transfer_balance, fee - ) + f":cross_mark: [red]Not enough balance[/red]:[bold white]\n balance: {account_balance}\n amount: {transfer_balance}\n for fee: {fee}[/bold white]" ) return False # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to transfer:[bold white]\n amount: {}\n from: {}:{}\n to: {}\n for fee: {}[/bold white]".format( - transfer_balance, wallet.name, wallet.coldkey.ss58_address, dest, fee - ) + f"Do you want to transfer:[bold white]\n amount: {transfer_balance}\n from: {wallet.name}:{wallet.coldkey.ss58_address}\n to: {dest}\n for fee: {fee}[/bold white]" ): return False @@ -124,7 +120,7 @@ def transfer_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) bittensor.__console__.print( - "[green]Block Hash: {}[/green]".format(block_hash) + f"[green]Block Hash: {block_hash}[/green]" ) explorer_urls = bittensor.utils.get_explorer_url_for_network( @@ -143,16 +139,14 @@ def transfer_extrinsic( ) else: bittensor.__console__.print( - ":cross_mark: [red]Failed[/red]: error:{}".format(err_msg) + f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) if success: with bittensor.__console__.status(":satellite: Checking Balance..."): new_balance = subtensor.get_balance(wallet.coldkey.ss58_address) bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - account_balance, new_balance - ) + f"Balance:\n [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) return True diff --git a/bittensor/extrinsics/unstaking.py b/bittensor/extrinsics/unstaking.py index 6046124f40..2cf8a65b02 100644 --- a/bittensor/extrinsics/unstaking.py +++ b/bittensor/extrinsics/unstaking.py @@ -16,10 +16,12 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor -from rich.prompt import Confirm from time import sleep -from typing import List, Union, Optional +from typing import List, Optional, Union + +from rich.prompt import Confirm + +import bittensor from bittensor.utils.balance import Balance @@ -132,9 +134,7 @@ def unstake_extrinsic( hotkey_ss58 = wallet.hotkey.ss58_address # Default to wallet's own hotkey. with bittensor.__console__.status( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ): old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) old_stake = subtensor.get_stake_for_coldkey_and_hotkey( @@ -154,9 +154,7 @@ def unstake_extrinsic( stake_on_uid = old_stake if unstaking_balance > stake_on_uid: bittensor.__console__.print( - ":cross_mark: [red]Not enough stake[/red]: [green]{}[/green] to unstake: [blue]{}[/blue] from hotkey: [white]{}[/white]".format( - stake_on_uid, unstaking_balance, wallet.hotkey_str - ) + f":cross_mark: [red]Not enough stake[/red]: [green]{stake_on_uid}[/green] to unstake: [blue]{unstaking_balance}[/blue] from hotkey: [white]{wallet.hotkey_str}[/white]" ) return False @@ -168,17 +166,13 @@ def unstake_extrinsic( # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to unstake:\n[bold white] amount: {}\n hotkey: {}[/bold white ]?".format( - unstaking_balance, wallet.hotkey_str - ) + f"Do you want to unstake:\n[bold white] amount: {unstaking_balance}\n hotkey: {wallet.hotkey_str}[/bold white ]?" ): return False try: with bittensor.__console__.status( - ":satellite: Unstaking from chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Unstaking from chain: [white]{subtensor.network}[/white] ..." ): staking_response: bool = __do_remove_stake_single( subtensor=subtensor, @@ -198,9 +192,7 @@ def unstake_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) with bittensor.__console__.status( - ":satellite: Checking Balance on: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: [white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance( address=wallet.coldkeypub.ss58_address @@ -209,14 +201,10 @@ def unstake_extrinsic( coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58 ) # Get stake on hotkey. bittensor.__console__.print( - "Balance:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_balance, new_balance - ) + f"Balance:\n [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) bittensor.__console__.print( - "Stake:\n [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_stake, new_stake - ) + f"Stake:\n [blue]{old_stake}[/blue] :arrow_right: [green]{new_stake}[/green]" ) return True else: @@ -225,15 +213,13 @@ def unstake_extrinsic( ) return False - except bittensor.errors.NotRegisteredError as e: + except bittensor.errors.NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format( - wallet.hotkey_str - ) + f":cross_mark: [red]Hotkey: {wallet.hotkey_str} is not registered.[/red]" ) return False except bittensor.errors.StakeError as e: - bittensor.__console__.print(":cross_mark: [red]Stake Error: {}[/red]".format(e)) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") return False @@ -301,9 +287,7 @@ def unstake_multiple_extrinsic( old_stakes = [] with bittensor.__console__.status( - ":satellite: Syncing with chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." ): old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) @@ -330,9 +314,7 @@ def unstake_multiple_extrinsic( stake_on_uid = old_stake if unstaking_balance > stake_on_uid: bittensor.__console__.print( - ":cross_mark: [red]Not enough stake[/red]: [green]{}[/green] to unstake: [blue]{}[/blue] from hotkey: [white]{}[/white]".format( - stake_on_uid, unstaking_balance, wallet.hotkey_str - ) + f":cross_mark: [red]Not enough stake[/red]: [green]{stake_on_uid}[/green] to unstake: [blue]{unstaking_balance}[/blue] from hotkey: [white]{wallet.hotkey_str}[/white]" ) continue @@ -344,17 +326,13 @@ def unstake_multiple_extrinsic( # Ask before moving on. if prompt: if not Confirm.ask( - "Do you want to unstake:\n[bold white] amount: {}\n hotkey: {}[/bold white ]?".format( - unstaking_balance, wallet.hotkey_str - ) + f"Do you want to unstake:\n[bold white] amount: {unstaking_balance}\n hotkey: {wallet.hotkey_str}[/bold white ]?" ): continue try: with bittensor.__console__.status( - ":satellite: Unstaking from chain: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Unstaking from chain: [white]{subtensor.network}[/white] ..." ): staking_response: bool = __do_remove_stake_single( subtensor=subtensor, @@ -373,9 +351,7 @@ def unstake_multiple_extrinsic( tx_rate_limit_blocks = subtensor.tx_rate_limit() if tx_rate_limit_blocks > 0: bittensor.__console__.print( - ":hourglass: [yellow]Waiting for tx rate limit: [white]{}[/white] blocks[/yellow]".format( - tx_rate_limit_blocks - ) + f":hourglass: [yellow]Waiting for tx rate limit: [white]{tx_rate_limit_blocks}[/white] blocks[/yellow]" ) sleep(tx_rate_limit_blocks * 12) # 12 seconds per block @@ -387,9 +363,7 @@ def unstake_multiple_extrinsic( ":white_heavy_check_mark: [green]Finalized[/green]" ) with bittensor.__console__.status( - ":satellite: Checking Balance on: [white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: [white]{subtensor.network}[/white] ..." ): block = subtensor.get_current_block() new_stake = subtensor.get_stake_for_coldkey_and_hotkey( @@ -398,9 +372,7 @@ def unstake_multiple_extrinsic( block=block, ) bittensor.__console__.print( - "Stake ({}): [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - hotkey_ss58, stake_on_uid, new_stake - ) + f"Stake ({hotkey_ss58}): [blue]{stake_on_uid}[/blue] :arrow_right: [green]{new_stake}[/green]" ) successful_unstakes += 1 else: @@ -409,28 +381,24 @@ def unstake_multiple_extrinsic( ) continue - except bittensor.errors.NotRegisteredError as e: + except bittensor.errors.NotRegisteredError: bittensor.__console__.print( - ":cross_mark: [red]{} is not registered.[/red]".format(hotkey_ss58) + f":cross_mark: [red]{hotkey_ss58} is not registered.[/red]" ) continue except bittensor.errors.StakeError as e: bittensor.__console__.print( - ":cross_mark: [red]Stake Error: {}[/red]".format(e) + f":cross_mark: [red]Stake Error: {e}[/red]" ) continue if successful_unstakes != 0: with bittensor.__console__.status( - ":satellite: Checking Balance on: ([white]{}[/white] ...".format( - subtensor.network - ) + f":satellite: Checking Balance on: ([white]{subtensor.network}[/white] ..." ): new_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) bittensor.__console__.print( - "Balance: [blue]{}[/blue] :arrow_right: [green]{}[/green]".format( - old_balance, new_balance - ) + f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]" ) return True diff --git a/bittensor/keyfile.py b/bittensor/keyfile.py index b5157cea4a..d9799616da 100644 --- a/bittensor/keyfile.py +++ b/bittensor/keyfile.py @@ -15,29 +15,29 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import os import base64 +import getpass import json +import os import stat -import getpass -import bittensor -from bittensor.errors import KeyFileError -from typing import Optional from pathlib import Path +from typing import Optional -from ansible_vault import Vault from ansible.parsing.vault import AnsibleVaultError -from cryptography.exceptions import InvalidSignature, InvalidKey +from ansible_vault import Vault +from cryptography.exceptions import InvalidKey, InvalidSignature from cryptography.fernet import Fernet, InvalidToken -from cryptography.hazmat.primitives import hashes from cryptography.hazmat.backends import default_backend +from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC from nacl import pwhash, secret from password_strength import PasswordPolicy +from rich.prompt import Confirm from substrateinterface.utils.ss58 import ss58_encode from termcolor import colored -from rich.prompt import Confirm +import bittensor +from bittensor.errors import KeyFileError NACL_SALT = b"\x13q\x83\xdf\xf1Z\t\xbc\x9c\x90\xb5Q\x879\xe9\xb1" @@ -98,9 +98,7 @@ def deserialize_keypair_from_keyfile_data(keyfile_data: bytes) -> "bittensor.Key } else: raise bittensor.KeyFileError( - "Keypair could not be created from keyfile data: {}".format( - string_value - ) + f"Keypair could not be created from keyfile data: {string_value}" ) if "secretSeed" in keyfile_dict and keyfile_dict["secretSeed"] is not None: @@ -122,7 +120,7 @@ def deserialize_keypair_from_keyfile_data(keyfile_data: bytes) -> "bittensor.Key else: raise bittensor.KeyFileError( - "Keypair could not be created from keyfile data: {}".format(keyfile_dict) + f"Keypair could not be created from keyfile data: {keyfile_dict}" ) @@ -347,7 +345,7 @@ def decrypt_keyfile_data( # Unknown. else: raise bittensor.KeyFileError( - "keyfile data: {} is corrupt".format(keyfile_data) + f"keyfile data: {keyfile_data} is corrupt" ) except (InvalidSignature, InvalidKey, InvalidToken): @@ -367,14 +365,11 @@ def __init__(self, path: str): def __str__(self): if not self.exists_on_device(): - return "keyfile (empty, {})>".format(self.path) + return f"keyfile (empty, {self.path})>" if self.is_encrypted(): - return "Keyfile ({} encrypted, {})>".format( - keyfile_data_encryption_method(self._read_keyfile_data_from_file()), - self.path, - ) + return f"Keyfile ({keyfile_data_encryption_method(self._read_keyfile_data_from_file())} encrypted, {self.path})>" else: - return "keyfile (decrypted, {})>".format(self.path) + return f"keyfile (decrypted, {self.path})>" def __repr__(self): return self.__str__() @@ -510,7 +505,7 @@ def _may_overwrite(self) -> bool: Returns: may_overwrite (bool): ``True`` if the user allows overwriting the file. """ - choice = input("File {} already exists. Overwrite? (y/N) ".format(self.path)) + choice = input(f"File {self.path} already exists. Overwrite? (y/N) ") return choice == "y" def check_and_update_encryption( @@ -560,7 +555,7 @@ def check_and_update_encryption( stored_mnemonic = False while not stored_mnemonic: bittensor.__console__.print( - f"\nPlease make sure you have the mnemonic stored in case an error occurs during the transfer.", + "\nPlease make sure you have the mnemonic stored in case an error occurs during the transfer.", style="white on red", ) stored_mnemonic = Confirm.ask("Have you stored the mnemonic?") @@ -626,15 +621,15 @@ def encrypt(self, password: str = None): """ if not self.exists_on_device(): raise bittensor.KeyFileError( - "Keyfile at: {} does not exist".format(self.path) + f"Keyfile at: {self.path} does not exist" ) if not self.is_readable(): raise bittensor.KeyFileError( - "Keyfile at: {} is not readable".format(self.path) + f"Keyfile at: {self.path} is not readable" ) if not self.is_writable(): raise bittensor.KeyFileError( - "Keyfile at: {} is not writable".format(self.path) + f"Keyfile at: {self.path} is not writable" ) keyfile_data = self._read_keyfile_data_from_file() if not keyfile_data_is_encrypted(keyfile_data): @@ -653,15 +648,15 @@ def decrypt(self, password: str = None): """ if not self.exists_on_device(): raise bittensor.KeyFileError( - "Keyfile at: {} does not exist".format(self.path) + f"Keyfile at: {self.path} does not exist" ) if not self.is_readable(): raise bittensor.KeyFileError( - "Keyfile at: {} is not readable".format(self.path) + f"Keyfile at: {self.path} is not readable" ) if not self.is_writable(): raise bittensor.KeyFileError( - "Keyfile at: {} is not writable".format(self.path) + f"Keyfile at: {self.path} is not writable" ) keyfile_data = self._read_keyfile_data_from_file() if keyfile_data_is_encrypted(keyfile_data): @@ -682,11 +677,11 @@ def _read_keyfile_data_from_file(self) -> bytes: """ if not self.exists_on_device(): raise bittensor.KeyFileError( - "Keyfile at: {} does not exist".format(self.path) + f"Keyfile at: {self.path} does not exist" ) if not self.is_readable(): raise bittensor.KeyFileError( - "Keyfile at: {} is not readable".format(self.path) + f"Keyfile at: {self.path} is not readable" ) with open(self.path, "rb") as file: data = file.read() @@ -705,7 +700,7 @@ def _write_keyfile_data_to_file(self, keyfile_data: bytes, overwrite: bool = Fal if self.exists_on_device() and not overwrite: if not self._may_overwrite(): raise bittensor.KeyFileError( - "Keyfile at: {} is not writable".format(self.path) + f"Keyfile at: {self.path} is not writable" ) with open(self.path, "wb") as keyfile: keyfile.write(keyfile_data) diff --git a/bittensor/metagraph.py b/bittensor/metagraph.py index 8d7e97bcc0..b81b718b9a 100644 --- a/bittensor/metagraph.py +++ b/bittensor/metagraph.py @@ -17,16 +17,17 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from abc import ABC, abstractmethod import os import pickle -import numpy as np -from numpy.typing import NDArray -import bittensor +from abc import ABC, abstractmethod from os import listdir from os.path import join -from typing import List, Optional, Union, Tuple +from typing import List, Optional, Tuple, Union +import numpy as np +from numpy.typing import NDArray + +import bittensor from bittensor.chain_data import AxonInfo from bittensor.utils.registration import torch, use_torch @@ -85,7 +86,7 @@ def latest_block_path(dir_path: str) -> str: if block_number > latest_block: latest_block = block_number latest_file_full_path = full_path_filename - except Exception as e: + except Exception: pass if not latest_file_full_path: raise ValueError(f"Metagraph not found at: {dir_path}") @@ -397,9 +398,7 @@ def __str__(self) -> str: print(metagraph) # Output: "metagraph(netuid:1, n:100, block:500, network:finney)" """ - return "metagraph(netuid:{}, n:{}, block:{}, network:{})".format( - self.netuid, self.n.item(), self.block.item(), self.network - ) + return f"metagraph(netuid:{self.netuid}, n:{self.n.item()}, block:{self.block.item()}, network:{self.network})" def __repr__(self) -> str: """ diff --git a/bittensor/mock/keyfile_mock.py b/bittensor/mock/keyfile_mock.py index e13126cc17..91a597a3bc 100644 --- a/bittensor/mock/keyfile_mock.py +++ b/bittensor/mock/keyfile_mock.py @@ -18,7 +18,7 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from bittensor import serialized_keypair_to_keyfile_data, keyfile, Keypair +from bittensor import Keypair, keyfile, serialized_keypair_to_keyfile_data class MockKeyfile(keyfile): @@ -34,11 +34,11 @@ def __init__(self, path: str): def __str__(self): if not self.exists_on_device(): - return "Keyfile (empty, {})>".format(self.path) + return f"Keyfile (empty, {self.path})>" if self.is_encrypted(): - return "Keyfile (encrypted, {})>".format(self.path) + return f"Keyfile (encrypted, {self.path})>" else: - return "Keyfile (decrypted, {})>".format(self.path) + return f"Keyfile (decrypted, {self.path})>" def __repr__(self): return self.__str__() diff --git a/bittensor/mock/subtensor_mock.py b/bittensor/mock/subtensor_mock.py index 30d58f22e0..e32fd2d19c 100644 --- a/bittensor/mock/subtensor_mock.py +++ b/bittensor/mock/subtensor_mock.py @@ -15,33 +15,29 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +from abc import abstractclassmethod +from collections.abc import Mapping +from dataclasses import dataclass +from hashlib import sha256 from random import randint from types import SimpleNamespace from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union from unittest.mock import MagicMock -from dataclasses import dataclass -from abc import abstractclassmethod -from collections.abc import Mapping - -from hashlib import sha256 -from ..wallet import wallet from ..chain_data import ( + AxonInfo, + DelegateInfo, NeuronInfo, NeuronInfoLite, PrometheusInfo, - DelegateInfo, SubnetInfo, - AxonInfo, ) from ..errors import ChainQueryError from ..subtensor import Subtensor from ..utils import RAOPERTAO, U16_NORMALIZED_FLOAT from ..utils.balance import Balance from ..utils.registration import POWSolution - -from typing import TypedDict - +from ..wallet import wallet # Mock Testing Constant __GLOBAL_MOCK_STATE__ = {} @@ -1184,9 +1180,9 @@ def _do_stake( stake_state = subtensor_state["Stake"] # Stake the funds - if not hotkey_ss58 in stake_state: + if hotkey_ss58 not in stake_state: stake_state[hotkey_ss58] = {} - if not wallet.coldkeypub.ss58_address in stake_state[hotkey_ss58]: + if wallet.coldkeypub.ss58_address not in stake_state[hotkey_ss58]: stake_state[hotkey_ss58][wallet.coldkeypub.ss58_address] = {} stake_state[hotkey_ss58][wallet.coldkeypub.ss58_address][self.block_number] = ( @@ -1199,11 +1195,11 @@ def _do_stake( ) total_hotkey_stake_state = subtensor_state["TotalHotkeyStake"] - if not hotkey_ss58 in total_hotkey_stake_state: + if hotkey_ss58 not in total_hotkey_stake_state: total_hotkey_stake_state[hotkey_ss58] = {} total_coldkey_stake_state = subtensor_state["TotalColdkeyStake"] - if not wallet.coldkeypub.ss58_address in total_coldkey_stake_state: + if wallet.coldkeypub.ss58_address not in total_coldkey_stake_state: total_coldkey_stake_state[wallet.coldkeypub.ss58_address] = {} curr_total_hotkey_stake = self.query_subtensor( @@ -1273,14 +1269,14 @@ def _do_unstake( ) total_hotkey_stake_state = subtensor_state["TotalHotkeyStake"] - if not hotkey_ss58 in total_hotkey_stake_state: + if hotkey_ss58 not in total_hotkey_stake_state: total_hotkey_stake_state[hotkey_ss58] = {} total_hotkey_stake_state[hotkey_ss58][self.block_number] = ( 0 # Shouldn't happen ) total_coldkey_stake_state = subtensor_state["TotalColdkeyStake"] - if not wallet.coldkeypub.ss58_address in total_coldkey_stake_state: + if wallet.coldkeypub.ss58_address not in total_coldkey_stake_state: total_coldkey_stake_state[wallet.coldkeypub.ss58_address] = {} total_coldkey_stake_state[wallet.coldkeypub.ss58_address][ self.block_number diff --git a/bittensor/mock/wallet_mock.py b/bittensor/mock/wallet_mock.py index 35179f8c94..89ab0c2c3c 100644 --- a/bittensor/mock/wallet_mock.py +++ b/bittensor/mock/wallet_mock.py @@ -19,10 +19,12 @@ # DEALINGS IN THE SOFTWARE. import os -import bittensor from typing import Optional + from Crypto.Hash import keccak +import bittensor + from .keyfile_mock import MockKeyfile diff --git a/bittensor/stream.py b/bittensor/stream.py index e0dc17c42c..39671b99b6 100644 --- a/bittensor/stream.py +++ b/bittensor/stream.py @@ -1,11 +1,13 @@ -from aiohttp import ClientResponse -import bittensor +from abc import ABC, abstractmethod +from collections.abc import Awaitable +from typing import Callable +from aiohttp import ClientResponse +from pydantic import BaseModel, ConfigDict from starlette.responses import StreamingResponse as _StreamingResponse -from starlette.types import Send, Receive, Scope -from typing import Callable, Awaitable -from pydantic import ConfigDict, BaseModel -from abc import ABC, abstractmethod +from starlette.types import Receive, Scope, Send + +import bittensor class BTStreamingResponseModel(BaseModel): diff --git a/bittensor/subnets.py b/bittensor/subnets.py index 836a20dcb7..4a0da61506 100644 --- a/bittensor/subnets.py +++ b/bittensor/subnets.py @@ -17,9 +17,10 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor as bt from abc import ABC, abstractmethod -from typing import Any, List, Union, Optional +from typing import Any, List, Optional, Union + +import bittensor as bt class SubnetsAPI(ABC): diff --git a/bittensor/subtensor.py b/bittensor/subtensor.py index 1b422ad276..9505114e0a 100644 --- a/bittensor/subtensor.py +++ b/bittensor/subtensor.py @@ -24,9 +24,8 @@ import argparse import copy import functools -import socket import time -from typing import List, Dict, Union, Optional, Tuple, TypedDict, Any +from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union import numpy as np import scalecodec @@ -36,24 +35,25 @@ from scalecodec.exceptions import RemainingScaleBytesNotEmptyException from scalecodec.type_registry import load_type_registry_preset from scalecodec.types import GenericCall, ScaleType -from substrateinterface.base import QueryMapResult, SubstrateInterface, ExtrinsicReceipt +from substrateinterface.base import ExtrinsicReceipt, QueryMapResult, SubstrateInterface from substrateinterface.exceptions import SubstrateRequestException import bittensor from bittensor.btlogging import logging as _logger from bittensor.utils import torch, weight_utils + from .chain_data import ( - NeuronInfo, + AxonInfo, DelegateInfo, DelegateInfoLite, - PrometheusInfo, - SubnetInfo, - SubnetHyperparameters, - StakeInfo, + IPInfo, + NeuronInfo, NeuronInfoLite, - AxonInfo, + PrometheusInfo, ProposalVoteData, - IPInfo, + StakeInfo, + SubnetHyperparameters, + SubnetInfo, custom_rpc_type_registry, ) from .errors import IdentityError, NominationError, StakeError, TakeError @@ -62,11 +62,11 @@ reveal_weights_extrinsic, ) from .extrinsics.delegation import ( + decrease_take_extrinsic, delegate_extrinsic, + increase_take_extrinsic, nominate_extrinsic, undelegate_extrinsic, - increase_take_extrinsic, - decrease_take_extrinsic, ) from .extrinsics.network import ( register_subnetwork_extrinsic, @@ -74,22 +74,22 @@ ) from .extrinsics.prometheus import prometheus_extrinsic from .extrinsics.registration import ( - register_extrinsic, burned_register_extrinsic, + register_extrinsic, run_faucet_extrinsic, swap_hotkey_extrinsic, ) from .extrinsics.root import root_register_extrinsic, set_root_weights_extrinsic from .extrinsics.senate import ( - register_senate_extrinsic, leave_senate_extrinsic, + register_senate_extrinsic, vote_senate_extrinsic, ) from .extrinsics.serving import ( - serve_extrinsic, - serve_axon_extrinsic, - publish_metadata, get_metadata, + publish_metadata, + serve_axon_extrinsic, + serve_extrinsic, ) from .extrinsics.set_weights import set_weights_extrinsic from .extrinsics.staking import add_stake_extrinsic, add_stake_multiple_extrinsic @@ -98,13 +98,12 @@ from .types import AxonServeCallParams, PrometheusServeCallParams from .utils import ( U16_NORMALIZED_FLOAT, - ss58_to_vec_u8, U64_NORMALIZED_FLOAT, networking, + ss58_to_vec_u8, ) from .utils.balance import Balance -from .utils.registration import POWSolution -from .utils.registration import legacy_torch_api_compat +from .utils.registration import POWSolution, legacy_torch_api_compat from .utils.subtensor import get_subtensor_errors KEY_NONCE: Dict[str, int] = {} @@ -115,7 +114,7 @@ if hasattr(RuntimeConfiguration, "convert_type_string"): original_convert_type_string = RuntimeConfiguration.convert_type_string - @functools.lru_cache(maxsize=None) + @functools.cache def convert_type_string(_, name): return original_convert_type_string(name) @@ -278,7 +277,7 @@ def __init__( _logger.warning(f"AttributeError: {e}") except TypeError as e: _logger.warning(f"TypeError: {e}") - except (socket.error, OSError) as e: + except OSError as e: _logger.warning(f"Socket error: {e}") if log_verbose: @@ -291,10 +290,10 @@ def __init__( def __str__(self) -> str: if self.network == self.chain_endpoint: # Connecting to chain endpoint without network known. - return "subtensor({})".format(self.chain_endpoint) + return f"subtensor({self.chain_endpoint})" else: # Connecting to network with endpoint known. - return "subtensor({}, {})".format(self.network, self.chain_endpoint) + return f"subtensor({self.network}, {self.chain_endpoint})" def __repr__(self) -> str: return self.__str__() @@ -948,9 +947,7 @@ def commit_weights( message = "No attempt made. Perhaps it is too soon to commit weights!" _logger.info( - "Committing weights with params: netuid={}, uids={}, weights={}, version_key={}".format( - netuid, uids, weights, version_key - ) + f"Committing weights with params: netuid={netuid}, uids={uids}, weights={weights}, version_key={version_key}" ) # Generate the hash of the weights @@ -963,7 +960,7 @@ def commit_weights( version_key=version_key, ) - _logger.info("Commit Hash: {}".format(commit_hash)) + _logger.info(f"Commit Hash: {commit_hash}") while retries < max_retries: try: @@ -1625,9 +1622,7 @@ def get_transfer_fee( ) except Exception as e: bittensor.__console__.print( - ":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n {}[/bold white]".format( - e - ) + f":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n {e}[/bold white]" ) payment_info = {"partialFee": int(2e7)} # assume 0.02 Tao diff --git a/bittensor/synapse.py b/bittensor/synapse.py index 53c53f0083..516b43f2a8 100644 --- a/bittensor/synapse.py +++ b/bittensor/synapse.py @@ -21,6 +21,7 @@ import json import sys import warnings +from typing import Any, ClassVar, Dict, Optional, Tuple from pydantic import ( BaseModel, @@ -29,8 +30,8 @@ field_validator, model_validator, ) + import bittensor -from typing import Optional, Any, Dict, ClassVar, Tuple def get_size(obj, seen=None) -> int: diff --git a/bittensor/tensor.py b/bittensor/tensor.py index ab46560d99..03f34f191a 100644 --- a/bittensor/tensor.py +++ b/bittensor/tensor.py @@ -16,13 +16,15 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import numpy as np import base64 +from typing import List, Optional, Union + import msgpack import msgpack_numpy -from typing import Optional, Union, List +import numpy as np +from pydantic import BaseModel, ConfigDict, Field, field_validator + from bittensor.utils.registration import torch, use_torch -from pydantic import ConfigDict, BaseModel, Field, field_validator class DTypes(dict): diff --git a/bittensor/threadpool.py b/bittensor/threadpool.py index 3e49786ff6..857f732dd7 100644 --- a/bittensor/threadpool.py +++ b/bittensor/threadpool.py @@ -5,21 +5,20 @@ __author__ = "Brian Quinlan (brian@sweetapp.com)" +import argparse +import itertools +import logging import os -import sys -import time import queue import random -import weakref -import logging -import argparse -import bittensor -import itertools +import sys import threading - -from typing import Callable +import time +import weakref from concurrent.futures import _base +from typing import Callable +import bittensor from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME # Workers are created as daemon threads. This is done to allow the interpreter @@ -42,7 +41,7 @@ _shutdown = False -class _WorkItem(object): +class _WorkItem: def __init__(self, future, fn, start_time, args, kwargs): self.future = future self.fn = fn diff --git a/bittensor/utils/__init__.py b/bittensor/utils/__init__.py index 175094da87..7a96320c4a 100644 --- a/bittensor/utils/__init__.py +++ b/bittensor/utils/__init__.py @@ -1,33 +1,31 @@ # The MIT License (MIT) # Copyright © 2022 Opentensor Foundation # Copyright © 2023 Opentensor Technologies Inc +import hashlib import os # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated # documentation files (the “Software”), to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, # and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - # The above copyright notice and this permission notice shall be included in all copies or substantial portions of # the Software. - # THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO # THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +from typing import Callable, Dict, List, Literal, Tuple -from typing import Callable, List, Dict, Literal, Tuple - -import bittensor -import hashlib +import numpy as np import requests import scalecodec -import numpy as np -from .wallet_utils import * # noqa F401 -from .version import version_checking, check_version, VersionCheckError +import bittensor + from .registration import torch, use_torch +from .version import VersionCheckError, check_version, version_checking +from .wallet_utils import * # noqa F401 RAOPERTAO = 1e9 U16_MAX = 65535 diff --git a/bittensor/utils/_register_cuda.py b/bittensor/utils/_register_cuda.py index 05619416e4..fe563a34a9 100644 --- a/bittensor/utils/_register_cuda.py +++ b/bittensor/utils/_register_cuda.py @@ -1,14 +1,13 @@ import binascii import hashlib +import io import math +from contextlib import redirect_stdout from typing import Tuple import numpy as np from Crypto.Hash import keccak -from contextlib import redirect_stdout -import io - def solve_cuda( nonce_start: np.int64, diff --git a/bittensor/utils/formatting.py b/bittensor/utils/formatting.py index 1e93ce8340..9e4a1541c8 100644 --- a/bittensor/utils/formatting.py +++ b/bittensor/utils/formatting.py @@ -19,4 +19,4 @@ def millify(n: int): ), ) - return "{:.2f}{}".format(n / 10 ** (3 * millidx), millnames[millidx]) + return f"{n / 10 ** (3 * millidx):.2f}{millnames[millidx]}" diff --git a/bittensor/utils/networking.py b/bittensor/utils/networking.py index 0437aff80f..45f98db9ac 100644 --- a/bittensor/utils/networking.py +++ b/bittensor/utils/networking.py @@ -19,9 +19,10 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +import json import os import urllib -import json + import netaddr import requests @@ -187,6 +188,6 @@ def get_formatted_ws_endpoint_url(endpoint_url: str) -> str: The formatted endpoint url. In the form of ws:// or wss:// """ if endpoint_url[0:6] != "wss://" and endpoint_url[0:5] != "ws://": - endpoint_url = "ws://{}".format(endpoint_url) + endpoint_url = f"ws://{endpoint_url}" return endpoint_url diff --git a/bittensor/utils/registration.py b/bittensor/utils/registration.py index 6c504b05f1..543a868388 100644 --- a/bittensor/utils/registration.py +++ b/bittensor/utils/registration.py @@ -14,14 +14,14 @@ import backoff import numpy - -import bittensor from Crypto.Hash import keccak from rich import console as rich_console from rich import status as rich_status -from .formatting import get_human_readable, millify +import bittensor + from ._register_cuda import solve_cuda +from .formatting import get_human_readable, millify def use_torch() -> bool: diff --git a/bittensor/utils/subtensor.py b/bittensor/utils/subtensor.py index 484184e77f..d9c92e16eb 100644 --- a/bittensor/utils/subtensor.py +++ b/bittensor/utils/subtensor.py @@ -22,7 +22,7 @@ import json import logging import os -from typing import Dict, Optional, Union, Any +from typing import Any, Dict, Optional, Union from substrateinterface.base import SubstrateInterface @@ -79,7 +79,7 @@ def _save_errors_to_cache(uniq_version: str, errors: Dict[str, Dict[str, str]]): try: with open(_ERRORS_FILE_PATH, "w") as json_file: json.dump(data, json_file, indent=4) - except IOError as e: + except OSError as e: _logger.warning(f"Error saving to file: {e}") @@ -93,9 +93,9 @@ def _get_errors_from_cache() -> Optional[Dict[str, Dict[str, Dict[str, str]]]]: return None try: - with open(_ERRORS_FILE_PATH, "r") as json_file: + with open(_ERRORS_FILE_PATH) as json_file: data = json.load(json_file) - except IOError as e: + except OSError as e: _logger.warning(f"Error reading from file: {e}") return None diff --git a/bittensor/utils/version.py b/bittensor/utils/version.py index 2a5aa3cd57..6892778d0b 100644 --- a/bittensor/utils/version.py +++ b/bittensor/utils/version.py @@ -1,10 +1,11 @@ -from typing import Optional -from pathlib import Path import time +from pathlib import Path +from typing import Optional + +import requests from packaging.version import Version import bittensor -import requests VERSION_CHECK_THRESHOLD = 86400 @@ -76,10 +77,8 @@ def check_version(timeout: int = 15): if Version(latest_version) > Version(bittensor.__version__): print( - "\u001b[33mBittensor Version: Current {}/Latest {}\nPlease update to the latest version at your earliest convenience. " - "Run the following command to upgrade:\n\n\u001b[0mpython -m pip install --upgrade bittensor".format( - bittensor.__version__, latest_version - ) + f"\u001b[33mBittensor Version: Current {bittensor.__version__}/Latest {latest_version}\nPlease update to the latest version at your earliest convenience. " + "Run the following command to upgrade:\n\n\u001b[0mpython -m pip install --upgrade bittensor" ) except Exception as e: raise VersionCheckError("Version check failed") from e diff --git a/bittensor/utils/wallet_utils.py b/bittensor/utils/wallet_utils.py index 39218c33f0..01544898ac 100644 --- a/bittensor/utils/wallet_utils.py +++ b/bittensor/utils/wallet_utils.py @@ -17,11 +17,12 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +from typing import Optional, Union + +from substrateinterface import Keypair as Keypair from substrateinterface.utils import ss58 -from typing import Union, Optional from .. import __ss58_format__ -from substrateinterface import Keypair as Keypair def get_ss58_format(ss58_address: str) -> int: diff --git a/bittensor/utils/weight_utils.py b/bittensor/utils/weight_utils.py index 42f0a88380..141e7e3726 100644 --- a/bittensor/utils/weight_utils.py +++ b/bittensor/utils/weight_utils.py @@ -20,15 +20,15 @@ # DEALINGS IN THE SOFTWARE. import hashlib -from typing import Tuple, List, Union +from typing import List, Tuple, Union import numpy as np from numpy.typing import NDArray -from scalecodec import ScaleBytes, U16, Vec +from scalecodec import U16, ScaleBytes, Vec from substrateinterface import Keypair import bittensor -from bittensor.utils.registration import torch, use_torch, legacy_torch_api_compat +from bittensor.utils.registration import legacy_torch_api_compat, torch, use_torch U32_MAX = 4294967295 U16_MAX = 65535 @@ -197,15 +197,13 @@ def convert_weights_and_uids_for_emit( uids = uids.tolist() if min(weights) < 0: raise ValueError( - "Passed weight is negative cannot exist on chain {}".format(weights) + f"Passed weight is negative cannot exist on chain {weights}" ) if min(uids) < 0: - raise ValueError("Passed uid is negative cannot exist on chain {}".format(uids)) + raise ValueError(f"Passed uid is negative cannot exist on chain {uids}") if len(uids) != len(weights): raise ValueError( - "Passed weights and uids must have the same length, got {} and {}".format( - len(uids), len(weights) - ) + f"Passed weights and uids must have the same length, got {len(uids)} and {len(weights)}" ) if sum(weights) == 0: return [], [] # Nothing to set on chain. @@ -280,7 +278,7 @@ def process_weights_for_netuid( if nzw_size == 0 or metagraph.n < min_allowed_weights: bittensor.logging.warning("No non-zero weights returning all ones.") final_weights = ( - torch.ones((metagraph.n)).to(metagraph.n) / metagraph.n + torch.ones(metagraph.n).to(metagraph.n) / metagraph.n if use_torch() else np.ones((metagraph.n), dtype=np.int64) / metagraph.n ) @@ -302,7 +300,7 @@ def process_weights_for_netuid( ) # ( const ): Should this be np.zeros( ( metagraph.n ) ) to reset everyone to build up weight? weights = ( - torch.ones((metagraph.n)).to(metagraph.n) * 1e-5 + torch.ones(metagraph.n).to(metagraph.n) * 1e-5 if use_torch() else np.ones((metagraph.n), dtype=np.int64) * 1e-5 ) # creating minimum even non-zero weights diff --git a/bittensor/wallet.py b/bittensor/wallet.py index be6aa08c93..5fe196b489 100644 --- a/bittensor/wallet.py +++ b/bittensor/wallet.py @@ -17,13 +17,15 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import os -import copy import argparse -import bittensor -from termcolor import colored +import copy +import os +from typing import Dict, Optional, Tuple, Union, overload + from substrateinterface import Keypair -from typing import Optional, Union, Tuple, Dict, overload +from termcolor import colored + +import bittensor from bittensor.utils import is_valid_bittensor_address_or_public_key @@ -44,11 +46,11 @@ def display_mnemonic_msg(keypair: Keypair, key_type: str): "red", ) ) - print("The mnemonic to the new {} is:\n\n{}\n".format(key_type, mnemonic_green)) + print(f"The mnemonic to the new {key_type} is:\n\n{mnemonic_green}\n") print( "You can use the mnemonic to recreate the key in case it gets lost. The command to use to regenerate the key using this mnemonic is:" ) - print("btcli w regen_{} --mnemonic {}".format(key_type, mnemonic)) + print(f"btcli w regen_{key_type} --mnemonic {mnemonic}") print("") @@ -169,7 +171,7 @@ def add_args(cls, parser: argparse.ArgumentParser, prefix: str = None): default=default_path, help="The path to your bittensor wallets", ) - except argparse.ArgumentError as e: + except argparse.ArgumentError: pass def __init__( @@ -217,7 +219,7 @@ def __str__(self): Returns: str: The string representation. """ - return "wallet({}, {}, {})".format(self.name, self.hotkey_str, self.path) + return f"wallet({self.name}, {self.hotkey_str}, {self.path})" def __repr__(self): """ diff --git a/setup.py b/setup.py index 49c419724a..f6fca7f7e8 100644 --- a/setup.py +++ b/setup.py @@ -15,13 +15,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from setuptools import setup, find_packages -from os import path -from io import open import codecs -import re import os import pathlib +import re +from io import open +from os import path + +from setuptools import find_packages, setup def read_requirements(path): diff --git a/tests/e2e_tests/conftest.py b/tests/e2e_tests/conftest.py index 2300eafc77..bf345f66c5 100644 --- a/tests/e2e_tests/conftest.py +++ b/tests/e2e_tests/conftest.py @@ -1,13 +1,14 @@ +import logging import os +import re +import shlex import signal -from substrateinterface import SubstrateInterface -import pytest import subprocess -import logging -import shlex -import re import time +import pytest +from substrateinterface import SubstrateInterface + logging.basicConfig(level=logging.INFO) diff --git a/tests/e2e_tests/multistep/test_last_tx_block.py b/tests/e2e_tests/multistep/test_last_tx_block.py index 0d1796f5d8..e7f5cb334a 100644 --- a/tests/e2e_tests/multistep/test_last_tx_block.py +++ b/tests/e2e_tests/multistep/test_last_tx_block.py @@ -1,7 +1,8 @@ -from bittensor.commands.root import RootRegisterCommand from bittensor.commands.delegates import NominateCommand from bittensor.commands.network import RegisterSubnetworkCommand from bittensor.commands.register import RegisterCommand +from bittensor.commands.root import RootRegisterCommand + from ..utils import setup_wallet diff --git a/tests/e2e_tests/subcommands/delegation/test_set_delegate_take.py b/tests/e2e_tests/subcommands/delegation/test_set_delegate_take.py index 0453576332..0631fd53f8 100644 --- a/tests/e2e_tests/subcommands/delegation/test_set_delegate_take.py +++ b/tests/e2e_tests/subcommands/delegation/test_set_delegate_take.py @@ -1,8 +1,7 @@ -from bittensor.commands.delegates import SetTakeCommand, NominateCommand +from bittensor.commands.delegates import NominateCommand, SetTakeCommand from bittensor.commands.network import RegisterSubnetworkCommand from bittensor.commands.register import RegisterCommand from bittensor.commands.root import RootRegisterCommand - from tests.e2e_tests.utils import setup_wallet diff --git a/tests/e2e_tests/subcommands/wallet/test_transfer.py b/tests/e2e_tests/subcommands/wallet/test_transfer.py index de8052e027..8d08807b3d 100644 --- a/tests/e2e_tests/subcommands/wallet/test_transfer.py +++ b/tests/e2e_tests/subcommands/wallet/test_transfer.py @@ -1,6 +1,6 @@ from bittensor.commands.transfer import TransferCommand + from ...utils import setup_wallet -import bittensor # Example test using the local_chain fixture diff --git a/tests/e2e_tests/subcommands/weights/test_commit_weights.py b/tests/e2e_tests/subcommands/weights/test_commit_weights.py index faed9d3925..13e7aedef7 100644 --- a/tests/e2e_tests/subcommands/weights/test_commit_weights.py +++ b/tests/e2e_tests/subcommands/weights/test_commit_weights.py @@ -6,11 +6,11 @@ import bittensor import bittensor.utils.weight_utils as weight_utils from bittensor.commands import ( + CommitWeightCommand, RegisterCommand, - StakeCommand, RegisterSubnetworkCommand, - CommitWeightCommand, RevealWeightCommand, + StakeCommand, ) from tests.e2e_tests.utils import setup_wallet diff --git a/tests/e2e_tests/utils.py b/tests/e2e_tests/utils.py index 3ad789dd6d..757324444b 100644 --- a/tests/e2e_tests/utils.py +++ b/tests/e2e_tests/utils.py @@ -1,5 +1,7 @@ -from substrateinterface import Keypair from typing import List + +from substrateinterface import Keypair + import bittensor diff --git a/tests/helpers/__init__.py b/tests/helpers/__init__.py index fc9e8ad9d2..c5239c366f 100644 --- a/tests/helpers/__init__.py +++ b/tests/helpers/__init__.py @@ -16,14 +16,15 @@ # DEALINGS IN THE SOFTWARE. import os + from .helpers import ( + CLOSE_IN_VALUE, + MockConsole, + __mock_wallet_factory__, _get_mock_coldkey, _get_mock_hotkey, _get_mock_keypair, _get_mock_wallet, - CLOSE_IN_VALUE, - MockConsole, - __mock_wallet_factory__, ) diff --git a/tests/helpers/helpers.py b/tests/helpers/helpers.py index 482f59ce2d..964f8cb186 100644 --- a/tests/helpers/helpers.py +++ b/tests/helpers/helpers.py @@ -16,16 +16,16 @@ # DEALINGS IN THE SOFTWARE. from typing import Union -from bittensor import Balance, NeuronInfo, AxonInfo, PrometheusInfo, __ss58_format__ + +from rich.console import Console +from rich.text import Text + +from bittensor import AxonInfo, Balance, NeuronInfo, PrometheusInfo from bittensor.mock.wallet_mock import MockWallet as _MockWallet from bittensor.mock.wallet_mock import get_mock_coldkey as _get_mock_coldkey from bittensor.mock.wallet_mock import get_mock_hotkey as _get_mock_hotkey -from bittensor.mock.wallet_mock import get_mock_keypair as _get_mock_keypair from bittensor.mock.wallet_mock import get_mock_wallet as _get_mock_wallet -from rich.console import Console -from rich.text import Text - def __mock_wallet_factory__(*args, **kwargs) -> _MockWallet: """Returns a mock wallet object.""" diff --git a/tests/integration_tests/test_cli.py b/tests/integration_tests/test_cli.py index aa019c4178..d458dfff60 100644 --- a/tests/integration_tests/test_cli.py +++ b/tests/integration_tests/test_cli.py @@ -18,14 +18,12 @@ # DEALINGS IN THE SOFTWARE. -import contextlib -from copy import deepcopy import os import random -import shutil +import unittest +from copy import deepcopy from types import SimpleNamespace from typing import Dict -import unittest from unittest.mock import MagicMock, patch import pytest @@ -38,13 +36,14 @@ from bittensor.mock import MockSubtensor from bittensor.wallet import wallet as Wallet from tests.helpers import ( - is_running_in_circleci, MockConsole, _get_mock_keypair, + is_running_in_circleci, +) +from tests.helpers import ( _get_mock_wallet as generate_wallet, ) - _subtensor_mock: MockSubtensor = MockSubtensor() @@ -253,9 +252,7 @@ def test_overview_not_in_first_subnet(self, _): for netuid, wallet in mock_registrations: print( - "Registering wallet {} to subnet {}".format( - wallet.hotkey_str, netuid - ) + f"Registering wallet {wallet.hotkey_str} to subnet {netuid}" ) _ = _subtensor_mock.force_register_neuron( netuid=netuid, @@ -723,7 +720,7 @@ def test_unstake_with_multiple_hotkeys_max_stake(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, @@ -946,7 +943,7 @@ def test_stake_with_specific_hotkeys(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, @@ -1020,7 +1017,7 @@ def test_stake_with_all_hotkeys(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, @@ -1118,7 +1115,7 @@ def test_stake_with_exclude_hotkeys_from_all(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, @@ -1224,7 +1221,7 @@ def test_stake_with_multiple_hotkeys_max_stake(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") if wallet.hotkey_str == "hk1": # Set the stake for hk1 _ = _subtensor_mock.force_register_neuron( @@ -1331,7 +1328,7 @@ def test_stake_with_multiple_hotkeys_max_stake_not_enough_balance(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, @@ -1424,7 +1421,7 @@ def test_stake_with_single_hotkey_max_stake(self, _): print("Registering mock wallets...") for wallet in mock_wallets: - print("Registering mock wallet {}".format(wallet.hotkey_str)) + print(f"Registering mock wallet {wallet.hotkey_str}") _ = _subtensor_mock.force_register_neuron( netuid=1, hotkey=wallet.hotkey.ss58_address, diff --git a/tests/integration_tests/test_cli_no_network.py b/tests/integration_tests/test_cli_no_network.py index 1ef6657f61..7e7aca817a 100644 --- a/tests/integration_tests/test_cli_no_network.py +++ b/tests/integration_tests/test_cli_no_network.py @@ -17,18 +17,17 @@ # DEALINGS IN THE SOFTWARE. +import re import unittest -from unittest.mock import MagicMock, patch -from typing import Any, Optional -import pytest from copy import deepcopy -import re +from typing import Any +from unittest.mock import MagicMock, patch -from tests.helpers import _get_mock_coldkey, __mock_wallet_factory__, MockConsole +import pytest import bittensor from bittensor import Balance -from rich.table import Table +from tests.helpers import __mock_wallet_factory__, _get_mock_coldkey class MockException(Exception): diff --git a/tests/integration_tests/test_metagraph_integration.py b/tests/integration_tests/test_metagraph_integration.py index 5dbb9ddfc1..c6a29d031e 100644 --- a/tests/integration_tests/test_metagraph_integration.py +++ b/tests/integration_tests/test_metagraph_integration.py @@ -16,11 +16,13 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import bittensor -import torch import os -from bittensor.mock import MockSubtensor + +import torch + +import bittensor from bittensor.metagraph import METAGRAPH_STATE_DICT_NDARRAY_KEYS, get_save_dir +from bittensor.mock import MockSubtensor _subtensor_mock: MockSubtensor = MockSubtensor() diff --git a/tests/integration_tests/test_subtensor_integration.py b/tests/integration_tests/test_subtensor_integration.py index e3661210bc..6a95502d6e 100644 --- a/tests/integration_tests/test_subtensor_integration.py +++ b/tests/integration_tests/test_subtensor_integration.py @@ -30,8 +30,8 @@ from bittensor.utils import weight_utils from bittensor.utils.balance import Balance from tests.helpers import ( - _get_mock_coldkey, MockConsole, + _get_mock_coldkey, _get_mock_keypair, _get_mock_wallet, ) @@ -329,7 +329,7 @@ def process_events(self): uids=[1], weights=chain_weights, ) - assert success == True + assert success is True def test_set_weights_inclusion(self): chain_weights = [0] @@ -343,7 +343,7 @@ def test_set_weights_inclusion(self): weights=chain_weights, wait_for_inclusion=True, ) - assert success == True + assert success is True def test_set_weights_failed(self): chain_weights = [0] @@ -359,7 +359,7 @@ def test_set_weights_failed(self): weights=chain_weights, wait_for_inclusion=True, ) - assert fail == False + assert fail is False def test_commit_weights(self): weights = np.array([0.1, 0.2, 0.3, 0.4], dtype=np.float32) diff --git a/tests/unit_tests/extrinsics/test_delegation.py b/tests/unit_tests/extrinsics/test_delegation.py index 42dcf4e706..7213e321ac 100644 --- a/tests/unit_tests/extrinsics/test_delegation.py +++ b/tests/unit_tests/extrinsics/test_delegation.py @@ -1,19 +1,21 @@ -import pytest from unittest.mock import MagicMock, patch -from bittensor.subtensor import Subtensor -from bittensor.wallet import wallet as Wallet -from bittensor.utils.balance import Balance -from bittensor.extrinsics.delegation import ( - nominate_extrinsic, - delegate_extrinsic, - undelegate_extrinsic, -) + +import pytest + from bittensor.errors import ( NominationError, NotDelegateError, NotRegisteredError, StakeError, ) +from bittensor.extrinsics.delegation import ( + delegate_extrinsic, + nominate_extrinsic, + undelegate_extrinsic, +) +from bittensor.subtensor import Subtensor +from bittensor.utils.balance import Balance +from bittensor.wallet import wallet as Wallet @pytest.fixture diff --git a/tests/unit_tests/extrinsics/test_network.py b/tests/unit_tests/extrinsics/test_network.py index 67df030ffe..d7d6947ed3 100644 --- a/tests/unit_tests/extrinsics/test_network.py +++ b/tests/unit_tests/extrinsics/test_network.py @@ -1,11 +1,13 @@ -import pytest from unittest.mock import MagicMock, patch -from bittensor.subtensor import Subtensor -from bittensor.wallet import wallet as Wallet + +import pytest + from bittensor.extrinsics.network import ( - set_hyperparameter_extrinsic, register_subnetwork_extrinsic, + set_hyperparameter_extrinsic, ) +from bittensor.subtensor import Subtensor +from bittensor.wallet import wallet as Wallet # Mock the bittensor and related modules to avoid real network calls and wallet operations diff --git a/tests/unit_tests/extrinsics/test_prometheus.py b/tests/unit_tests/extrinsics/test_prometheus.py index 7d9c975fbc..b2b7fcae61 100644 --- a/tests/unit_tests/extrinsics/test_prometheus.py +++ b/tests/unit_tests/extrinsics/test_prometheus.py @@ -1,9 +1,11 @@ -import pytest from unittest.mock import MagicMock, patch + +import pytest + import bittensor +from bittensor.extrinsics.prometheus import prometheus_extrinsic from bittensor.subtensor import Subtensor from bittensor.wallet import wallet as Wallet -from bittensor.extrinsics.prometheus import prometheus_extrinsic # Mocking the bittensor and networking modules @@ -112,7 +114,7 @@ def test_prometheus_extrinsic_edge_cases( ) # Assert - assert result == True, f"Test ID: {test_id}" + assert result is True, f"Test ID: {test_id}" # Error cases diff --git a/tests/unit_tests/extrinsics/test_registration.py b/tests/unit_tests/extrinsics/test_registration.py index 5a4d32dff6..3eabbb47bc 100644 --- a/tests/unit_tests/extrinsics/test_registration.py +++ b/tests/unit_tests/extrinsics/test_registration.py @@ -1,15 +1,17 @@ -import pytest from unittest.mock import MagicMock, patch -from bittensor.subtensor import Subtensor -from bittensor.wallet import wallet as Wallet -from bittensor.utils.registration import POWSolution + +import pytest + from bittensor.extrinsics.registration import ( - MaxSuccessException, MaxAttemptsException, - swap_hotkey_extrinsic, + MaxSuccessException, burned_register_extrinsic, register_extrinsic, + swap_hotkey_extrinsic, ) +from bittensor.subtensor import Subtensor +from bittensor.utils.registration import POWSolution +from bittensor.wallet import wallet as Wallet # Mocking external dependencies diff --git a/tests/unit_tests/extrinsics/test_root.py b/tests/unit_tests/extrinsics/test_root.py index d3ae2c3973..6c79d05a2a 100644 --- a/tests/unit_tests/extrinsics/test_root.py +++ b/tests/unit_tests/extrinsics/test_root.py @@ -1,10 +1,12 @@ -import pytest from unittest.mock import MagicMock, patch -from bittensor.subtensor import Subtensor + +import pytest + from bittensor.extrinsics.root import ( root_register_extrinsic, set_root_weights_extrinsic, ) +from bittensor.subtensor import Subtensor @pytest.fixture diff --git a/tests/unit_tests/extrinsics/test_senate.py b/tests/unit_tests/extrinsics/test_senate.py index 66849efc5c..699190be27 100644 --- a/tests/unit_tests/extrinsics/test_senate.py +++ b/tests/unit_tests/extrinsics/test_senate.py @@ -1,5 +1,7 @@ -import pytest from unittest.mock import MagicMock, patch + +import pytest + from bittensor import subtensor, wallet from bittensor.extrinsics.senate import ( leave_senate_extrinsic, diff --git a/tests/unit_tests/extrinsics/test_serving.py b/tests/unit_tests/extrinsics/test_serving.py index bf975e195a..e335cbe943 100644 --- a/tests/unit_tests/extrinsics/test_serving.py +++ b/tests/unit_tests/extrinsics/test_serving.py @@ -1,14 +1,15 @@ +from unittest.mock import MagicMock, patch + import pytest -from unittest.mock import MagicMock, patch -from bittensor.subtensor import Subtensor -from bittensor.wallet import wallet as Wallet from bittensor.axon import axon as Axon from bittensor.extrinsics.serving import ( - serve_extrinsic, publish_metadata, serve_axon_extrinsic, + serve_extrinsic, ) +from bittensor.subtensor import Subtensor +from bittensor.wallet import wallet as Wallet @pytest.fixture diff --git a/tests/unit_tests/extrinsics/test_set_weights.py b/tests/unit_tests/extrinsics/test_set_weights.py index 68ce7acae9..da45fd24f3 100644 --- a/tests/unit_tests/extrinsics/test_set_weights.py +++ b/tests/unit_tests/extrinsics/test_set_weights.py @@ -1,6 +1,8 @@ -import torch -import pytest from unittest.mock import MagicMock, patch + +import pytest +import torch + from bittensor import subtensor, wallet from bittensor.extrinsics.set_weights import set_weights_extrinsic diff --git a/tests/unit_tests/extrinsics/test_staking.py b/tests/unit_tests/extrinsics/test_staking.py index 288e065f78..006283cddd 100644 --- a/tests/unit_tests/extrinsics/test_staking.py +++ b/tests/unit_tests/extrinsics/test_staking.py @@ -1,12 +1,14 @@ +from unittest.mock import MagicMock, patch + import pytest -from unittest.mock import patch, MagicMock + import bittensor -from bittensor.utils.balance import Balance +from bittensor.errors import NotDelegateError from bittensor.extrinsics.staking import ( add_stake_extrinsic, add_stake_multiple_extrinsic, ) -from bittensor.errors import NotDelegateError +from bittensor.utils.balance import Balance # Mocking external dependencies diff --git a/tests/unit_tests/extrinsics/test_unstaking.py b/tests/unit_tests/extrinsics/test_unstaking.py index 6ad0a977e7..62b3abb642 100644 --- a/tests/unit_tests/extrinsics/test_unstaking.py +++ b/tests/unit_tests/extrinsics/test_unstaking.py @@ -1,10 +1,10 @@ -import bittensor -import pytest +from unittest.mock import MagicMock, patch -from unittest.mock import patch, MagicMock +import pytest -from bittensor.utils.balance import Balance +import bittensor from bittensor.extrinsics.unstaking import unstake_extrinsic, unstake_multiple_extrinsic +from bittensor.utils.balance import Balance @pytest.fixture diff --git a/tests/unit_tests/test_axon.py b/tests/unit_tests/test_axon.py index 36d0ba2d00..29755de941 100644 --- a/tests/unit_tests/test_axon.py +++ b/tests/unit_tests/test_axon.py @@ -27,12 +27,12 @@ # Third Party import netaddr import pytest -from starlette.requests import Request from fastapi.testclient import TestClient +from starlette.requests import Request # Bittensor import bittensor -from bittensor import Synapse, RunException +from bittensor import RunException, Synapse from bittensor.axon import AxonMiddleware from bittensor.axon import axon as Axon diff --git a/tests/unit_tests/test_chain_data.py b/tests/unit_tests/test_chain_data.py index a6474bbee9..1937d53760 100644 --- a/tests/unit_tests/test_chain_data.py +++ b/tests/unit_tests/test_chain_data.py @@ -1,6 +1,7 @@ import pytest -import bittensor import torch + +import bittensor from bittensor.chain_data import AxonInfo, ChainDataType, DelegateInfo, NeuronInfo SS58_FORMAT = bittensor.__ss58_format__ diff --git a/tests/unit_tests/test_dendrite.py b/tests/unit_tests/test_dendrite.py index c30ecc58fa..e97ae3f975 100644 --- a/tests/unit_tests/test_dendrite.py +++ b/tests/unit_tests/test_dendrite.py @@ -17,14 +17,14 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from pydantic import ValidationError -import pytest import typing -import bittensor from unittest.mock import MagicMock, Mock -from tests.helpers import _get_mock_wallet +import pytest + +import bittensor from bittensor.synapse import TerminalInfo +from tests.helpers import _get_mock_wallet class SynapseDummy(bittensor.Synapse): @@ -79,12 +79,12 @@ def test_init(setup_dendrite): def test_str(dendrite_obj): - expected_string = "dendrite({})".format(dendrite_obj.keypair.ss58_address) + expected_string = f"dendrite({dendrite_obj.keypair.ss58_address})" assert str(dendrite_obj) == expected_string def test_repr(dendrite_obj): - expected_string = "dendrite({})".format(dendrite_obj.keypair.ss58_address) + expected_string = f"dendrite({dendrite_obj.keypair.ss58_address})" assert repr(dendrite_obj) == expected_string @@ -93,7 +93,7 @@ def test_close(dendrite_obj, setup_axon): # Query the axon to open a session dendrite_obj.query(axon, SynapseDummy(input=1)) # Session should be automatically closed after query - assert dendrite_obj._session == None + assert dendrite_obj._session is None @pytest.mark.asyncio @@ -103,7 +103,7 @@ async def test_aclose(dendrite_obj, setup_axon): async with dendrite_obj: resp = await dendrite_obj([axon], SynapseDummy(input=1), deserialize=False) # Close should automatically be called on the session after context manager scope - assert dendrite_obj._session == None + assert dendrite_obj._session is None class AsyncMock(Mock): @@ -306,7 +306,7 @@ async def test_dendrite__call__success_response( ) ) mock_aioresponse.post( - f"http://127.0.0.1:666/SynapseDummy", + "http://127.0.0.1:666/SynapseDummy", body=expected_synapse.json(), ) synapse = await dendrite_obj.call(axon_info, synapse=input_synapse) @@ -326,7 +326,7 @@ async def test_dendrite__call__handles_http_error_response( message = "Custom Error" mock_aioresponse.post( - f"http://127.0.0.1:666/SynapseDummy", + "http://127.0.0.1:666/SynapseDummy", status=status_code, payload={"message": message}, ) diff --git a/tests/unit_tests/test_keyfile.py b/tests/unit_tests/test_keyfile.py index d20af809f9..fb62d3f4b9 100644 --- a/tests/unit_tests/test_keyfile.py +++ b/tests/unit_tests/test_keyfile.py @@ -15,19 +15,20 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import os import json -import time -import pytest +import os import shutil -import bittensor +import time import unittest.mock as mock + +import pytest +from bip39 import bip39_validate from scalecodec import ScaleBytes from substrateinterface import Keypair, KeypairType from substrateinterface.constants import DEV_PHRASE from substrateinterface.exceptions import ConfigurationError -from bip39 import bip39_validate +import bittensor from bittensor import get_coldkey_password_from_environment @@ -36,7 +37,7 @@ def test_generate_mnemonic(): Test the generation of a mnemonic and its validation. """ mnemonic = Keypair.generate_mnemonic() - assert bip39_validate(mnemonic) == True + assert bip39_validate(mnemonic) is True def test_invalid_mnemonic(): @@ -44,7 +45,7 @@ def test_invalid_mnemonic(): Test the validation of an invalid mnemonic. """ mnemonic = "This is an invalid mnemonic" - assert bip39_validate(mnemonic) == False + assert bip39_validate(mnemonic) is False def test_create_sr25519_keypair(): @@ -114,7 +115,7 @@ def test_sign_and_verify(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic) signature = keypair.sign("Test1231223123123") - assert keypair.verify("Test1231223123123", signature) == True + assert keypair.verify("Test1231223123123", signature) is True def test_sign_and_verify_hex_data(): @@ -124,7 +125,7 @@ def test_sign_and_verify_hex_data(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic) signature = keypair.sign("0x1234") - assert keypair.verify("0x1234", signature) == True + assert keypair.verify("0x1234", signature) is True def test_sign_and_verify_scale_bytes(): @@ -135,7 +136,7 @@ def test_sign_and_verify_scale_bytes(): keypair = Keypair.create_from_mnemonic(mnemonic) data = ScaleBytes("0x1234") signature = keypair.sign(data) - assert keypair.verify(data, signature) == True + assert keypair.verify(data, signature) is True def test_sign_missing_private_key(): @@ -180,7 +181,7 @@ def test_sign_and_verify_incorrect_signature(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic) signature = "0x4c291bfb0bb9c1274e86d4b666d13b2ac99a0bacc04a4846fb8ea50bda114677f83c1f164af58fc184451e5140cc8160c4de626163b11451d3bbb208a1889f8a" - assert keypair.verify("Test1231223123123", signature) == False + assert keypair.verify("Test1231223123123", signature) is False def test_sign_and_verify_invalid_signature(): @@ -201,7 +202,7 @@ def test_sign_and_verify_invalid_message(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic) signature = keypair.sign("Test1231223123123") - assert keypair.verify("OtherMessage", signature) == False + assert keypair.verify("OtherMessage", signature) is False def test_create_ed25519_keypair(): @@ -222,7 +223,7 @@ def test_sign_and_verify_ed25519(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic, crypto_type=KeypairType.ED25519) signature = keypair.sign("Test1231223123123") - assert keypair.verify("Test1231223123123", signature) == True + assert keypair.verify("Test1231223123123", signature) is True def test_sign_and_verify_invalid_signature_ed25519(): @@ -232,7 +233,7 @@ def test_sign_and_verify_invalid_signature_ed25519(): mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic, crypto_type=KeypairType.ED25519) signature = "0x4c291bfb0bb9c1274e86d4b666d13b2ac99a0bacc04a4846fb8ea50bda114677f83c1f164af58fc184451e5140cc8160c4de626163b11451d3bbb208a1889f8a" - assert keypair.verify("Test1231223123123", signature) == False + assert keypair.verify("Test1231223123123", signature) is False def test_unsupport_crypto_type(): @@ -465,13 +466,13 @@ def test_validate_password(): """ from bittensor.keyfile import validate_password - assert validate_password(None) == False - assert validate_password("passw0rd") == False - assert validate_password("123456789") == False + assert validate_password(None) is False + assert validate_password("passw0rd") is False + assert validate_password("123456789") is False with mock.patch("getpass.getpass", return_value="biTTensor"): - assert validate_password("biTTensor") == True + assert validate_password("biTTensor") is True with mock.patch("getpass.getpass", return_value="biTTenso"): - assert validate_password("biTTensor") == False + assert validate_password("biTTensor") is False def test_decrypt_keyfile_data_legacy(): @@ -590,8 +591,10 @@ def test_deserialize_keypair_from_keyfile_data(keyfile_setup_teardown): then deserializes the keyfile data to a keypair. It then asserts that the deserialized keypair matches the original keypair. """ - from bittensor.keyfile import serialized_keypair_to_keyfile_data - from bittensor.keyfile import deserialize_keypair_from_keyfile_data + from bittensor.keyfile import ( + deserialize_keypair_from_keyfile_data, + serialized_keypair_to_keyfile_data, + ) root_path = keyfile_setup_teardown keyfile = bittensor.keyfile(path=os.path.join(root_path, "keyfile")) diff --git a/tests/unit_tests/test_logging.py b/tests/unit_tests/test_logging.py index 1822fc86ef..aaebea4113 100644 --- a/tests/unit_tests/test_logging.py +++ b/tests/unit_tests/test_logging.py @@ -1,9 +1,11 @@ -import pytest -import multiprocessing import logging as stdlogging +import multiprocessing from unittest.mock import MagicMock, patch + +import pytest + from bittensor.btlogging import LoggingMachine -from bittensor.btlogging.defines import DEFAULT_LOG_FILE_NAME, BITTENSOR_LOGGER_NAME +from bittensor.btlogging.defines import BITTENSOR_LOGGER_NAME, DEFAULT_LOG_FILE_NAME from bittensor.btlogging.loggingmachine import LoggingConfig diff --git a/tests/unit_tests/test_metagraph.py b/tests/unit_tests/test_metagraph.py index af0dbdba76..67abd75b4a 100644 --- a/tests/unit_tests/test_metagraph.py +++ b/tests/unit_tests/test_metagraph.py @@ -15,13 +15,13 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from unittest.mock import Mock -import pytest +from unittest.mock import MagicMock, Mock + import numpy as np -import bittensor +import pytest +import bittensor from bittensor.metagraph import metagraph as Metagraph -from unittest.mock import MagicMock @pytest.fixture diff --git a/tests/unit_tests/test_subtensor.py b/tests/unit_tests/test_subtensor.py index ee1dd06b58..0517c743ac 100644 --- a/tests/unit_tests/test_subtensor.py +++ b/tests/unit_tests/test_subtensor.py @@ -25,12 +25,12 @@ # Application import bittensor +from bittensor import subtensor_module from bittensor.subtensor import ( + Balance, Subtensor, _logger, - Balance, ) -from bittensor import subtensor_module def test_serve_axon_with_external_ip_set(): diff --git a/tests/unit_tests/test_synapse.py b/tests/unit_tests/test_synapse.py index b0ce4f1325..a66e0cd276 100644 --- a/tests/unit_tests/test_synapse.py +++ b/tests/unit_tests/test_synapse.py @@ -14,11 +14,13 @@ # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import json import base64 +import json +from typing import ClassVar, Optional + import pytest + import bittensor -from typing import Optional, ClassVar def test_parse_headers_to_inputs(): diff --git a/tests/unit_tests/test_tensor.py b/tests/unit_tests/test_tensor.py index 9939b397e7..b7a64ce1fe 100644 --- a/tests/unit_tests/test_tensor.py +++ b/tests/unit_tests/test_tensor.py @@ -14,12 +14,13 @@ # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -import pytest -import numpy as np -import bittensor import numpy +import numpy as np +import pytest import torch +import bittensor + # This is a fixture that creates an example tensor for testing @pytest.fixture diff --git a/tests/unit_tests/test_wallet.py b/tests/unit_tests/test_wallet.py index 0d0466e344..9288af72c8 100644 --- a/tests/unit_tests/test_wallet.py +++ b/tests/unit_tests/test_wallet.py @@ -16,15 +16,17 @@ # DEALINGS IN THE SOFTWARE. import json -import time -import pytest import random import re +import time +from unittest.mock import patch + +import pytest +from ansible_vault import Vault +from rich.prompt import Confirm + import bittensor from bittensor.errors import KeyFileError -from rich.prompt import Confirm -from ansible_vault import Vault -from unittest.mock import patch def legacy_encrypt_keyfile_data(keyfile_data: bytes, password: str = None) -> bytes: @@ -69,7 +71,7 @@ def _legacy_encrypt_keyfile_data(*args, **kwargs): path="/tmp/tests_wallets/do_not_use", ) legacy_password = ( - default_legacy_password if legacy_password == None else legacy_password + default_legacy_password if legacy_password is None else legacy_password ) # create a legacy ansible wallet @@ -198,8 +200,8 @@ def check_new_coldkey_file(keyfile): ) new_path = legacy_wallet.coldkey_file.path - assert old_coldkey_file_data != None - assert new_keyfile_data != None + assert old_coldkey_file_data is not None + assert new_keyfile_data is not None assert not old_coldkey_file_data == new_keyfile_data assert bittensor.keyfile_data_is_encrypted_ansible(old_coldkey_file_data) assert bittensor.keyfile_data_is_encrypted_nacl(new_keyfile_data) @@ -216,7 +218,7 @@ def check_new_hotkey_file(keyfile): assert new_path == old_hotkey_path assert not bittensor.keyfile_data_is_encrypted(new_keyfile_data) - if legacy_wallet == None: + if legacy_wallet is None: legacy_password = f"PASSword-{random.randint(0, 10000)}" legacy_wallet = create_legacy_wallet(legacy_password=legacy_password) diff --git a/tests/unit_tests/utils/test_balance.py b/tests/unit_tests/utils/test_balance.py index b99bc111f2..bb9bb72950 100644 --- a/tests/unit_tests/utils/test_balance.py +++ b/tests/unit_tests/utils/test_balance.py @@ -1,7 +1,8 @@ +from typing import Union + import pytest from hypothesis import given from hypothesis import strategies as st -from typing import Union from bittensor import Balance from tests.helpers import CLOSE_IN_VALUE @@ -439,7 +440,7 @@ def test_balance_not_eq_none(balance: Union[int, float]): Test the inequality (!=) of a Balance object and None. """ balance_ = Balance(balance) - assert not balance_ == None + assert balance_ is not None @given(balance=valid_tao_numbers_strategy) @@ -448,7 +449,7 @@ def test_balance_neq_none(balance: Union[int, float]): Test the inequality (!=) of a Balance object and None. """ balance_ = Balance(balance) - assert balance_ != None + assert balance_ is not None def test_balance_init_from_invalid_value(): diff --git a/tests/unit_tests/utils/test_networking.py b/tests/unit_tests/utils/test_networking.py index 6bc89d3f27..a74f8ac110 100644 --- a/tests/unit_tests/utils/test_networking.py +++ b/tests/unit_tests/utils/test_networking.py @@ -1,10 +1,12 @@ import os +import unittest.mock as mock import urllib +from unittest.mock import MagicMock + import pytest import requests -import unittest.mock as mock + from bittensor import utils -from unittest.mock import MagicMock # Test conversion functions for IPv4 diff --git a/tests/unit_tests/utils/test_subtensor.py b/tests/unit_tests/utils/test_subtensor.py index 1c1220bcea..ce9f346fa4 100644 --- a/tests/unit_tests/utils/test_subtensor.py +++ b/tests/unit_tests/utils/test_subtensor.py @@ -69,7 +69,7 @@ def test_save_errors_to_cache(tmp_path): st_utils._ERRORS_FILE_PATH = test_file st_utils._save_errors_to_cache("0x123", errors) - with open(test_file, "r") as file: + with open(test_file) as file: data = json.load(file) assert data["subtensor_build_id"] == "0x123" assert data["errors"] == errors diff --git a/tests/unit_tests/utils/test_utils.py b/tests/unit_tests/utils/test_utils.py index b03ab6e99c..1d3945cd2b 100644 --- a/tests/unit_tests/utils/test_utils.py +++ b/tests/unit_tests/utils/test_utils.py @@ -18,9 +18,10 @@ # DEALINGS IN THE SOFTWARE. import numpy as np -import bittensor.utils.weight_utils as weight_utils import pytest +import bittensor.utils.weight_utils as weight_utils + def test_convert_weight_and_uids(): uids = np.arange(10) diff --git a/tests/unit_tests/utils/test_version.py b/tests/unit_tests/utils/test_version.py index f9760933f3..48688cfc61 100644 --- a/tests/unit_tests/utils/test_version.py +++ b/tests/unit_tests/utils/test_version.py @@ -17,20 +17,21 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. +from datetime import datetime, timedelta, timezone from pathlib import Path +from unittest.mock import MagicMock + import pytest from freezegun import freeze_time -from datetime import datetime, timedelta, timezone +from pytest_mock import MockerFixture from bittensor.utils.version import ( VERSION_CHECK_THRESHOLD, VersionCheckError, - get_and_save_latest_version, check_version, + get_and_save_latest_version, version_checking, ) -from unittest.mock import MagicMock -from pytest_mock import MockerFixture @pytest.fixture diff --git a/tests/unit_tests/utils/test_weight_utils.py b/tests/unit_tests/utils/test_weight_utils.py index edf334db50..913b2e9cfa 100644 --- a/tests/unit_tests/utils/test_weight_utils.py +++ b/tests/unit_tests/utils/test_weight_utils.py @@ -18,9 +18,9 @@ # DEALINGS IN THE SOFTWARE. import numpy as np -import bittensor.utils.weight_utils as weight_utils import pytest +import bittensor.utils.weight_utils as weight_utils from bittensor.utils import torch From 0a5b82bb06d7f14af4772d7033c9cf5f311198ea Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:41:49 +0200 Subject: [PATCH 04/15] apply `ruff check . --fix --unsafe-fixes` --- bittensor/axon.py | 22 +-- bittensor/btlogging/format.py | 11 +- bittensor/btlogging/loggingmachine.py | 2 +- bittensor/chain_data.py | 82 +++++------ bittensor/cli.py | 6 +- bittensor/commands/delegates.py | 20 +-- bittensor/commands/inspect.py | 18 +-- bittensor/commands/metagraph.py | 2 +- bittensor/commands/network.py | 8 +- bittensor/commands/overview.py | 36 ++--- bittensor/commands/register.py | 3 +- bittensor/commands/root.py | 9 +- bittensor/commands/senate.py | 12 +- bittensor/commands/stake.py | 30 ++-- bittensor/commands/unstake.py | 16 +-- bittensor/commands/utils.py | 24 ++-- bittensor/commands/wallets.py | 34 ++--- bittensor/config.py | 32 ++--- bittensor/dendrite.py | 37 ++--- bittensor/extrinsics/commit_weights.py | 11 +- bittensor/extrinsics/delegation.py | 18 +-- bittensor/extrinsics/network.py | 2 +- bittensor/extrinsics/prometheus.py | 4 +- bittensor/extrinsics/registration.py | 16 +-- bittensor/extrinsics/root.py | 10 +- bittensor/extrinsics/serving.py | 6 +- bittensor/extrinsics/set_weights.py | 6 +- bittensor/extrinsics/staking.py | 14 +- bittensor/extrinsics/unstaking.py | 14 +- bittensor/keyfile.py | 2 +- bittensor/metagraph.py | 16 +-- bittensor/mock/subtensor_mock.py | 67 +++++---- bittensor/mock/wallet_mock.py | 6 +- bittensor/subnets.py | 6 +- bittensor/subtensor.py | 130 +++++++++--------- bittensor/synapse.py | 6 +- bittensor/tensor.py | 8 +- bittensor/threadpool.py | 6 +- bittensor/utils/__init__.py | 26 ++-- bittensor/utils/_register_cuda.py | 3 +- bittensor/utils/registration.py | 24 ++-- bittensor/utils/subtensor.py | 10 +- bittensor/utils/test_utils.py | 3 +- bittensor/utils/weight_utils.py | 20 +-- bittensor/wallet.py | 14 +- setup.py | 2 - tests/e2e_tests/utils.py | 3 +- tests/integration_tests/test_cli.py | 25 ++-- .../integration_tests/test_cli_no_network.py | 2 +- .../test_subtensor_integration.py | 10 +- .../extrinsics/test_registration.py | 2 +- tests/unit_tests/extrinsics/test_senate.py | 2 +- tests/unit_tests/test_dendrite.py | 4 +- tests/unit_tests/test_keyfile.py | 2 +- tests/unit_tests/test_logging.py | 2 +- tests/unit_tests/test_overview.py | 2 +- tests/unit_tests/test_subtensor.py | 13 +- tests/unit_tests/utils/test_utils.py | 6 +- tests/unit_tests/utils/test_weight_utils.py | 12 +- 59 files changed, 460 insertions(+), 479 deletions(-) diff --git a/bittensor/axon.py b/bittensor/axon.py index 913a9e137e..9a124c8640 100644 --- a/bittensor/axon.py +++ b/bittensor/axon.py @@ -33,7 +33,7 @@ import uuid from collections.abc import Awaitable from inspect import Parameter, Signature, signature -from typing import Any, Callable, Dict, List, Optional, Tuple +from typing import Any, Callable, Optional import uvicorn from fastapi import APIRouter, Depends, FastAPI @@ -343,12 +343,12 @@ def __init__( self.port = self.config.axon.port self.external_ip = ( self.config.axon.external_ip - if self.config.axon.external_ip != None + if self.config.axon.external_ip is not None else bittensor.utils.networking.get_external_ip() ) self.external_port = ( self.config.axon.external_port - if self.config.axon.external_port != None + if self.config.axon.external_port is not None else self.config.axon.port ) self.full_address = str(self.config.axon.ip) + ":" + str(self.config.axon.port) @@ -358,14 +358,14 @@ def __init__( self.thread_pool = bittensor.PriorityThreadPoolExecutor( max_workers=self.config.axon.max_workers ) - self.nonces: Dict[str, int] = {} + self.nonces: dict[str, int] = {} # Request default functions. - self.forward_class_types: Dict[str, List[Signature]] = {} - self.blacklist_fns: Dict[str, Optional[Callable]] = {} - self.priority_fns: Dict[str, Optional[Callable]] = {} - self.forward_fns: Dict[str, Optional[Callable]] = {} - self.verify_fns: Dict[str, Optional[Callable]] = {} + self.forward_class_types: dict[str, list[Signature]] = {} + self.blacklist_fns: dict[str, Optional[Callable]] = {} + self.priority_fns: dict[str, Optional[Callable]] = {} + self.forward_fns: dict[str, Optional[Callable]] = {} + self.verify_fns: dict[str, Optional[Callable]] = {} # Instantiate FastAPI self.app = FastAPI() @@ -518,7 +518,7 @@ async def endpoint(*args, **kwargs): ] if blacklist_fn: blacklist_sig = Signature( - expected_params, return_annotation=Tuple[bool, str] + expected_params, return_annotation=tuple[bool, str] ) assert ( signature(blacklist_fn) == blacklist_sig @@ -1320,7 +1320,7 @@ async def priority(self, synapse: bittensor.Synapse): async def submit_task( executor: PriorityThreadPoolExecutor, priority: float - ) -> Tuple[float, Any]: + ) -> tuple[float, Any]: """ Submits the given priority function to the specified executor for asynchronous execution. The function will run in the provided executor and return the priority value along with the result. diff --git a/bittensor/btlogging/format.py b/bittensor/btlogging/format.py index 3ab0021bd8..f0741c17ec 100644 --- a/bittensor/btlogging/format.py +++ b/bittensor/btlogging/format.py @@ -23,7 +23,6 @@ import logging import time -from typing import Dict from colorama import Back, Fore, Style, init @@ -51,14 +50,14 @@ def _success(self, message: str, *args, **kws): logging.addLevelName(TRACE_LEVEL_NUM, "TRACE") logging.Logger.trace = _trace -emoji_map: Dict[str, str] = { +emoji_map: dict[str, str] = { ":white_heavy_check_mark:": "✅", ":cross_mark:": "❌", ":satellite:": "🛰️", } -color_map: Dict[str, str] = { +color_map: dict[str, str] = { "": Fore.RED, "": Style.RESET_ALL, "": Fore.BLUE, @@ -68,7 +67,7 @@ def _success(self, message: str, *args, **kws): } -log_level_color_prefix: Dict[int, str] = { +log_level_color_prefix: dict[int, str] = { logging.NOTSET: Fore.RESET, logging.TRACE: Fore.MAGENTA, logging.DEBUG: Fore.BLUE, @@ -80,12 +79,12 @@ def _success(self, message: str, *args, **kws): } -LOG_FORMATS: Dict[int, str] = { +LOG_FORMATS: dict[int, str] = { level: f"{Fore.BLUE}%(asctime)s{Fore.RESET} | {Style.BRIGHT}{color}%(levelname)s\033[0m | %(message)s" for level, color in log_level_color_prefix.items() } -LOG_TRACE_FORMATS: Dict[int, str] = { +LOG_TRACE_FORMATS: dict[int, str] = { level: f"{Fore.BLUE}%(asctime)s{Fore.RESET}" f" | {Style.BRIGHT}{color}%(levelname)s{Fore.RESET}{Back.RESET}{Style.RESET_ALL}" f" | %(name)s:%(filename)s:%(lineno)s" diff --git a/bittensor/btlogging/loggingmachine.py b/bittensor/btlogging/loggingmachine.py index 45f5bae320..1bb7214a37 100644 --- a/bittensor/btlogging/loggingmachine.py +++ b/bittensor/btlogging/loggingmachine.py @@ -91,7 +91,7 @@ class LoggingMachine(StateMachine): def __init__(self, config: bittensor.config, name: str = BITTENSOR_LOGGER_NAME): # basics - super(LoggingMachine, self).__init__() + super().__init__() self._queue = mp.Queue(-1) self._primary_loggers = {name} self._config = config diff --git a/bittensor/chain_data.py b/bittensor/chain_data.py index c93dc4776e..7d8e837a78 100644 --- a/bittensor/chain_data.py +++ b/bittensor/chain_data.py @@ -23,7 +23,7 @@ import json from dataclasses import asdict, dataclass from enum import Enum -from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union +from typing import Any, Optional, TypedDict, Union from scalecodec.base import RuntimeConfiguration, ScaleBytes from scalecodec.type_registry import load_type_registry_preset @@ -327,11 +327,11 @@ class ChainDataType(Enum): def from_scale_encoding( - input_: Union[List[int], bytes, ScaleBytes], + input_: Union[list[int], bytes, ScaleBytes], type_name: ChainDataType, is_vec: bool = False, is_option: bool = False, -) -> Optional[Dict]: +) -> Optional[dict]: """ Decodes input_ data from SCALE encoding based on the specified type name and modifiers. @@ -357,8 +357,8 @@ def from_scale_encoding( def from_scale_encoding_using_type_string( - input_: Union[List[int], bytes, ScaleBytes], type_string: str -) -> Optional[Dict]: + input_: Union[list[int], bytes, ScaleBytes], type_string: str +) -> Optional[dict]: if isinstance(input_, ScaleBytes): as_scale_bytes = input_ else: @@ -393,7 +393,7 @@ class NeuronInfo: active: int stake: Balance # mapping of coldkey to amount staked to this Neuron - stake_dict: Dict[str, Balance] + stake_dict: dict[str, Balance] total_stake: Balance rank: float emission: float @@ -404,8 +404,8 @@ class NeuronInfo: dividends: float last_update: int validator_permit: bool - weights: List[List[int]] - bonds: List[List[int]] + weights: list[list[int]] + bonds: list[list[int]] pruning_score: int prometheus_info: Optional["PrometheusInfo"] = None axon_info: Optional[AxonInfo] = None @@ -462,7 +462,7 @@ def fix_decoded_values(cls, neuron_info_decoded: Any) -> "NeuronInfo": return cls(**neuron_info_decoded) @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> "NeuronInfo": + def from_vec_u8(cls, vec_u8: list[int]) -> "NeuronInfo": """Returns a NeuronInfo object from a ``vec_u8``.""" if len(vec_u8) == 0: return NeuronInfo.get_null_neuron() @@ -474,7 +474,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> "NeuronInfo": return NeuronInfo.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["NeuronInfo"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["NeuronInfo"]: """Returns a list of NeuronInfo objects from a ``vec_u8``""" decoded_list = from_scale_encoding( @@ -521,8 +521,8 @@ def get_null_neuron() -> "NeuronInfo": def from_weights_bonds_and_neuron_lite( cls, neuron_lite: "NeuronInfoLite", - weights_as_dict: Dict[int, List[Tuple[int, int]]], - bonds_as_dict: Dict[int, List[Tuple[int, int]]], + weights_as_dict: dict[int, list[tuple[int, int]]], + bonds_as_dict: dict[int, list[tuple[int, int]]], ) -> "NeuronInfo": n_dict = neuron_lite.__dict__ n_dict["weights"] = weights_as_dict.get(neuron_lite.uid, []) @@ -542,7 +542,7 @@ class NeuronInfoLite: active: int stake: Balance # mapping of coldkey to amount staked to this Neuron - stake_dict: Dict[str, Balance] + stake_dict: dict[str, Balance] total_stake: Balance rank: float emission: float @@ -602,7 +602,7 @@ def fix_decoded_values(cls, neuron_info_decoded: Any) -> "NeuronInfoLite": return cls(**neuron_info_decoded) @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> "NeuronInfoLite": + def from_vec_u8(cls, vec_u8: list[int]) -> "NeuronInfoLite": """Returns a NeuronInfoLite object from a ``vec_u8``.""" if len(vec_u8) == 0: return NeuronInfoLite.get_null_neuron() @@ -614,7 +614,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> "NeuronInfoLite": return NeuronInfoLite.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["NeuronInfoLite"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["NeuronInfoLite"]: """Returns a list of NeuronInfoLite objects from a ``vec_u8``.""" decoded_list = from_scale_encoding( @@ -667,7 +667,7 @@ class PrometheusInfo: ip_type: int @classmethod - def fix_decoded_values(cls, prometheus_info_decoded: Dict) -> "PrometheusInfo": + def fix_decoded_values(cls, prometheus_info_decoded: dict) -> "PrometheusInfo": """Returns a PrometheusInfo object from a prometheus_info_decoded dictionary.""" prometheus_info_decoded["ip"] = net.int_to_ip( int(prometheus_info_decoded["ip"]) @@ -724,15 +724,15 @@ class DelegateInfo: hotkey_ss58: str # Hotkey of delegate total_stake: Balance # Total stake of the delegate - nominators: List[ - Tuple[str, Balance] + nominators: list[ + tuple[str, Balance] ] # List of nominators of the delegate and their stake owner_ss58: str # Coldkey of owner take: float # Take of the delegate as a percentage - validator_permits: List[ + validator_permits: list[ int ] # List of subnets that the delegate is allowed to validate on - registrations: List[int] # List of subnets that the delegate is registered on + registrations: list[int] # List of subnets that the delegate is registered on return_per_1000: Balance # Return per 1000 tao of the delegate over a day total_daily_return: Balance # Total daily return of the delegate @@ -763,7 +763,7 @@ def fix_decoded_values(cls, decoded: Any) -> "DelegateInfo": ) @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> Optional["DelegateInfo"]: + def from_vec_u8(cls, vec_u8: list[int]) -> Optional["DelegateInfo"]: """Returns a DelegateInfo object from a ``vec_u8``.""" if len(vec_u8) == 0: return None @@ -775,7 +775,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> Optional["DelegateInfo"]: return DelegateInfo.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["DelegateInfo"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["DelegateInfo"]: """Returns a list of DelegateInfo objects from a ``vec_u8``.""" decoded = from_scale_encoding(vec_u8, ChainDataType.DelegateInfo, is_vec=True) @@ -786,8 +786,8 @@ def list_from_vec_u8(cls, vec_u8: List[int]) -> List["DelegateInfo"]: @classmethod def delegated_list_from_vec_u8( - cls, vec_u8: List[int] - ) -> List[Tuple["DelegateInfo", Balance]]: + cls, vec_u8: list[int] + ) -> list[tuple["DelegateInfo", Balance]]: """Returns a list of Tuples of DelegateInfo objects, and Balance, from a ``vec_u8``. This is the list of delegates that the user has delegated to, and the amount of stake delegated. @@ -820,7 +820,7 @@ def fix_decoded_values(cls, decoded: Any) -> "StakeInfo": ) @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> Optional["StakeInfo"]: + def from_vec_u8(cls, vec_u8: list[int]) -> Optional["StakeInfo"]: """Returns a StakeInfo object from a ``vec_u8``.""" if len(vec_u8) == 0: return None @@ -833,8 +833,8 @@ def from_vec_u8(cls, vec_u8: List[int]) -> Optional["StakeInfo"]: @classmethod def list_of_tuple_from_vec_u8( - cls, vec_u8: List[int] - ) -> Dict[str, List["StakeInfo"]]: + cls, vec_u8: list[int] + ) -> dict[str, list["StakeInfo"]]: """Returns a list of StakeInfo objects from a ``vec_u8``.""" decoded: Optional[list[tuple[str, list[object]]]] = ( from_scale_encoding_using_type_string( @@ -853,7 +853,7 @@ def list_of_tuple_from_vec_u8( } @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["StakeInfo"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["StakeInfo"]: """Returns a list of StakeInfo objects from a ``vec_u8``.""" decoded = from_scale_encoding(vec_u8, ChainDataType.StakeInfo, is_vec=True) if decoded is None: @@ -881,13 +881,13 @@ class SubnetInfo: tempo: int modality: int # netuid -> topk percentile prunning score requirement (u16:MAX normalized.) - connection_requirements: Dict[str, float] + connection_requirements: dict[str, float] emission_value: float burn: Balance owner_ss58: str @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> Optional["SubnetInfo"]: + def from_vec_u8(cls, vec_u8: list[int]) -> Optional["SubnetInfo"]: """Returns a SubnetInfo object from a ``vec_u8``.""" if len(vec_u8) == 0: return None @@ -899,7 +899,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> Optional["SubnetInfo"]: return SubnetInfo.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["SubnetInfo"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["SubnetInfo"]: r"""Returns a list of SubnetInfo objects from a ``vec_u8``.""" decoded = from_scale_encoding( vec_u8, ChainDataType.SubnetInfo, is_vec=True, is_option=True @@ -911,7 +911,7 @@ def list_from_vec_u8(cls, vec_u8: List[int]) -> List["SubnetInfo"]: return [SubnetInfo.fix_decoded_values(d) for d in decoded] @classmethod - def fix_decoded_values(cls, decoded: Dict) -> "SubnetInfo": + def fix_decoded_values(cls, decoded: dict) -> "SubnetInfo": """Returns a SubnetInfo object from a decoded SubnetInfo dictionary.""" return SubnetInfo( netuid=decoded["netuid"], @@ -986,7 +986,7 @@ class SubnetHyperparameters: commit_reveal_weights_enabled: bool @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> Optional["SubnetHyperparameters"]: + def from_vec_u8(cls, vec_u8: list[int]) -> Optional["SubnetHyperparameters"]: """Returns a SubnetHyperparameters object from a ``vec_u8``.""" if len(vec_u8) == 0: return None @@ -998,7 +998,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> Optional["SubnetHyperparameters"]: return SubnetHyperparameters.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["SubnetHyperparameters"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["SubnetHyperparameters"]: """Returns a list of SubnetHyperparameters objects from a ``vec_u8``.""" decoded = from_scale_encoding( vec_u8, ChainDataType.SubnetHyperparameters, is_vec=True, is_option=True @@ -1009,7 +1009,7 @@ def list_from_vec_u8(cls, vec_u8: List[int]) -> List["SubnetHyperparameters"]: return [SubnetHyperparameters.fix_decoded_values(d) for d in decoded] @classmethod - def fix_decoded_values(cls, decoded: Dict) -> "SubnetHyperparameters": + def fix_decoded_values(cls, decoded: dict) -> "SubnetHyperparameters": """Returns a SubnetInfo object from a decoded SubnetInfo dictionary.""" return SubnetHyperparameters( rho=decoded["rho"], @@ -1065,7 +1065,7 @@ class IPInfo: ip_type: int protocol: int - def encode(self) -> Dict[str, Any]: + def encode(self) -> dict[str, Any]: """Returns a dictionary of the IPInfo object that can be encoded.""" return { "ip": net.ip_to_int( @@ -1075,7 +1075,7 @@ def encode(self) -> Dict[str, Any]: } @classmethod - def from_vec_u8(cls, vec_u8: List[int]) -> Optional["IPInfo"]: + def from_vec_u8(cls, vec_u8: list[int]) -> Optional["IPInfo"]: """Returns a IPInfo object from a ``vec_u8``.""" if len(vec_u8) == 0: return None @@ -1087,7 +1087,7 @@ def from_vec_u8(cls, vec_u8: List[int]) -> Optional["IPInfo"]: return IPInfo.fix_decoded_values(decoded) @classmethod - def list_from_vec_u8(cls, vec_u8: List[int]) -> List["IPInfo"]: + def list_from_vec_u8(cls, vec_u8: list[int]) -> list["IPInfo"]: r"""Returns a list of IPInfo objects from a ``vec_u8``.""" decoded = from_scale_encoding(vec_u8, ChainDataType.IPInfo, is_vec=True) @@ -1097,7 +1097,7 @@ def list_from_vec_u8(cls, vec_u8: List[int]) -> List["IPInfo"]: return [IPInfo.fix_decoded_values(d) for d in decoded] @classmethod - def fix_decoded_values(cls, decoded: Dict) -> "IPInfo": + def fix_decoded_values(cls, decoded: dict) -> "IPInfo": """Returns a SubnetInfo object from a decoded IPInfo dictionary.""" return IPInfo( ip=net.int_to_ip(decoded["ip"]), @@ -1128,8 +1128,8 @@ def from_parameter_dict( class ProposalVoteData(TypedDict): index: int threshold: int - ayes: List[str] - nays: List[str] + ayes: list[str] + nays: list[str] end: int diff --git a/bittensor/cli.py b/bittensor/cli.py index b7e7ee7a1b..21cb4520b2 100644 --- a/bittensor/cli.py +++ b/bittensor/cli.py @@ -17,7 +17,7 @@ import argparse import sys -from typing import List, Optional +from typing import Optional import shtab @@ -236,7 +236,7 @@ class cli: def __init__( self, config: Optional["bittensor.config"] = None, - args: Optional[List[str]] = None, + args: Optional[list[str]] = None, ): """ Initializes a bittensor.CLI object. @@ -316,7 +316,7 @@ def __create_parser__() -> "argparse.ArgumentParser": return parser @staticmethod - def create_config(args: List[str]) -> "bittensor.config": + def create_config(args: list[str]) -> "bittensor.config": """ From the argument parser, add config to bittensor.executor and local config diff --git a/bittensor/commands/delegates.py b/bittensor/commands/delegates.py index 2d48bafe08..5c313ea291 100644 --- a/bittensor/commands/delegates.py +++ b/bittensor/commands/delegates.py @@ -18,7 +18,7 @@ import argparse import os import sys -from typing import Dict, List, Optional +from typing import Optional from rich.console import Text from rich.prompt import Confirm, FloatPrompt, Prompt @@ -33,7 +33,7 @@ from .utils import DelegatesDetails, get_delegates_details -def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def _get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: try: wallet_names = next(os.walk(os.path.expanduser(path)))[1] return [bittensor.wallet(path=path, name=name) for name in wallet_names] @@ -47,7 +47,7 @@ def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: def show_delegates_lite( - delegates_lite: List["bittensor.DelegateInfoLite"], width: Optional[int] = None + delegates_lite: list["bittensor.DelegateInfoLite"], width: Optional[int] = None ): """ This method is a lite version of the :func:`show_delegates`. This method displays a formatted table of Bittensor network delegates with detailed statistics to the console. @@ -84,7 +84,7 @@ def show_delegates_lite( the table in the console. """ - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) if registered_delegate_info is None: @@ -154,8 +154,8 @@ def show_delegates_lite( # Uses rich console to pretty print a table of delegates. def show_delegates( - delegates: List["bittensor.DelegateInfo"], - prev_delegates: Optional[List["bittensor.DelegateInfo"]], + delegates: list["bittensor.DelegateInfo"], + prev_delegates: Optional[list["bittensor.DelegateInfo"]], width: Optional[int] = None, ): """ @@ -207,7 +207,7 @@ def show_delegates( for prev_delegate in prev_delegates: prev_delegates_dict[prev_delegate.hotkey_ss58] = prev_delegate - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) if registered_delegate_info is None: @@ -406,7 +406,7 @@ def check_config(config: "bittensor.config"): # Check for delegates. with bittensor.__console__.status(":satellite: Loading delegates..."): subtensor = bittensor.subtensor(config=config, log_verbose=False) - delegates: List[bittensor.DelegateInfo] = subtensor.get_delegates() + delegates: list[bittensor.DelegateInfo] = subtensor.get_delegates() try: prev_delegates = subtensor.get_delegates( max(0, subtensor.block - 1200) @@ -547,7 +547,7 @@ def check_config(config: "bittensor.config"): # Check for delegates. with bittensor.__console__.status(":satellite: Loading delegates..."): subtensor = bittensor.subtensor(config=config, log_verbose=False) - delegates: List[bittensor.DelegateInfo] = subtensor.get_delegates() + delegates: list[bittensor.DelegateInfo] = subtensor.get_delegates() try: prev_delegates = subtensor.get_delegates( max(0, subtensor.block - 1200) @@ -1145,7 +1145,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Prompt user for take value. new_take_str = config.get("take") - if new_take_str == None: + if new_take_str is None: new_take = FloatPrompt.ask("Enter take value (0.18 for 18%)") else: new_take = float(new_take_str) diff --git a/bittensor/commands/inspect.py b/bittensor/commands/inspect.py index c04a0714ab..f295e0941b 100644 --- a/bittensor/commands/inspect.py +++ b/bittensor/commands/inspect.py @@ -35,12 +35,12 @@ console = bittensor.__console__ import os -from typing import Dict, List, Optional, Tuple +from typing import Optional import bittensor -def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def _get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: try: wallet_names = next(os.walk(os.path.expanduser(path)))[1] return [bittensor.wallet(path=path, name=name) for name in wallet_names] @@ -50,7 +50,7 @@ def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: return wallets -def _get_hotkey_wallets_for_wallet(wallet) -> List["bittensor.wallet"]: +def _get_hotkey_wallets_for_wallet(wallet) -> list["bittensor.wallet"]: hotkey_wallets = [] hotkeys_path = wallet.path + "/" + wallet.name + "/hotkeys" try: @@ -129,7 +129,7 @@ def run(cli: "bittensor.cli"): @staticmethod def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): - if cli.config.get("all", d=False) == True: + if cli.config.get("all", d=False) is True: wallets = _get_coldkey_wallets_for_path(cli.config.wallet.path) all_hotkeys = get_all_wallets_for_path(cli.config.wallet.path) else: @@ -142,7 +142,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) bittensor.logging.debug(f"Netuids to check: {netuids}") - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) if registered_delegate_info is None: @@ -154,7 +154,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): neuron_state_dict = {} for netuid in tqdm(netuids): neurons = subtensor.neurons_lite(netuid) - neuron_state_dict[netuid] = neurons if neurons != None else [] + neuron_state_dict[netuid] = neurons if neurons is not None else [] table = Table(show_footer=True, pad_edge=False, box=None, expand=True) table.add_column( @@ -185,7 +185,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): "[overline white]Emission", footer_style="overline white", style="green" ) for wallet in tqdm(wallets): - delegates: List[Tuple[bittensor.DelegateInfo, bittensor.Balance]] = ( + delegates: list[tuple[bittensor.DelegateInfo, bittensor.Balance]] = ( subtensor.get_delegated(coldkey_ss58=wallet.coldkeypub.ss58_address) ) if not wallet.coldkeypub_file.exists_on_device(): @@ -218,7 +218,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): if neuron.coldkey == wallet.coldkeypub.ss58_address: hotkey_name: str = "" - hotkey_names: List[str] = [ + hotkey_names: list[str] = [ wallet.hotkey_str for wallet in filter( lambda hotkey: hotkey.hotkey.ss58_address @@ -253,7 +253,7 @@ def check_config(config: "bittensor.config"): wallet_name = Prompt.ask("Enter wallet name", default=defaults.wallet.name) config.wallet.name = str(wallet_name) - if config.netuids != [] and config.netuids != None: + if config.netuids != [] and config.netuids is not None: if not isinstance(config.netuids, list): config.netuids = [int(config.netuids)] else: diff --git a/bittensor/commands/metagraph.py b/bittensor/commands/metagraph.py index aad70c341b..3cdc6b03a2 100644 --- a/bittensor/commands/metagraph.py +++ b/bittensor/commands/metagraph.py @@ -94,7 +94,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): metagraph: bittensor.metagraph = subtensor.metagraph(netuid=cli.config.netuid) metagraph.save() difficulty = subtensor.difficulty(cli.config.netuid) - subnet_emission = bittensor.Balance.from_tao( + bittensor.Balance.from_tao( subtensor.get_emission_value_by_subnet(cli.config.netuid) ) total_issuance = bittensor.Balance.from_rao(subtensor.total_issuance().rao) diff --git a/bittensor/commands/network.py b/bittensor/commands/network.py index 38c40fb05b..109d03013d 100644 --- a/bittensor/commands/network.py +++ b/bittensor/commands/network.py @@ -16,7 +16,7 @@ # DEALINGS IN THE SOFTWARE. import argparse -from typing import Dict, List, Optional +from typing import Optional from rich.prompt import Prompt from rich.table import Table @@ -165,7 +165,7 @@ def run(cli: "bittensor.cli"): @staticmethod def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""View locking cost of creating a new subnetwork""" - config = cli.config.copy() + cli.config.copy() try: bittensor.__console__.print( f"Subnet lock cost: [green]{bittensor.utils.balance.Balance( subtensor.get_subnet_burn_cost() )}[/green]" @@ -241,11 +241,11 @@ def run(cli: "bittensor.cli"): @staticmethod def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""List all subnet netuids in the network.""" - subnets: List[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() + subnets: list[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() rows = [] total_neurons = 0 - delegate_info: Optional[Dict[str, DelegatesDetails]] = get_delegates_details( + delegate_info: Optional[dict[str, DelegatesDetails]] = get_delegates_details( url=bittensor.__delegates_details_url__ ) diff --git a/bittensor/commands/overview.py b/bittensor/commands/overview.py index d4715085b7..c43bae04b4 100644 --- a/bittensor/commands/overview.py +++ b/bittensor/commands/overview.py @@ -18,7 +18,7 @@ import argparse from collections import defaultdict from concurrent.futures import ProcessPoolExecutor -from typing import Dict, List, Optional, Tuple +from typing import Optional from fuzzywuzzy import fuzz from rich.align import Align @@ -98,7 +98,7 @@ def _get_total_balance( total_balance: "bittensor.Balance", subtensor: "bittensor.subtensor", cli: "bittensor.cli", - ) -> Tuple[List["bittensor.wallet"], "bittensor.Balance"]: + ) -> tuple[list["bittensor.wallet"], "bittensor.Balance"]: if cli.config.get("all", d=None): cold_wallets = get_coldkey_wallets_for_path(cli.config.wallet.path) for cold_wallet in tqdm(cold_wallets, desc="Pulling balances"): @@ -129,8 +129,8 @@ def _get_total_balance( @staticmethod def _get_hotkeys( - cli: "bittensor.cli", all_hotkeys: List["bittensor.wallet"] - ) -> List["bittensor.wallet"]: + cli: "bittensor.cli", all_hotkeys: list["bittensor.wallet"] + ) -> list["bittensor.wallet"]: if not cli.config.get("all_hotkeys", False): # We are only showing hotkeys that are specified. all_hotkeys = [ @@ -148,7 +148,7 @@ def _get_hotkeys( return all_hotkeys @staticmethod - def _get_key_address(all_hotkeys: List["bittensor.wallet"]): + def _get_key_address(all_hotkeys: list["bittensor.wallet"]): hotkey_coldkey_to_hotkey_wallet = {} for hotkey_wallet in all_hotkeys: if hotkey_wallet.hotkey.ss58_address not in hotkey_coldkey_to_hotkey_wallet: @@ -164,10 +164,10 @@ def _get_key_address(all_hotkeys: List["bittensor.wallet"]): @staticmethod def _process_neuron_results( - results: List[Tuple[int, List["bittensor.NeuronInfoLite"], Optional[str]]], - neurons: Dict[str, List["bittensor.NeuronInfoLite"]], - netuids: List[int], - ) -> Dict[str, List["bittensor.NeuronInfoLite"]]: + results: list[tuple[int, list["bittensor.NeuronInfoLite"], Optional[str]]], + neurons: dict[str, list["bittensor.NeuronInfoLite"]], + netuids: list[int], + ) -> dict[str, list["bittensor.NeuronInfoLite"]]: for result in results: netuid, neurons_result, err_msg = result if err_msg is not None: @@ -205,7 +205,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): return # Pull neuron info for all keys. - neurons: Dict[str, List[bittensor.NeuronInfoLite]] = {} + neurons: dict[str, list[bittensor.NeuronInfoLite]] = {} block = subtensor.block netuids = subtensor.get_all_subnet_netuids() @@ -612,16 +612,16 @@ def overview_sort_function(row): @staticmethod def _get_neurons_for_netuid( - args_tuple: Tuple["bittensor.Config", int, List[str]], - ) -> Tuple[int, List["bittensor.NeuronInfoLite"], Optional[str]]: + args_tuple: tuple["bittensor.Config", int, list[str]], + ) -> tuple[int, list["bittensor.NeuronInfoLite"], Optional[str]]: subtensor_config, netuid, hot_wallets = args_tuple - result: List["bittensor.NeuronInfoLite"] = [] + result: list["bittensor.NeuronInfoLite"] = [] try: subtensor = bittensor.subtensor(config=subtensor_config, log_verbose=False) - all_neurons: List["bittensor.NeuronInfoLite"] = subtensor.neurons_lite( + all_neurons: list["bittensor.NeuronInfoLite"] = subtensor.neurons_lite( netuid=netuid ) # Map the hotkeys to uids @@ -643,13 +643,13 @@ def _get_neurons_for_netuid( @staticmethod def _get_de_registered_stake_for_coldkey_wallet( args_tuple, - ) -> Tuple[ - "bittensor.Wallet", List[Tuple[str, "bittensor.Balance"]], Optional[str] + ) -> tuple[ + "bittensor.Wallet", list[tuple[str, "bittensor.Balance"]], Optional[str] ]: subtensor_config, all_hotkey_addresses, coldkey_wallet = args_tuple # List of (hotkey_addr, our_stake) tuples. - result: List[Tuple[str, "bittensor.Balance"]] = [] + result: list[tuple[str, "bittensor.Balance"]] = [] try: subtensor = bittensor.subtensor(config=subtensor_config, log_verbose=False) @@ -770,7 +770,7 @@ def check_config(config: "bittensor.config"): wallet_name = Prompt.ask("Enter wallet name", default=defaults.wallet.name) config.wallet.name = str(wallet_name) - if config.netuids != [] and config.netuids != None: + if config.netuids != [] and config.netuids is not None: if not isinstance(config.netuids, list): config.netuids = [int(config.netuids)] else: diff --git a/bittensor/commands/register.py b/bittensor/commands/register.py index 804c791f8f..6502250fea 100644 --- a/bittensor/commands/register.py +++ b/bittensor/commands/register.py @@ -104,8 +104,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): Confirm.ask( f"Your balance is: [bold green]{balance}[/bold green]\nThe cost to register by recycle is [bold red]{current_recycle}[/bold red]\nDo you want to continue?", default=False, - ) - == False + ) is False ): sys.exit(1) diff --git a/bittensor/commands/root.py b/bittensor/commands/root.py index 8aaa2d5624..ba79f46475 100644 --- a/bittensor/commands/root.py +++ b/bittensor/commands/root.py @@ -17,8 +17,7 @@ import argparse import re -import typing -from typing import Dict, List, Optional +from typing import Optional import numpy as np from rich.prompt import Prompt @@ -145,10 +144,10 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) senate_members = subtensor.get_senate_members() - root_neurons: typing.List[bittensor.NeuronInfoLite] = subtensor.neurons_lite( + root_neurons: list[bittensor.NeuronInfoLite] = subtensor.neurons_lite( netuid=0 ) - delegate_info: Optional[Dict[str, DelegatesDetails]] = get_delegates_details( + delegate_info: Optional[dict[str, DelegatesDetails]] = get_delegates_details( url=bittensor.__delegates_details_url__ ) @@ -488,7 +487,7 @@ def run(cli: "bittensor.cli"): def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""Set weights for root network.""" wallet = bittensor.wallet(config=cli.config) - subnets: List[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() + subnets: list[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() # Get values if not set. if not cli.config.is_set("netuids"): diff --git a/bittensor/commands/senate.py b/bittensor/commands/senate.py index 4a66217bb7..19c0665bf7 100644 --- a/bittensor/commands/senate.py +++ b/bittensor/commands/senate.py @@ -17,7 +17,7 @@ import argparse -from typing import Dict, Optional +from typing import Optional from rich.prompt import Confirm, Prompt from rich.table import Table @@ -71,7 +71,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) senate_members = subtensor.get_senate_members() - delegate_info: Optional[Dict[str, DelegatesDetails]] = get_delegates_details( + delegate_info: Optional[dict[str, DelegatesDetails]] = get_delegates_details( url=bittensor.__delegates_details_url__ ) @@ -210,7 +210,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): senate_members = subtensor.get_senate_members() proposals = subtensor.get_proposals() - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) @@ -333,11 +333,11 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): return proposal_vote_data = subtensor.get_vote_data(proposal_hash) - if proposal_vote_data == None: + if proposal_vote_data is None: console.print(":cross_mark: [red]Failed[/red]: Proposal not found.") return - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) @@ -593,7 +593,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): wallet.coldkey vote_data = subtensor.get_vote_data(proposal_hash) - if vote_data == None: + if vote_data is None: console.print(":cross_mark: [red]Failed[/red]: Proposal not found.") return diff --git a/bittensor/commands/stake.py b/bittensor/commands/stake.py index e98ecc3c15..564e7e3aba 100644 --- a/bittensor/commands/stake.py +++ b/bittensor/commands/stake.py @@ -18,7 +18,7 @@ import argparse import os import sys -from typing import Dict, List, Optional, Tuple, Union +from typing import Optional, Union from rich.prompt import Confirm, Prompt from rich.table import Table @@ -87,14 +87,14 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): wallet = bittensor.wallet(config=config) # Get the hotkey_names (if any) and the hotkey_ss58s. - hotkeys_to_stake_to: List[Tuple[Optional[str], str]] = [] + hotkeys_to_stake_to: list[tuple[Optional[str], str]] = [] if config.get("all_hotkeys"): # Stake to all hotkeys. - all_hotkeys: List[bittensor.wallet] = get_hotkey_wallets_for_wallet( + all_hotkeys: list[bittensor.wallet] = get_hotkey_wallets_for_wallet( wallet=wallet ) # Get the hotkeys to exclude. (d)efault to no exclusions. - hotkeys_to_exclude: List[str] = cli.config.get("hotkeys", d=[]) + hotkeys_to_exclude: list[str] = cli.config.get("hotkeys", d=[]) # Exclude hotkeys that are specified. hotkeys_to_stake_to = [ (wallet.hotkey_str, wallet.hotkey.ss58_address) @@ -139,10 +139,10 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): # Get coldkey balance wallet_balance: Balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) - final_hotkeys: List[Tuple[str, str]] = [] - final_amounts: List[Union[float, Balance]] = [] + final_hotkeys: list[tuple[str, str]] = [] + final_amounts: list[Union[float, Balance]] = [] for hotkey in tqdm(hotkeys_to_stake_to): - hotkey: Tuple[Optional[str], str] # (hotkey_name (or None), hotkey_ss58) + hotkey: tuple[Optional[str], str] # (hotkey_name (or None), hotkey_ss58) if not subtensor.is_hotkey_registered_any(hotkey_ss58=hotkey[1]): # Hotkey is not registered. if len(hotkeys_to_stake_to) == 1: @@ -298,7 +298,7 @@ def add_args(cls, parser: argparse.ArgumentParser): bittensor.subtensor.add_args(stake_parser) -def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def _get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: try: wallet_names = next(os.walk(os.path.expanduser(path)))[1] return [bittensor.wallet(path=path, name=name) for name in wallet_names] @@ -308,7 +308,7 @@ def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: return wallets -def _get_hotkey_wallets_for_wallet(wallet) -> List["bittensor.wallet"]: +def _get_hotkey_wallets_for_wallet(wallet) -> list["bittensor.wallet"]: hotkey_wallets = [] hotkeys_path = wallet.path + "/" + wallet.name + "/hotkeys" try: @@ -376,17 +376,17 @@ def run(cli: "bittensor.cli"): @staticmethod def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): r"""Show all stake accounts.""" - if cli.config.get("all", d=False) == True: + if cli.config.get("all", d=False) is True: wallets = _get_coldkey_wallets_for_path(cli.config.wallet.path) else: wallets = [bittensor.wallet(config=cli.config)] - registered_delegate_info: Optional[Dict[str, DelegatesDetails]] = ( + registered_delegate_info: Optional[dict[str, DelegatesDetails]] = ( get_delegates_details(url=bittensor.__delegates_details_url__) ) def get_stake_accounts( wallet, subtensor - ) -> Dict[str, Dict[str, Union[str, Balance]]]: + ) -> dict[str, dict[str, Union[str, Balance]]]: """Get stake account details for the given wallet. Args: @@ -415,7 +415,7 @@ def get_stake_accounts( def get_stakes_from_hotkeys( subtensor, wallet - ) -> Dict[str, Dict[str, Union[str, Balance]]]: + ) -> dict[str, dict[str, Union[str, Balance]]]: """Fetch stakes from hotkeys for the provided wallet. Args: @@ -448,7 +448,7 @@ def get_stakes_from_hotkeys( def get_stakes_from_delegates( subtensor, wallet - ) -> Dict[str, Dict[str, Union[str, Balance]]]: + ) -> dict[str, dict[str, Union[str, Balance]]]: """Fetch stakes from delegates for the provided wallet. Args: @@ -480,7 +480,7 @@ def get_stakes_from_delegates( def get_all_wallet_accounts( wallets, subtensor, - ) -> List[Dict[str, Dict[str, Union[str, Balance]]]]: + ) -> list[dict[str, dict[str, Union[str, Balance]]]]: """Fetch stake accounts for all provided wallets using a ThreadPool. Args: diff --git a/bittensor/commands/unstake.py b/bittensor/commands/unstake.py index 2634ec90c2..ac1f859eac 100644 --- a/bittensor/commands/unstake.py +++ b/bittensor/commands/unstake.py @@ -16,7 +16,7 @@ # DEALINGS IN THE SOFTWARE. import sys -from typing import List, Optional, Tuple, Union +from typing import Optional, Union from rich.prompt import Confirm, Prompt from tqdm import tqdm @@ -174,17 +174,17 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): wallet = bittensor.wallet(config=config) # Get the hotkey_names (if any) and the hotkey_ss58s. - hotkeys_to_unstake_from: List[Tuple[Optional[str], str]] = [] + hotkeys_to_unstake_from: list[tuple[Optional[str], str]] = [] if cli.config.get("hotkey_ss58address"): # Stake to specific hotkey. hotkeys_to_unstake_from = [(None, cli.config.get("hotkey_ss58address"))] elif cli.config.get("all_hotkeys"): # Stake to all hotkeys. - all_hotkeys: List[bittensor.wallet] = get_hotkey_wallets_for_wallet( + all_hotkeys: list[bittensor.wallet] = get_hotkey_wallets_for_wallet( wallet=wallet ) # Get the hotkeys to exclude. (d)efault to no exclusions. - hotkeys_to_exclude: List[str] = cli.config.get("hotkeys", d=[]) + hotkeys_to_exclude: list[str] = cli.config.get("hotkeys", d=[]) # Exclude hotkeys that are specified. hotkeys_to_unstake_from = [ (wallet.hotkey_str, wallet.hotkey.ss58_address) @@ -229,17 +229,17 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): (None, bittensor.wallet(config=cli.config).hotkey.ss58_address) ] - final_hotkeys: List[Tuple[str, str]] = [] - final_amounts: List[Union[float, Balance]] = [] + final_hotkeys: list[tuple[str, str]] = [] + final_amounts: list[Union[float, Balance]] = [] for hotkey in tqdm(hotkeys_to_unstake_from): - hotkey: Tuple[Optional[str], str] # (hotkey_name (or None), hotkey_ss58) + hotkey: tuple[Optional[str], str] # (hotkey_name (or None), hotkey_ss58) unstake_amount_tao: float = cli.config.get( "amount" ) # The amount specified to unstake. hotkey_stake: Balance = subtensor.get_stake_for_coldkey_and_hotkey( hotkey_ss58=hotkey[1], coldkey_ss58=wallet.coldkeypub.ss58_address ) - if unstake_amount_tao == None: + if unstake_amount_tao is None: unstake_amount_tao = hotkey_stake.tao if cli.config.get("max_stake"): # Get the current stake of the hotkey from this coldkey. diff --git a/bittensor/commands/utils.py b/bittensor/commands/utils.py index cf5fe25aaf..d7a2c07385 100644 --- a/bittensor/commands/utils.py +++ b/bittensor/commands/utils.py @@ -18,7 +18,7 @@ import os import sys from dataclasses import dataclass -from typing import Any, Dict, List, Optional +from typing import Any, Optional import requests from rich.prompt import Confirm, PromptBase @@ -93,8 +93,8 @@ def check_for_cuda_reg_config(config: "bittensor.config") -> None: config.pow_register.cuda.use_cuda and config.pow_register.cuda.get("dev_id") is None ): - devices: List[str] = [str(x) for x in range(torch.cuda.device_count())] - device_names: List[str] = [ + devices: list[str] = [str(x) for x in range(torch.cuda.device_count())] + device_names: list[str] = [ torch.cuda.get_device_name(x) for x in range(torch.cuda.device_count()) ] @@ -130,7 +130,7 @@ def check_for_cuda_reg_config(config: "bittensor.config") -> None: config.pow_register.cuda.use_cuda = defaults.pow_register.cuda.use_cuda -def get_hotkey_wallets_for_wallet(wallet) -> List["bittensor.wallet"]: +def get_hotkey_wallets_for_wallet(wallet) -> list["bittensor.wallet"]: hotkey_wallets = [] hotkeys_path = wallet.path + "/" + wallet.name + "/hotkeys" try: @@ -152,7 +152,7 @@ def get_hotkey_wallets_for_wallet(wallet) -> List["bittensor.wallet"]: return hotkey_wallets -def get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: try: wallet_names = next(os.walk(os.path.expanduser(path)))[1] return [bittensor.wallet(path=path, name=name) for name in wallet_names] @@ -162,7 +162,7 @@ def get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: return wallets -def get_all_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def get_all_wallets_for_path(path: str) -> list["bittensor.wallet"]: all_wallets = [] cold_wallets = get_coldkey_wallets_for_path(path) for cold_wallet in cold_wallets: @@ -176,7 +176,7 @@ def get_all_wallets_for_path(path: str) -> List["bittensor.wallet"]: def filter_netuids_by_registered_hotkeys( cli, subtensor, netuids, all_hotkeys -) -> List[int]: +) -> list[int]: netuids_with_registered_hotkeys = [] for wallet in all_hotkeys: netuids_list = subtensor.get_netuids_for_hotkey(wallet.hotkey.ss58_address) @@ -185,7 +185,7 @@ def filter_netuids_by_registered_hotkeys( ) netuids_with_registered_hotkeys.extend(netuids_list) - if cli.config.netuids == None or cli.config.netuids == []: + if cli.config.netuids is None or cli.config.netuids == []: netuids = netuids_with_registered_hotkeys elif cli.config.netuids != []: @@ -203,7 +203,7 @@ class DelegatesDetails: signature: str @classmethod - def from_json(cls, json: Dict[str, any]) -> "DelegatesDetails": + def from_json(cls, json: dict[str, any]) -> "DelegatesDetails": return cls( name=json["name"], url=json["url"], @@ -214,11 +214,11 @@ def from_json(cls, json: Dict[str, any]) -> "DelegatesDetails": def _get_delegates_details_from_github( requests_get, url: str -) -> Dict[str, DelegatesDetails]: +) -> dict[str, DelegatesDetails]: response = requests_get(url) if response.status_code == 200: - all_delegates: Dict[str, Any] = response.json() + all_delegates: dict[str, Any] = response.json() all_delegates_details = {} for delegate_hotkey, delegates_details in all_delegates.items(): all_delegates_details[delegate_hotkey] = DelegatesDetails.from_json( @@ -229,7 +229,7 @@ def _get_delegates_details_from_github( return {} -def get_delegates_details(url: str) -> Optional[Dict[str, DelegatesDetails]]: +def get_delegates_details(url: str) -> Optional[dict[str, DelegatesDetails]]: try: return _get_delegates_details_from_github(requests.get, url) except Exception: diff --git a/bittensor/commands/wallets.py b/bittensor/commands/wallets.py index 8c3b2b184c..912a5d4005 100644 --- a/bittensor/commands/wallets.py +++ b/bittensor/commands/wallets.py @@ -18,7 +18,7 @@ import argparse import os import sys -from typing import List, Optional, Tuple +from typing import Optional import requests from rich.prompt import Confirm, Prompt @@ -85,9 +85,9 @@ def check_config(config: "bittensor.config"): wallet_name = Prompt.ask("Enter wallet name", default=defaults.wallet.name) config.wallet.name = str(wallet_name) if ( - config.mnemonic == None - and config.get("seed", d=None) == None - and config.get("json", d=None) == None + config.mnemonic is None + and config.get("seed", d=None) is None + and config.get("json", d=None) is None ): prompt_answer = Prompt.ask("Enter mnemonic, seed, or json file location") if prompt_answer.startswith("0x"): @@ -97,7 +97,7 @@ def check_config(config: "bittensor.config"): else: config.json = prompt_answer - if config.get("json", d=None) and config.get("json_password", d=None) == None: + if config.get("json", d=None) and config.get("json_password", d=None) is None: config.json_password = Prompt.ask( "Enter json backup password", password=True ) @@ -191,7 +191,7 @@ def check_config(config: "bittensor.config"): if not config.is_set("wallet.name") and not config.no_prompt: wallet_name = Prompt.ask("Enter wallet name", default=defaults.wallet.name) config.wallet.name = str(wallet_name) - if config.ss58_address == None and config.public_key_hex == None: + if config.ss58_address is None and config.public_key_hex is None: prompt_answer = Prompt.ask( "Enter the ss58_address or the public key in hex" ) @@ -303,9 +303,9 @@ def check_config(config: "bittensor.config"): hotkey = Prompt.ask("Enter hotkey name", default=defaults.wallet.hotkey) config.wallet.hotkey = str(hotkey) if ( - config.mnemonic == None - and config.get("seed", d=None) == None - and config.get("json", d=None) == None + config.mnemonic is None + and config.get("seed", d=None) is None + and config.get("json", d=None) is None ): prompt_answer = Prompt.ask("Enter mnemonic, seed, or json file location") if prompt_answer.startswith("0x"): @@ -315,7 +315,7 @@ def check_config(config: "bittensor.config"): else: config.json = prompt_answer - if config.get("json", d=None) and config.get("json_password", d=None) == None: + if config.get("json", d=None) and config.get("json_password", d=None) is None: config.json_password = Prompt.ask( "Enter json backup password", password=True ) @@ -617,7 +617,7 @@ def add_args(parser: argparse.ArgumentParser): bittensor.subtensor.add_args(new_coldkey_parser) -def _get_coldkey_wallets_for_path(path: str) -> List["bittensor.wallet"]: +def _get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: """Get all coldkey wallet names from path.""" try: wallet_names = next(os.walk(os.path.expanduser(path)))[1] @@ -655,7 +655,7 @@ class UpdateWalletCommand: def run(cli): """Check if any of the wallets needs an update.""" config = cli.config.copy() - if config.get("all", d=False) == True: + if config.get("all", d=False) is True: wallets = _get_coldkey_wallets_for_path(config.wallet.path) else: wallets = [bittensor.wallet(config=config)] @@ -676,14 +676,14 @@ def add_args(parser: argparse.ArgumentParser): @staticmethod def check_config(config: "bittensor.Config"): - if config.get("all", d=False) == False: + if config.get("all", d=False) is False: if not config.no_prompt: if Confirm.ask("Do you want to update all legacy wallets?"): config["all"] = True # Ask the user to specify the wallet if the wallet name is not clear. if ( - config.get("all", d=False) == False + config.get("all", d=False) is False and config.wallet.get("name") == bittensor.defaults.wallet.name and not config.no_prompt ): @@ -693,7 +693,7 @@ def check_config(config: "bittensor.Config"): config.wallet.name = str(wallet_name) -def _get_coldkey_ss58_addresses_for_path(path: str) -> Tuple[List[str], List[str]]: +def _get_coldkey_ss58_addresses_for_path(path: str) -> tuple[list[str], list[str]]: """Get all coldkey ss58 addresses from path.""" def list_coldkeypub_files(dir_path): @@ -777,7 +777,7 @@ def run(cli: "bittensor.cli"): @staticmethod def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): - wallet = bittensor.wallet(config=cli.config) + bittensor.wallet(config=cli.config) wallet_names = [] coldkeys = [] @@ -1016,7 +1016,7 @@ def check_config(config: "bittensor.config"): config.wallet.name = str(wallet_name) -def get_wallet_transfers(wallet_address) -> List[dict]: +def get_wallet_transfers(wallet_address) -> list[dict]: """Get all transfers associated with the provided wallet address.""" variables = { diff --git a/bittensor/config.py b/bittensor/config.py index a390312d91..1e212a6778 100644 --- a/bittensor/config.py +++ b/bittensor/config.py @@ -25,7 +25,7 @@ import os import sys from copy import deepcopy -from typing import Any, Dict, List, Optional, Type, TypeVar +from typing import Any, Optional, TypeVar import yaml from munch import DefaultMunch @@ -42,7 +42,7 @@ class config(DefaultMunch): Implementation of the config class, which manages the configuration of different Bittensor modules. """ - __is_set: Dict[str, bool] + __is_set: dict[str, bool] r""" Translates the passed parser into a nested Bittensor config. @@ -64,7 +64,7 @@ class config(DefaultMunch): def __init__( self, parser: argparse.ArgumentParser = None, - args: Optional[List[str]] = None, + args: Optional[list[str]] = None, strict: bool = False, default: Optional[Any] = None, ) -> None: @@ -72,7 +72,7 @@ def __init__( self["__is_set"] = {} - if parser == None: + if parser is None: return None # Optionally add config specific arguments @@ -121,7 +121,7 @@ def __init__( pass # Get args from argv if not passed in. - if args == None: + if args is None: args = sys.argv[1:] # Check for missing required arguments before proceeding @@ -149,7 +149,7 @@ def __init__( ## strict=True when passed in OR when --strict is set strict = config_params.strict or strict - if config_file_path != None: + if config_file_path is not None: config_file_path = os.path.expanduser(config_file_path) try: with open(config_file_path) as f: @@ -176,10 +176,10 @@ def __init__( # Only command as the arg, else no args default_param_args = ( [_config.get("command")] - if _config.get("command") != None and _config.get("subcommand") == None + if _config.get("command") is not None and _config.get("subcommand") is None else [] ) - if _config.get("command") != None and _config.get("subcommand") != None: + if _config.get("command") is not None and _config.get("subcommand") is not None: default_param_args = [_config.get("command"), _config.get("subcommand")] ## Get all args by name @@ -193,7 +193,7 @@ def __init__( parser_no_defaults._defaults.clear() # Needed for quirk of argparse ### Check for subparsers and do the same - if parser_no_defaults._subparsers != None: + if parser_no_defaults._subparsers is not None: for action in parser_no_defaults._subparsers._actions: # Should only be the "command" subparser action if isinstance(action, argparse._SubParsersAction): @@ -241,7 +241,7 @@ def __split_params__(params: argparse.Namespace, _config: "config"): keys = split_keys while len(keys) > 1: if ( - hasattr(head, keys[0]) and head[keys[0]] != None + hasattr(head, keys[0]) and head[keys[0]] is not None ): # Needs to be Config head = getattr(head, keys[0]) keys = keys[1:] @@ -254,7 +254,7 @@ def __split_params__(params: argparse.Namespace, _config: "config"): @staticmethod def __parse_args__( - args: List[str], parser: argparse.ArgumentParser = None, strict: bool = False + args: list[str], parser: argparse.ArgumentParser = None, strict: bool = False ) -> argparse.Namespace: """Parses the passed args use the passed parser. @@ -355,7 +355,7 @@ def merge(self, b): self = self._merge(self, b) @classmethod - def merge_all(cls, configs: List["config"]) -> "config": + def merge_all(cls, configs: list["config"]) -> "config": """ Merge all configs in the list into one config. If there is a conflict, the value from the last configuration in the list will take precedence. @@ -383,14 +383,14 @@ def is_set(self, param_name: str) -> bool: return self.get("__is_set")[param_name] def __check_for_missing_required_args( - self, parser: argparse.ArgumentParser, args: List[str] - ) -> List[str]: + self, parser: argparse.ArgumentParser, args: list[str] + ) -> list[str]: required_args = self.__get_required_args_from_parser(parser) missing_args = [arg for arg in required_args if not any(arg in s for s in args)] return missing_args @staticmethod - def __get_required_args_from_parser(parser: argparse.ArgumentParser) -> List[str]: + def __get_required_args_from_parser(parser: argparse.ArgumentParser) -> list[str]: required_args = [] for action in parser._actions: if action.required: @@ -409,7 +409,7 @@ class DefaultConfig(config): """ @classmethod - def default(cls: Type[T]) -> T: + def default(cls: type[T]) -> T: """ Get default config. """ diff --git a/bittensor/dendrite.py b/bittensor/dendrite.py index 16de67c921..ac7528b4ee 100644 --- a/bittensor/dendrite.py +++ b/bittensor/dendrite.py @@ -23,7 +23,7 @@ import time import uuid from collections.abc import AsyncGenerator -from typing import Any, List, Optional, Union +from typing import Any import aiohttp @@ -98,7 +98,7 @@ class DendriteMixin: """ def __init__( - self, wallet: Optional[Union[bittensor.wallet, bittensor.Keypair]] = None + self, wallet: bittensor.wallet | bittensor.Keypair | None = None ): """ Initializes the Dendrite object, setting up essential properties. @@ -108,7 +108,7 @@ def __init__( The user's wallet or keypair used for signing messages. Defaults to ``None``, in which case a new :func:`bittensor.wallet().hotkey` is generated and used. """ # Initialize the parent class - super(DendriteMixin, self).__init__() + super().__init__() # Unique identifier for the instance self.uuid = str(uuid.uuid1()) @@ -123,7 +123,7 @@ def __init__( self.synapse_history: list = [] - self._session: Optional[aiohttp.ClientSession] = None + self._session: aiohttp.ClientSession | None = None @property async def session(self) -> aiohttp.ClientSession: @@ -293,8 +293,8 @@ def _log_incoming_response(self, synapse): def query( self, *args, **kwargs - ) -> List[ - Union[AsyncGenerator[Any, Any], bittensor.Synapse, bittensor.StreamingSynapse] + ) -> list[ + AsyncGenerator[Any, Any] | bittensor.Synapse | bittensor.StreamingSynapse ]: """ Makes a synchronous request to multiple target Axons and returns the server responses. @@ -325,17 +325,14 @@ def query( async def forward( self, - axons: Union[ - List[Union[bittensor.AxonInfo, bittensor.axon]], - Union[bittensor.AxonInfo, bittensor.axon], - ], + axons: list[bittensor.AxonInfo | bittensor.axon] | bittensor.AxonInfo | bittensor.axon, synapse: bittensor.Synapse = bittensor.Synapse(), timeout: float = 12, deserialize: bool = True, run_async: bool = True, streaming: bool = False, - ) -> List[ - Union[AsyncGenerator[Any, Any], bittensor.Synapse, bittensor.StreamingSynapse] + ) -> list[ + AsyncGenerator[Any, Any] | bittensor.Synapse | bittensor.StreamingSynapse ]: """ Asynchronously sends requests to one or multiple Axons and collates their responses. @@ -401,9 +398,7 @@ async def forward( async def query_all_axons( is_stream: bool, - ) -> Union[ - AsyncGenerator[Any, Any], bittensor.Synapse, bittensor.StreamingSynapse - ]: + ) -> AsyncGenerator[Any, Any] | bittensor.Synapse | bittensor.StreamingSynapse: """ Handles the processing of requests to all targeted axons, accommodating both streaming and non-streaming responses. @@ -423,9 +418,7 @@ async def query_all_axons( async def single_axon_response( target_axon, - ) -> Union[ - AsyncGenerator[Any, Any], bittensor.Synapse, bittensor.StreamingSynapse - ]: + ) -> AsyncGenerator[Any, Any] | bittensor.Synapse | bittensor.StreamingSynapse: """ Manages the request and response process for a single axon, supporting both streaming and non-streaming modes. @@ -477,7 +470,7 @@ async def single_axon_response( async def call( self, - target_axon: Union[bittensor.AxonInfo, bittensor.axon], + target_axon: bittensor.AxonInfo | bittensor.axon, synapse: bittensor.Synapse = bittensor.Synapse(), timeout: float = 12.0, deserialize: bool = True, @@ -552,7 +545,7 @@ async def call( async def call_stream( self, - target_axon: Union[bittensor.AxonInfo, bittensor.axon], + target_axon: bittensor.AxonInfo | bittensor.axon, synapse: bittensor.StreamingSynapse = bittensor.Synapse(), # type: ignore timeout: float = 12.0, deserialize: bool = True, @@ -818,12 +811,12 @@ def __del__(self): # For back-compatibility with torch -BaseModel: Union[torch.nn.Module, object] = torch.nn.Module if use_torch() else object +BaseModel: torch.nn.Module | object = torch.nn.Module if use_torch() else object class dendrite(DendriteMixin, BaseModel): # type: ignore def __init__( - self, wallet: Optional[Union[bittensor.wallet, bittensor.Keypair]] = None + self, wallet: bittensor.wallet | bittensor.Keypair | None = None ): if use_torch(): torch.nn.Module.__init__(self) diff --git a/bittensor/extrinsics/commit_weights.py b/bittensor/extrinsics/commit_weights.py index e9bbd91a7a..62b9c3de43 100644 --- a/bittensor/extrinsics/commit_weights.py +++ b/bittensor/extrinsics/commit_weights.py @@ -18,7 +18,6 @@ """Module commit weights and reveal weights extrinsic.""" -from typing import List, Tuple from rich.prompt import Confirm @@ -33,7 +32,7 @@ def commit_weights_extrinsic( wait_for_inclusion: bool = False, wait_for_finalization: bool = False, prompt: bool = False, -) -> Tuple[bool, str]: +) -> tuple[bool, str]: """ Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet. This function is a wrapper around the `_do_commit_weights` method, handling user prompts and error messages. @@ -74,14 +73,14 @@ def reveal_weights_extrinsic( subtensor: "bittensor.subtensor", wallet: "bittensor.wallet", netuid: int, - uids: List[int], - weights: List[int], - salt: List[int], + uids: list[int], + weights: list[int], + salt: list[int], version_key: int, wait_for_inclusion: bool = False, wait_for_finalization: bool = False, prompt: bool = False, -) -> Tuple[bool, str]: +) -> tuple[bool, str]: """ Reveals the weights for a specific subnet on the Bittensor blockchain using the provided wallet. This function is a wrapper around the `_do_reveal_weights` method, handling user prompts and error messages. diff --git a/bittensor/extrinsics/delegation.py b/bittensor/extrinsics/delegation.py index 60813622d4..401c788ab2 100644 --- a/bittensor/extrinsics/delegation.py +++ b/bittensor/extrinsics/delegation.py @@ -70,7 +70,7 @@ def nominate_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success == True: + if success is True: bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) @@ -132,14 +132,14 @@ def delegate_extrinsic( # Get state. my_prev_coldkey_balance = subtensor.get_balance(wallet.coldkey.ss58_address) - delegate_take = subtensor.get_delegate_take(delegate_ss58) + subtensor.get_delegate_take(delegate_ss58) delegate_owner = subtensor.get_hotkey_owner(delegate_ss58) my_prev_delegated_stake = subtensor.get_stake_for_coldkey_and_hotkey( coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=delegate_ss58 ) # Convert to bittensor.Balance - if amount == None: + if amount is None: # Stake it all. staking_balance = bittensor.Balance.from_tao(my_prev_coldkey_balance.tao) elif not isinstance(amount, bittensor.Balance): @@ -179,7 +179,7 @@ def delegate_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully staked. + if staking_response is True: # If we successfully staked. # We only wait here if we expect finalization. if not wait_for_finalization and not wait_for_inclusion: return True @@ -253,14 +253,14 @@ def undelegate_extrinsic( # Get state. my_prev_coldkey_balance = subtensor.get_balance(wallet.coldkey.ss58_address) - delegate_take = subtensor.get_delegate_take(delegate_ss58) + subtensor.get_delegate_take(delegate_ss58) delegate_owner = subtensor.get_hotkey_owner(delegate_ss58) my_prev_delegated_stake = subtensor.get_stake_for_coldkey_and_hotkey( coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=delegate_ss58 ) # Convert to bittensor.Balance - if amount == None: + if amount is None: # Stake it all. unstaking_balance = bittensor.Balance.from_tao(my_prev_delegated_stake.tao) @@ -296,7 +296,7 @@ def undelegate_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully staked. + if staking_response is True: # If we successfully staked. # We only wait here if we expect finalization. if not wait_for_finalization and not wait_for_inclusion: return True @@ -374,7 +374,7 @@ def decrease_take_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success == True: + if success is True: bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) @@ -432,7 +432,7 @@ def increase_take_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success == True: + if success is True: bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) diff --git a/bittensor/extrinsics/network.py b/bittensor/extrinsics/network.py index def25a210e..b98b8b29a2 100644 --- a/bittensor/extrinsics/network.py +++ b/bittensor/extrinsics/network.py @@ -157,7 +157,7 @@ def set_hyperparameter_extrinsic( wallet.coldkey # unlock coldkey extrinsic = HYPERPARAMS.get(parameter) - if extrinsic == None: + if extrinsic is None: bittensor.__console__.print( ":cross_mark: [red]Invalid hyperparameter specified.[/red]" ) diff --git a/bittensor/extrinsics/prometheus.py b/bittensor/extrinsics/prometheus.py index 1ebd0c7661..b10e607a11 100644 --- a/bittensor/extrinsics/prometheus.py +++ b/bittensor/extrinsics/prometheus.py @@ -54,7 +54,7 @@ def prometheus_extrinsic( """ # ---- Get external ip ---- - if ip == None: + if ip is None: try: external_ip = net.get_external_ip() bittensor.__console__.print( @@ -118,7 +118,7 @@ def prometheus_extrinsic( ) if wait_for_inclusion or wait_for_finalization: - if success == True: + if success is True: bittensor.__console__.print( f":white_heavy_check_mark: [green]Served prometheus[/green]\n [bold white]{json.dumps(call_params, indent=4, sort_keys=True)}[/bold white]" ) diff --git a/bittensor/extrinsics/registration.py b/bittensor/extrinsics/registration.py index 26d5f1d473..6ddba2a41b 100644 --- a/bittensor/extrinsics/registration.py +++ b/bittensor/extrinsics/registration.py @@ -17,7 +17,7 @@ # DEALINGS IN THE SOFTWARE. import time -from typing import List, Optional, Tuple, Union +from typing import Optional, Union from rich.prompt import Confirm @@ -40,7 +40,7 @@ def register_extrinsic( max_allowed_attempts: int = 3, output_in_place: bool = True, cuda: bool = False, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, tpb: int = 256, num_processes: Optional[int] = None, update_interval: Optional[int] = None, @@ -158,7 +158,7 @@ def register_extrinsic( with bittensor.__console__.status(":satellite: Submitting POW..."): # check if pow result is still valid while not pow_result.is_stale(subtensor=subtensor): - result: Tuple[bool, Optional[str]] = subtensor._do_pow_register( + result: tuple[bool, Optional[str]] = subtensor._do_pow_register( netuid=netuid, wallet=wallet, pow_result=pow_result, @@ -167,7 +167,7 @@ def register_extrinsic( ) success, err_msg = result - if success != True or success == False: + if success is not True or success is False: if "key is already registered" in err_msg: # Error meant that the key is already registered. bittensor.__console__.print( @@ -280,7 +280,7 @@ def burned_register_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success != True or success == False: + if success is not True or success is False: bittensor.__console__.print( f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) @@ -330,12 +330,12 @@ def run_faucet_extrinsic( max_allowed_attempts: int = 3, output_in_place: bool = True, cuda: bool = False, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, tpb: int = 256, num_processes: Optional[int] = None, update_interval: Optional[int] = None, log_verbose: bool = False, -) -> Tuple[bool, str]: +) -> tuple[bool, str]: r"""Runs a continual POW to get a faucet of TAO on the test net. Args: @@ -491,7 +491,7 @@ def swap_hotkey_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success != True or success == False: + if success is not True or success is False: bittensor.__console__.print( f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) diff --git a/bittensor/extrinsics/root.py b/bittensor/extrinsics/root.py index 41d91d7138..044c877559 100644 --- a/bittensor/extrinsics/root.py +++ b/bittensor/extrinsics/root.py @@ -18,7 +18,7 @@ import logging import time -from typing import List, Union +from typing import Union import numpy as np from numpy.typing import NDArray @@ -78,7 +78,7 @@ def root_register_extrinsic( wait_for_finalization=wait_for_finalization, ) - if success != True or success == False: + if success is not True or success is False: bittensor.__console__.print( f":cross_mark: [red]Failed[/red]: error:{err_msg}" ) @@ -105,8 +105,8 @@ def root_register_extrinsic( def set_root_weights_extrinsic( subtensor: "bittensor.subtensor", wallet: "bittensor.wallet", - netuids: Union[NDArray[np.int64], "torch.LongTensor", List[int]], - weights: Union[NDArray[np.float32], "torch.FloatTensor", List[float]], + netuids: Union[NDArray[np.int64], "torch.LongTensor", list[int]], + weights: Union[NDArray[np.float32], "torch.FloatTensor", list[float]], version_key: int = 0, wait_for_inclusion: bool = False, wait_for_finalization: bool = False, @@ -145,7 +145,7 @@ def set_root_weights_extrinsic( # Get non zero values. non_zero_weight_idx = np.argwhere(weights > 0).squeeze(axis=1) - non_zero_weight_uids = netuids[non_zero_weight_idx] + netuids[non_zero_weight_idx] non_zero_weights = weights[non_zero_weight_idx] if non_zero_weights.size < min_allowed_weights: raise ValueError( diff --git a/bittensor/extrinsics/serving.py b/bittensor/extrinsics/serving.py index 1d1dcf8607..806803c023 100644 --- a/bittensor/extrinsics/serving.py +++ b/bittensor/extrinsics/serving.py @@ -124,7 +124,7 @@ def serve_extrinsic( ) if wait_for_inclusion or wait_for_finalization: - if success == True: + if success is True: bittensor.logging.debug( f"Axon served with: AxonInfo({wallet.hotkey.ss58_address},{ip}:{port}) on {subtensor.network}:{netuid} " ) @@ -168,7 +168,7 @@ def serve_axon_extrinsic( external_port = axon.external_port # ---- Get external ip ---- - if axon.external_ip == None: + if axon.external_ip is None: try: external_ip = net.get_external_ip() bittensor.__console__.print( @@ -272,7 +272,7 @@ def make_substrate_call_with_retry(): module="Commitments", storage_function="CommitmentOf", params=[netuid, hotkey], - block_hash=None if block == None else substrate.get_block_hash(block), + block_hash=None if block is None else substrate.get_block_hash(block), ) commit_data = make_substrate_call_with_retry() diff --git a/bittensor/extrinsics/set_weights.py b/bittensor/extrinsics/set_weights.py index b9ee35e555..cd3644ab35 100644 --- a/bittensor/extrinsics/set_weights.py +++ b/bittensor/extrinsics/set_weights.py @@ -17,7 +17,7 @@ # DEALINGS IN THE SOFTWARE. import logging -from typing import Tuple, Union +from typing import Union import numpy as np from numpy.typing import NDArray @@ -41,7 +41,7 @@ def set_weights_extrinsic( wait_for_inclusion: bool = False, wait_for_finalization: bool = False, prompt: bool = False, -) -> Tuple[bool, str]: +) -> tuple[bool, str]: r"""Sets the given weights and values on chain for wallet hotkey account. Args: @@ -108,7 +108,7 @@ def set_weights_extrinsic( if not wait_for_finalization and not wait_for_inclusion: return True, "Not waiting for finalization or inclusion." - if success == True: + if success is True: bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) diff --git a/bittensor/extrinsics/staking.py b/bittensor/extrinsics/staking.py index aa6ce47da2..1b4d5dd848 100644 --- a/bittensor/extrinsics/staking.py +++ b/bittensor/extrinsics/staking.py @@ -17,7 +17,7 @@ # DEALINGS IN THE SOFTWARE. from time import sleep -from typing import List, Optional, Union +from typing import Optional, Union from rich.prompt import Confirm @@ -92,7 +92,7 @@ def add_stake_extrinsic( ) # Convert to bittensor.Balance - if amount == None: + if amount is None: # Stake it all. staking_balance = bittensor.Balance.from_tao(old_balance.tao) elif not isinstance(amount, bittensor.Balance): @@ -140,7 +140,7 @@ def add_stake_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully staked. + if staking_response is True: # If we successfully staked. # We only wait here if we expect finalization. if not wait_for_finalization and not wait_for_inclusion: return True @@ -187,8 +187,8 @@ def add_stake_extrinsic( def add_stake_multiple_extrinsic( subtensor: "bittensor.subtensor", wallet: "bittensor.wallet", - hotkey_ss58s: List[str], - amounts: Optional[List[Union[Balance, float]]] = None, + hotkey_ss58s: list[str], + amounts: Optional[list[Union[Balance, float]]] = None, wait_for_inclusion: bool = True, wait_for_finalization: bool = False, prompt: bool = False, @@ -287,7 +287,7 @@ def add_stake_multiple_extrinsic( ): staking_all = False # Convert to bittensor.Balance - if amount == None: + if amount is None: # Stake it all. staking_balance = bittensor.Balance.from_tao(old_balance.tao) staking_all = True @@ -320,7 +320,7 @@ def add_stake_multiple_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully staked. + if staking_response is True: # If we successfully staked. # We only wait here if we expect finalization. if idx < len(hotkey_ss58s) - 1: diff --git a/bittensor/extrinsics/unstaking.py b/bittensor/extrinsics/unstaking.py index 2cf8a65b02..e88978c333 100644 --- a/bittensor/extrinsics/unstaking.py +++ b/bittensor/extrinsics/unstaking.py @@ -17,7 +17,7 @@ # DEALINGS IN THE SOFTWARE. from time import sleep -from typing import List, Optional, Union +from typing import Optional, Union from rich.prompt import Confirm @@ -142,7 +142,7 @@ def unstake_extrinsic( ) # Convert to bittensor.Balance - if amount == None: + if amount is None: # Unstake it all. unstaking_balance = old_stake elif not isinstance(amount, bittensor.Balance): @@ -183,7 +183,7 @@ def unstake_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully unstaked. + if staking_response is True: # If we successfully unstaked. # We only wait here if we expect finalization. if not wait_for_finalization and not wait_for_inclusion: return True @@ -226,8 +226,8 @@ def unstake_extrinsic( def unstake_multiple_extrinsic( subtensor: "bittensor.subtensor", wallet: "bittensor.wallet", - hotkey_ss58s: List[str], - amounts: Optional[List[Union[Balance, float]]] = None, + hotkey_ss58s: list[str], + amounts: Optional[list[Union[Balance, float]]] = None, wait_for_inclusion: bool = True, wait_for_finalization: bool = False, prompt: bool = False, @@ -302,7 +302,7 @@ def unstake_multiple_extrinsic( zip(hotkey_ss58s, amounts, old_stakes) ): # Covert to bittensor.Balance - if amount == None: + if amount is None: # Unstake it all. unstaking_balance = old_stake elif not isinstance(amount, bittensor.Balance): @@ -343,7 +343,7 @@ def unstake_multiple_extrinsic( wait_for_finalization=wait_for_finalization, ) - if staking_response == True: # If we successfully unstaked. + if staking_response is True: # If we successfully unstaked. # We only wait here if we expect finalization. if idx < len(hotkey_ss58s) - 1: diff --git a/bittensor/keyfile.py b/bittensor/keyfile.py index d9799616da..cf5dd8c08a 100644 --- a/bittensor/keyfile.py +++ b/bittensor/keyfile.py @@ -566,7 +566,7 @@ def check_and_update_encryption( break decrypted_keyfile_data = None - while decrypted_keyfile_data == None and not terminate: + while decrypted_keyfile_data is None and not terminate: try: password = getpass.getpass( "\nEnter password to update keyfile: " diff --git a/bittensor/metagraph.py b/bittensor/metagraph.py index b81b718b9a..f560db5aa2 100644 --- a/bittensor/metagraph.py +++ b/bittensor/metagraph.py @@ -22,7 +22,7 @@ from abc import ABC, abstractmethod from os import listdir from os.path import join -from typing import List, Optional, Tuple, Union +from typing import Optional, Union import numpy as np from numpy.typing import NDArray @@ -153,7 +153,7 @@ class MetagraphMixin(ABC): netuid: int network: str - version: Union["torch.nn.Parameter", Tuple[NDArray]] + version: Union["torch.nn.Parameter", tuple[NDArray]] n: Union["torch.nn.Parameter", NDArray] block: Union["torch.nn.Parameter", NDArray] stake: Union["torch.nn.Parameter", NDArray] @@ -171,7 +171,7 @@ class MetagraphMixin(ABC): weights: Union["torch.nn.Parameter", NDArray] bonds: Union["torch.nn.Parameter", NDArray] uids: Union["torch.nn.Parameter", NDArray] - axons: List[AxonInfo] + axons: list[AxonInfo] @property def S(self) -> Union[NDArray, "torch.nn.Parameter"]: @@ -316,7 +316,7 @@ def W(self) -> Union[NDArray, "torch.nn.Parameter"]: return self.weights @property - def hotkeys(self) -> List[str]: + def hotkeys(self) -> list[str]: """ Represents a list of ``hotkeys`` for each neuron in the Bittensor network. @@ -334,7 +334,7 @@ def hotkeys(self) -> List[str]: return [axon.hotkey for axon in self.axons] @property - def coldkeys(self) -> List[str]: + def coldkeys(self) -> list[str]: """ Contains a list of ``coldkeys`` for each neuron in the Bittensor network. @@ -350,7 +350,7 @@ def coldkeys(self) -> List[str]: return [axon.coldkey for axon in self.axons] @property - def addresses(self) -> List[str]: + def addresses(self) -> list[str]: """ Provides a list of IP addresses for each neuron in the Bittensor network. These addresses are used for network communication, allowing neurons to connect, interact, and exchange information with each other. @@ -927,7 +927,7 @@ def __init__( self.uids = torch.nn.Parameter( torch.tensor([], dtype=torch.int64), requires_grad=False ) - self.axons: List[AxonInfo] = [] + self.axons: list[AxonInfo] = [] if sync: self.sync(block=None, lite=lite) @@ -1064,7 +1064,7 @@ def __init__( self.weights = np.array([], dtype=np.float32) self.bonds = np.array([], dtype=np.int64) self.uids = np.array([], dtype=np.int64) - self.axons: List[AxonInfo] = [] + self.axons: list[AxonInfo] = [] if sync: self.sync(block=None, lite=lite) diff --git a/bittensor/mock/subtensor_mock.py b/bittensor/mock/subtensor_mock.py index e32fd2d19c..05151ce578 100644 --- a/bittensor/mock/subtensor_mock.py +++ b/bittensor/mock/subtensor_mock.py @@ -21,7 +21,7 @@ from hashlib import sha256 from random import randint from types import SimpleNamespace -from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union +from typing import Any, Optional, TypedDict, Union from unittest.mock import MagicMock from ..chain_data import ( @@ -132,12 +132,12 @@ class MockSubtensorValue: class MockMapResult: - records: Optional[List[Tuple[MockSubtensorValue, MockSubtensorValue]]] + records: Optional[list[tuple[MockSubtensorValue, MockSubtensorValue]]] def __init__( self, records: Optional[ - List[Tuple[Union[Any, MockSubtensorValue], Union[Any, MockSubtensorValue]]] + list[tuple[Union[Any, MockSubtensorValue], Union[Any, MockSubtensorValue]]] ] = None, ): _records = [ @@ -166,25 +166,25 @@ def __iter__(self): class MockSystemState(TypedDict): - Account: Dict[str, Dict[int, int]] # address -> block -> balance + Account: dict[str, dict[int, int]] # address -> block -> balance class MockSubtensorState(TypedDict): - Rho: Dict[int, Dict[BlockNumber, int]] # netuid -> block -> rho - Kappa: Dict[int, Dict[BlockNumber, int]] # netuid -> block -> kappa - Difficulty: Dict[int, Dict[BlockNumber, int]] # netuid -> block -> difficulty - ImmunityPeriod: Dict[ - int, Dict[BlockNumber, int] + Rho: dict[int, dict[BlockNumber, int]] # netuid -> block -> rho + Kappa: dict[int, dict[BlockNumber, int]] # netuid -> block -> kappa + Difficulty: dict[int, dict[BlockNumber, int]] # netuid -> block -> difficulty + ImmunityPeriod: dict[ + int, dict[BlockNumber, int] ] # netuid -> block -> immunity_period - ValidatorBatchSize: Dict[ - int, Dict[BlockNumber, int] + ValidatorBatchSize: dict[ + int, dict[BlockNumber, int] ] # netuid -> block -> validator_batch_size - Active: Dict[int, Dict[BlockNumber, bool]] # (netuid, uid), block -> active - Stake: Dict[str, Dict[str, Dict[int, int]]] # (hotkey, coldkey) -> block -> stake + Active: dict[int, dict[BlockNumber, bool]] # (netuid, uid), block -> active + Stake: dict[str, dict[str, dict[int, int]]] # (hotkey, coldkey) -> block -> stake - Delegates: Dict[str, Dict[int, float]] # address -> block -> delegate_take + Delegates: dict[str, dict[int, float]] # address -> block -> delegate_take - NetworksAdded: Dict[int, Dict[BlockNumber, bool]] # netuid -> block -> added + NetworksAdded: dict[int, dict[BlockNumber, bool]] # netuid -> block -> added class MockChainState(TypedDict): @@ -519,7 +519,7 @@ def force_register_neuron( def force_set_balance( self, ss58_address: str, balance: Union["Balance", float, int] = Balance(0) - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Returns: Tuple[bool, Optional[str]]: (success, err_msg) @@ -564,7 +564,7 @@ def do_block_step(self) -> None: + 1 ) - def _handle_type_default(self, name: str, params: List[object]) -> object: + def _handle_type_default(self, name: str, params: list[object]) -> object: defaults_mapping = { "TotalStake": 0, "TotalHotkeyStake": 0, @@ -596,7 +596,7 @@ def query_subtensor( self, name: str, block: Optional[int] = None, - params: Optional[List[object]] = [], + params: Optional[list[object]] = [], ) -> MockSubtensorValue: if block: if self.block_number < block: @@ -632,7 +632,7 @@ def query_map_subtensor( self, name: str, block: Optional[int] = None, - params: Optional[List[object]] = [], + params: Optional[list[object]] = [], ) -> Optional[MockMapResult]: """ Note: Double map requires one param @@ -739,7 +739,7 @@ def get_balance(self, address: str, block: int = None) -> "Balance": else: return Balance(0) - def get_balances(self, block: int = None) -> Dict[str, "Balance"]: + def get_balances(self, block: int = None) -> dict[str, "Balance"]: balances = {} for address in self.chain_state["System"]["Account"]: balances[address] = self.get_balance(address, block) @@ -771,7 +771,7 @@ def neuron_for_uid( else: return neuron_info - def neurons(self, netuid: int, block: Optional[int] = None) -> List[NeuronInfo]: + def neurons(self, netuid: int, block: Optional[int] = None) -> list[NeuronInfo]: if netuid not in self.chain_state["SubtensorModule"]["NetworksAdded"]: raise Exception("Subnet does not exist") @@ -788,7 +788,7 @@ def neurons(self, netuid: int, block: Optional[int] = None) -> List[NeuronInfo]: @staticmethod def _get_most_recent_storage( - storage: Dict[BlockNumber, Any], block_number: Optional[int] = None + storage: dict[BlockNumber, Any], block_number: Optional[int] = None ) -> Any: if block_number is None: items = list(storage.items()) @@ -985,7 +985,7 @@ def neuron_for_uid_lite( def neurons_lite( self, netuid: int, block: Optional[int] = None - ) -> List[NeuronInfoLite]: + ) -> list[NeuronInfoLite]: if netuid not in self.chain_state["SubtensorModule"]["NetworksAdded"]: raise Exception("Subnet does not exist") @@ -1052,7 +1052,6 @@ def _do_nominate( wait_for_finalization: bool = False, ) -> bool: hotkey_ss58 = wallet.hotkey.ss58_address - coldkey_ss58 = wallet.coldkeypub.ss58_address subtensor_state = self.chain_state["SubtensorModule"] if self.is_hotkey_delegate(hotkey_ss58=hotkey_ss58): @@ -1078,7 +1077,7 @@ def _do_transfer( transfer_balance: "Balance", wait_for_inclusion: bool = True, wait_for_finalization: bool = False, - ) -> Tuple[bool, Optional[str], Optional[str]]: + ) -> tuple[bool, Optional[str], Optional[str]]: bal = self.get_balance(wallet.coldkeypub.ss58_address) dest_bal = self.get_balance(dest) transfer_fee = self.get_transfer_fee(wallet, dest, transfer_balance) @@ -1110,7 +1109,7 @@ def _do_pow_register( pow_result: "POWSolution", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: # Assume pow result is valid subtensor_state = self.chain_state["SubtensorModule"] @@ -1131,7 +1130,7 @@ def _do_burned_register( wallet: "wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: subtensor_state = self.chain_state["SubtensorModule"] if netuid not in subtensor_state["NetworksAdded"]: raise Exception("Subnet does not exist") @@ -1364,7 +1363,7 @@ def get_delegate_by_hotkey( return info - def get_delegates(self, block: Optional[int] = None) -> List["DelegateInfo"]: + def get_delegates(self, block: Optional[int] = None) -> list["DelegateInfo"]: subtensor_state = self.chain_state["SubtensorModule"] delegates_info = [] for hotkey in subtensor_state["Delegates"]: @@ -1376,7 +1375,7 @@ def get_delegates(self, block: Optional[int] = None) -> List["DelegateInfo"]: def get_delegated( self, coldkey_ss58: str, block: Optional[int] = None - ) -> List[Tuple["DelegateInfo", "Balance"]]: + ) -> list[tuple["DelegateInfo", "Balance"]]: """Returns the list of delegates that a given coldkey is staked to.""" delegates = self.get_delegates(block=block) @@ -1387,7 +1386,7 @@ def get_delegated( return result - def get_all_subnets_info(self, block: Optional[int] = None) -> List[SubnetInfo]: + def get_all_subnets_info(self, block: Optional[int] = None) -> list[SubnetInfo]: subtensor_state = self.chain_state["SubtensorModule"] result = [] for subnet in subtensor_state["NetworksAdded"]: @@ -1440,7 +1439,7 @@ def _do_serve_prometheus( call_params: "PrometheusServeCallParams", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: return True, None def _do_set_weights( @@ -1448,11 +1447,11 @@ def _do_set_weights( wallet: "wallet", netuid: int, uids: int, - vals: List[int], + vals: list[int], version_key: int, wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: return True, None def _do_serve_axon( @@ -1461,5 +1460,5 @@ def _do_serve_axon( call_params: "AxonServeCallParams", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: return True, None diff --git a/bittensor/mock/wallet_mock.py b/bittensor/mock/wallet_mock.py index 89ab0c2c3c..0aa6254713 100644 --- a/bittensor/mock/wallet_mock.py +++ b/bittensor/mock/wallet_mock.py @@ -48,7 +48,7 @@ def __init__(self, **kwargs): @property def hotkey_file(self) -> "bittensor.keyfile": if self._is_mock: - if self._mocked_hotkey_keyfile == None: + if self._mocked_hotkey_keyfile is None: self._mocked_hotkey_keyfile = MockKeyfile(path="MockedHotkey") return self._mocked_hotkey_keyfile else: @@ -59,7 +59,7 @@ def hotkey_file(self) -> "bittensor.keyfile": @property def coldkey_file(self) -> "bittensor.keyfile": if self._is_mock: - if self._mocked_coldkey_keyfile == None: + if self._mocked_coldkey_keyfile is None: self._mocked_coldkey_keyfile = MockKeyfile(path="MockedColdkey") return self._mocked_coldkey_keyfile else: @@ -70,7 +70,7 @@ def coldkey_file(self) -> "bittensor.keyfile": @property def coldkeypub_file(self) -> "bittensor.keyfile": if self._is_mock: - if self._mocked_coldkey_keyfile == None: + if self._mocked_coldkey_keyfile is None: self._mocked_coldkey_keyfile = MockKeyfile(path="MockedColdkeyPub") return self._mocked_coldkey_keyfile else: diff --git a/bittensor/subnets.py b/bittensor/subnets.py index 4a0da61506..b1e1e4bb6a 100644 --- a/bittensor/subnets.py +++ b/bittensor/subnets.py @@ -18,7 +18,7 @@ # DEALINGS IN THE SOFTWARE. from abc import ABC, abstractmethod -from typing import Any, List, Optional, Union +from typing import Any, Optional, Union import bittensor as bt @@ -39,7 +39,7 @@ def prepare_synapse(self, *args, **kwargs) -> Any: ... @abstractmethod - def process_responses(self, responses: List[Union["bt.Synapse", Any]]) -> Any: + def process_responses(self, responses: list[Union["bt.Synapse", Any]]) -> Any: """ Process the responses from the network. """ @@ -47,7 +47,7 @@ def process_responses(self, responses: List[Union["bt.Synapse", Any]]) -> Any: async def query_api( self, - axons: Union[bt.axon, List[bt.axon]], + axons: Union[bt.axon, list[bt.axon]], deserialize: Optional[bool] = False, timeout: Optional[int] = 12, **kwargs: Optional[Any], diff --git a/bittensor/subtensor.py b/bittensor/subtensor.py index 9505114e0a..a863f8a68a 100644 --- a/bittensor/subtensor.py +++ b/bittensor/subtensor.py @@ -25,7 +25,7 @@ import copy import functools import time -from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union +from typing import Any, Optional, TypedDict, Union import numpy as np import scalecodec @@ -106,7 +106,7 @@ from .utils.registration import POWSolution, legacy_torch_api_compat from .utils.subtensor import get_subtensor_errors -KEY_NONCE: Dict[str, int] = {} +KEY_NONCE: dict[str, int] = {} ####### # Monkey patch in caching the convert_type_string method @@ -285,7 +285,7 @@ def __init__( f"Connected to {self.network} network and {self.chain_endpoint}." ) - self._subtensor_errors: Dict[str, Dict[str, str]] = {} + self._subtensor_errors: dict[str, dict[str, str]] = {} def __str__(self) -> str: if self.network == self.chain_endpoint: @@ -784,7 +784,7 @@ def set_weights( wait_for_finalization: bool = False, prompt: bool = False, max_retries: int = 5, - ) -> Tuple[bool, str]: + ) -> tuple[bool, str]: """ Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or trust a neuron places on other neurons in the network, which is a fundamental aspect @@ -840,13 +840,13 @@ def set_weights( def _do_set_weights( self, wallet: "bittensor.wallet", - uids: List[int], - vals: List[int], + uids: list[int], + vals: list[int], netuid: int, version_key: int = bittensor.__version_as_int__, wait_for_inclusion: bool = False, wait_for_finalization: bool = False, - ) -> Tuple[bool, Optional[str]]: # (success, error_message) + ) -> tuple[bool, Optional[str]]: # (success, error_message) """ Internal method to send a transaction to the Bittensor blockchain, setting weights for specified neurons. This method constructs and submits the transaction, handling @@ -910,7 +910,7 @@ def commit_weights( self, wallet: "bittensor.wallet", netuid: int, - salt: List[int], + salt: list[int], uids: Union[NDArray[np.int64], list], weights: Union[NDArray[np.int64], list], version_key: int = bittensor.__version_as_int__, @@ -918,7 +918,7 @@ def commit_weights( wait_for_finalization: bool = False, prompt: bool = False, max_retries: int = 5, - ) -> Tuple[bool, str]: + ) -> tuple[bool, str]: """ Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet. This action serves as a commitment or snapshot of the neuron's current weight distribution. @@ -989,7 +989,7 @@ def _do_commit_weights( commit_hash: str, wait_for_inclusion: bool = False, wait_for_finalization: bool = False, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Internal method to send a transaction to the Bittensor blockchain, committing the hash of a neuron's weights. This method constructs and submits the transaction, handling retries and blockchain communication. @@ -1054,7 +1054,7 @@ def reveal_weights( wait_for_finalization: bool = False, prompt: bool = False, max_retries: int = 5, - ) -> Tuple[bool, str]: + ) -> tuple[bool, str]: """ Reveals the weights for a specific subnet on the Bittensor blockchain using the provided wallet. This action serves as a revelation of the neuron's previously committed weight distribution. @@ -1109,13 +1109,13 @@ def _do_reveal_weights( self, wallet: "bittensor.wallet", netuid: int, - uids: List[int], - values: List[int], - salt: List[int], + uids: list[int], + values: list[int], + salt: list[int], version_key: int, wait_for_inclusion: bool = False, wait_for_finalization: bool = False, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Internal method to send a transaction to the Bittensor blockchain, revealing the weights for a specific subnet. This method constructs and submits the transaction, handling retries and blockchain communication. @@ -1184,7 +1184,7 @@ def register( max_allowed_attempts: int = 3, output_in_place: bool = True, cuda: bool = False, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, tpb: int = 256, num_processes: Optional[int] = None, update_interval: Optional[int] = None, @@ -1279,7 +1279,7 @@ def run_faucet( max_allowed_attempts: int = 3, output_in_place: bool = True, cuda: bool = False, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, tpb: int = 256, num_processes: Optional[int] = None, update_interval: Optional[int] = None, @@ -1374,7 +1374,7 @@ def _do_pow_register( pow_result: POWSolution, wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """Sends a (POW) register extrinsic to the chain. Args: @@ -1435,7 +1435,7 @@ def _do_burned_register( wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Performs a burned register extrinsic call to the Subtensor chain. @@ -1492,7 +1492,7 @@ def _do_swap_hotkey( new_wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Performs a hotkey swap extrinsic call to the Subtensor chain. @@ -1645,7 +1645,7 @@ def _do_transfer( transfer_balance: "Balance", wait_for_inclusion: bool = True, wait_for_finalization: bool = False, - ) -> Tuple[bool, Optional[str], Optional[str]]: + ) -> tuple[bool, Optional[str], Optional[str]]: """Sends a transfer extrinsic to the chain. Args: @@ -1879,7 +1879,7 @@ def _do_serve_axon( call_params: AxonServeCallParams, wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Internal method to submit a serve axon transaction to the Bittensor blockchain. This method creates and submits a transaction, enabling a neuron's Axon to serve requests on the network. @@ -1946,7 +1946,7 @@ def _do_serve_prometheus( call_params: PrometheusServeCallParams, wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Sends a serve prometheus extrinsic to the chain. Args: @@ -1988,11 +1988,11 @@ def make_substrate_call_with_retry(): def _do_associate_ips( self, wallet: "bittensor.wallet", - ip_info_list: List["IPInfo"], + ip_info_list: list["IPInfo"], netuid: int, wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: """ Sends an associate IPs extrinsic to the chain. @@ -2081,8 +2081,8 @@ def add_stake( def add_stake_multiple( self, wallet: "bittensor.wallet", - hotkey_ss58s: List[str], - amounts: Optional[List[Union["Balance", float]]] = None, + hotkey_ss58s: list[str], + amounts: Optional[list[Union["Balance", float]]] = None, wait_for_inclusion: bool = True, wait_for_finalization: bool = False, prompt: bool = False, @@ -2170,8 +2170,8 @@ def make_substrate_call_with_retry(): def unstake_multiple( self, wallet: "bittensor.wallet", - hotkey_ss58s: List[str], - amounts: Optional[List[Union["Balance", float]]] = None, + hotkey_ss58s: list[str], + amounts: Optional[list[Union["Balance", float]]] = None, wait_for_inclusion: bool = True, wait_for_finalization: bool = False, prompt: bool = False, @@ -2443,7 +2443,7 @@ def get_vote_data( get_proposal_vote_data = get_vote_data - def get_senate_members(self, block: Optional[int] = None) -> Optional[List[str]]: + def get_senate_members(self, block: Optional[int] = None) -> Optional[list[str]]: """ Retrieves the list of current senate members from the Bittensor blockchain. Senate members are responsible for governance and decision-making within the network. @@ -2487,7 +2487,7 @@ def get_proposal_call_data( return proposal_data.serialize() if proposal_data is not None else None - def get_proposal_hashes(self, block: Optional[int] = None) -> Optional[List[str]]: + def get_proposal_hashes(self, block: Optional[int] = None) -> Optional[list[str]]: """ Retrieves the list of proposal hashes currently present on the Bittensor blockchain. Each hash uniquely identifies a proposal made within the network. @@ -2511,7 +2511,7 @@ def get_proposal_hashes(self, block: Optional[int] = None) -> Optional[List[str] def get_proposals( self, block: Optional[int] = None - ) -> Optional[Dict[str, Tuple["GenericCall", "ProposalVoteData"]]]: + ) -> Optional[dict[str, tuple["GenericCall", "ProposalVoteData"]]]: """ Retrieves all active proposals on the Bittensor blockchain, along with their call and voting data. This comprehensive view allows for a thorough understanding of the proposals and their reception @@ -2527,7 +2527,7 @@ def get_proposals( This function is integral for analyzing the governance activity on the Bittensor network, providing a holistic view of the proposals and their impact or potential changes within the network. """ - proposal_hashes: Optional[List[str]] = self.get_proposal_hashes(block=block) + proposal_hashes: Optional[list[str]] = self.get_proposal_hashes(block=block) if proposal_hashes is None: return None return { @@ -2578,7 +2578,7 @@ def _do_root_register( wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, - ) -> Tuple[bool, Optional[str]]: + ) -> tuple[bool, Optional[str]]: @retry(delay=1, tries=3, backoff=2, max_delay=4, logger=_logger) def make_substrate_call_with_retry(): # create extrinsic call @@ -2991,7 +2991,7 @@ def state_call( method: str, data: str, block: Optional[int] = None, - ) -> Dict[Any, Any]: + ) -> dict[Any, Any]: """ Makes a state call to the Bittensor blockchain, allowing for direct queries of the blockchain's state. This function is typically used for advanced queries that require specific method calls and data inputs. @@ -3009,7 +3009,7 @@ def state_call( """ @retry(delay=1, tries=3, backoff=2, max_delay=4, logger=_logger) - def make_substrate_call_with_retry() -> Dict[Any, Any]: + def make_substrate_call_with_retry() -> dict[Any, Any]: block_hash = None if block is None else self.substrate.get_block_hash(block) return self.substrate.rpc_request( @@ -3023,7 +3023,7 @@ def query_runtime_api( self, runtime_api: str, method: str, - params: Optional[Union[List[int], Dict[str, int]]], + params: Optional[Union[list[int], dict[str, int]]], block: Optional[int] = None, ) -> Optional[str]: """ @@ -3076,8 +3076,8 @@ def query_runtime_api( def _encode_params( self, - call_definition: List["ParamWithTypes"], - params: Union[List[Any], Dict[str, Any]], + call_definition: list["ParamWithTypes"], + params: Union[list[Any], dict[str, Any]], ) -> str: """Returns a hex encoded string of the params using their types.""" param_data = scalecodec.ScaleBytes(b"") @@ -3683,7 +3683,7 @@ def get_stake_for_coldkey_and_hotkey( def get_stake( self, hotkey_ss58: str, block: Optional[int] = None - ) -> List[Tuple[str, "Balance"]]: + ) -> list[tuple[str, "Balance"]]: """ Returns a list of stake tuples (coldkey, balance) for each delegating coldkey including the owner. @@ -3924,7 +3924,7 @@ def subnet_exists(self, netuid: int, block: Optional[int] = None) -> bool: _result = self.query_subtensor("NetworksAdded", block, [netuid]) return getattr(_result, "value", False) - def get_all_subnet_netuids(self, block: Optional[int] = None) -> List[int]: + def get_all_subnet_netuids(self, block: Optional[int] = None) -> list[int]: """ Retrieves the list of all subnet unique identifiers (netuids) currently present in the Bittensor network. @@ -4008,7 +4008,7 @@ def get_emission_value_by_subnet( def get_subnet_connection_requirements( self, netuid: int, block: Optional[int] = None - ) -> Dict[str, int]: + ) -> dict[str, int]: """ Retrieves the connection requirements for a specific subnet within the Bittensor network. This function provides details on the criteria that must be met for neurons to connect to the subnet. @@ -4030,7 +4030,7 @@ def get_subnet_connection_requirements( else {} ) - def get_subnets(self, block: Optional[int] = None) -> List[int]: + def get_subnets(self, block: Optional[int] = None) -> list[int]: """ Retrieves a list of all subnets currently active within the Bittensor network. This function provides an overview of the various subnets and their identifiers. @@ -4051,7 +4051,7 @@ def get_subnets(self, block: Optional[int] = None) -> List[int]: else [] ) - def get_all_subnets_info(self, block: Optional[int] = None) -> List[SubnetInfo]: + def get_all_subnets_info(self, block: Optional[int] = None) -> list[SubnetInfo]: """ Retrieves detailed information about all subnets within the Bittensor network. This function provides comprehensive data on each subnet, including its characteristics and operational parameters. @@ -4118,7 +4118,7 @@ def make_substrate_call_with_retry(): def get_subnet_hyperparameters( self, netuid: int, block: Optional[int] = None - ) -> Optional[Union[List, SubnetHyperparameters]]: + ) -> Optional[Union[list, 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. @@ -4218,7 +4218,7 @@ def get_delegate_take( def get_nominators_for_hotkey( self, hotkey_ss58: str, block: Optional[int] = None - ) -> Union[List[Tuple[str, Balance]], int]: + ) -> Union[list[tuple[str, Balance]], int]: """ Retrieves a list of nominators and their stakes for a neuron identified by its hotkey. Nominators are neurons that stake their tokens on a delegate to support its operations. @@ -4259,7 +4259,7 @@ def get_delegate_by_hotkey( """ @retry(delay=1, tries=3, backoff=2, max_delay=4, logger=_logger) - def make_substrate_call_with_retry(encoded_hotkey_: List[int]): + def make_substrate_call_with_retry(encoded_hotkey_: list[int]): block_hash = None if block is None else self.substrate.get_block_hash(block) return self.substrate.rpc_request( @@ -4277,7 +4277,7 @@ def make_substrate_call_with_retry(encoded_hotkey_: List[int]): return DelegateInfo.from_vec_u8(result) - def get_delegates_lite(self, block: Optional[int] = None) -> List[DelegateInfoLite]: + def get_delegates_lite(self, block: Optional[int] = None) -> list[DelegateInfoLite]: """ Retrieves a lighter list of all delegate neurons within the Bittensor network. This function provides an overview of the neurons that are actively involved in the network's delegation system. @@ -4311,7 +4311,7 @@ def make_substrate_call_with_retry(): return [DelegateInfoLite(**d) for d in result] - def get_delegates(self, block: Optional[int] = None) -> List[DelegateInfo]: + def get_delegates(self, block: Optional[int] = None) -> list[DelegateInfo]: """ Retrieves a list of all delegate neurons within the Bittensor network. This function provides an overview of the neurons that are actively involved in the network's delegation system. @@ -4347,7 +4347,7 @@ def make_substrate_call_with_retry(): def get_delegated( self, coldkey_ss58: str, block: Optional[int] = None - ) -> List[Tuple[DelegateInfo, Balance]]: + ) -> list[tuple[DelegateInfo, Balance]]: """ Retrieves a list of delegates and their associated stakes for a given coldkey. This function identifies the delegates that a specific account has staked tokens on. @@ -4365,7 +4365,7 @@ def get_delegated( """ @retry(delay=1, tries=3, backoff=2, max_delay=4, logger=_logger) - def make_substrate_call_with_retry(encoded_coldkey_: List[int]): + def make_substrate_call_with_retry(encoded_coldkey_: list[int]): block_hash = None if block is None else self.substrate.get_block_hash(block) return self.substrate.rpc_request( @@ -4389,7 +4389,7 @@ def make_substrate_call_with_retry(encoded_coldkey_: List[int]): def get_stake_info_for_coldkey( self, coldkey_ss58: str, block: Optional[int] = None - ) -> Optional[List[StakeInfo]]: + ) -> Optional[list[StakeInfo]]: """ Retrieves stake information associated with a specific coldkey. This function provides details about the stakes held by an account, including the staked amounts and associated delegates. @@ -4424,8 +4424,8 @@ def get_stake_info_for_coldkey( return StakeInfo.list_from_vec_u8(bytes_result) # type: ignore def get_stake_info_for_coldkeys( - self, coldkey_ss58_list: List[str], block: Optional[int] = None - ) -> Optional[Dict[str, List[StakeInfo]]]: + self, coldkey_ss58_list: list[str], block: Optional[int] = None + ) -> Optional[dict[str, list[StakeInfo]]]: """ Retrieves stake information for a list of coldkeys. This function aggregates stake data for multiple accounts, providing a collective view of their stakes and delegations. @@ -4579,7 +4579,7 @@ def get_uid_for_hotkey_on_subnet( def get_all_uids_for_hotkey( self, hotkey_ss58: str, block: Optional[int] = None - ) -> List[int]: + ) -> list[int]: """ Retrieves all unique identifiers (UIDs) associated with a given hotkey across different subnets within the Bittensor network. This function helps in identifying all the neuron instances that are @@ -4602,7 +4602,7 @@ def get_all_uids_for_hotkey( def get_netuids_for_hotkey( self, hotkey_ss58: str, block: Optional[int] = None - ) -> List[int]: + ) -> list[int]: """ Retrieves a list of subnet UIDs (netuids) for which a given hotkey is a member. This function identifies the specific subnets within the Bittensor network where the neuron associated with @@ -4649,7 +4649,7 @@ def get_neuron_for_pubkey_and_subnet( def get_all_neurons_for_pubkey( self, hotkey_ss58: str, block: Optional[int] = None - ) -> List[NeuronInfo]: + ) -> list[NeuronInfo]: """ Retrieves information about all neuron instances associated with a given public key (hotkey ``SS58`` address) across different subnets of the Bittensor network. This function aggregates neuron data @@ -4754,7 +4754,7 @@ def make_substrate_call_with_retry(): return NeuronInfo.from_vec_u8(result) - def neurons(self, netuid: int, block: Optional[int] = None) -> List[NeuronInfo]: + def neurons(self, netuid: int, block: Optional[int] = None) -> list[NeuronInfo]: """ Retrieves a list of all neurons within a specified subnet of the Bittensor network. This function provides a snapshot of the subnet's neuron population, including each neuron's attributes and network @@ -4829,7 +4829,7 @@ def neuron_for_uid_lite( def neurons_lite( self, netuid: int, block: Optional[int] = None - ) -> List[NeuronInfoLite]: + ) -> list[NeuronInfoLite]: """ Retrieves a list of neurons in a 'lite' format from a specific subnet of the Bittensor network. This function provides a streamlined view of the neurons, focusing on key attributes such as stake @@ -4891,7 +4891,7 @@ def metagraph( return metagraph_ - def incentive(self, netuid: int, block: Optional[int] = None) -> List[int]: + def incentive(self, netuid: int, block: Optional[int] = None) -> list[int]: """ Retrieves the list of incentives for neurons within a specific subnet of the Bittensor network. This function provides insights into the reward distribution mechanisms and the incentives allocated @@ -4919,7 +4919,7 @@ def incentive(self, netuid: int, block: Optional[int] = None) -> List[int]: def weights( self, netuid: int, block: Optional[int] = None - ) -> List[Tuple[int, List[Tuple[int, int]]]]: + ) -> list[tuple[int, list[tuple[int, int]]]]: """ Retrieves the weight distribution set by neurons within a specific subnet of the Bittensor network. This function maps each neuron's UID to the weights it assigns to other neurons, reflecting the @@ -4947,7 +4947,7 @@ def weights( def bonds( self, netuid: int, block: Optional[int] = None - ) -> List[Tuple[int, List[Tuple[int, int]]]]: + ) -> list[tuple[int, list[tuple[int, int]]]]: """ Retrieves the bond distribution set by neurons within a specific subnet of the Bittensor network. Bonds represent the investments or commitments made by neurons in one another, indicating a level @@ -4978,7 +4978,7 @@ def bonds( def associated_validator_ip_info( self, netuid: int, block: Optional[int] = None - ) -> Optional[List["IPInfo"]]: + ) -> Optional[list["IPInfo"]]: """ Retrieves the list of all validator IP addresses associated with a specific subnet in the Bittensor network. This information is crucial for network communication and the identification of validator nodes. @@ -5361,7 +5361,7 @@ def make_substrate_call_with_retry(): return make_substrate_call_with_retry() - def get_balances(self, block: Optional[int] = None) -> Dict[str, Balance]: + def get_balances(self, block: Optional[int] = None) -> dict[str, Balance]: """ Retrieves the token balances of all accounts within the Bittensor network as of a specific blockchain block. This function provides a comprehensive view of the token distribution among different accounts. @@ -5438,7 +5438,7 @@ def get_block_hash(self, block_id: int) -> str: """ return self.substrate.get_block_hash(block_id=block_id) - def get_error_info_by_index(self, error_index: int) -> Tuple[str, str]: + def get_error_info_by_index(self, error_index: int) -> tuple[str, str]: """ Returns the error name and description from the Subtensor error list. diff --git a/bittensor/synapse.py b/bittensor/synapse.py index 516b43f2a8..8d0f3c42e0 100644 --- a/bittensor/synapse.py +++ b/bittensor/synapse.py @@ -21,7 +21,7 @@ import json import sys import warnings -from typing import Any, ClassVar, Dict, Optional, Tuple +from typing import Any, ClassVar, Optional from pydantic import ( BaseModel, @@ -482,7 +482,7 @@ def set_name_type(cls, values) -> dict: repr=False, ) - required_hash_fields: ClassVar[Tuple[str, ...]] = () + required_hash_fields: ClassVar[tuple[str, ...]] = () _extract_total_size = field_validator("total_size", mode="before")(cast_int) @@ -757,7 +757,7 @@ def parse_headers_to_inputs(cls, headers: dict) -> dict: """ # Initialize the input dictionary with empty sub-dictionaries for 'axon' and 'dendrite' - inputs_dict: Dict[str, Dict[str, str]] = {"axon": {}, "dendrite": {}} + inputs_dict: dict[str, dict[str, str]] = {"axon": {}, "dendrite": {}} # Iterate over each item in the headers for key, value in headers.items(): diff --git a/bittensor/tensor.py b/bittensor/tensor.py index 03f34f191a..02f1b68fb4 100644 --- a/bittensor/tensor.py +++ b/bittensor/tensor.py @@ -17,7 +17,7 @@ # DEALINGS IN THE SOFTWARE. import base64 -from typing import List, Optional, Union +from typing import Optional, Union import msgpack import msgpack_numpy @@ -107,7 +107,7 @@ def cast_dtype(raw: Union[None, np.dtype, "torch.dtype", str]) -> Optional[str]: ) -def cast_shape(raw: Union[None, List[int], str]) -> Optional[Union[str, list]]: +def cast_shape(raw: Union[None, list[int], str]) -> Optional[Union[str, list]]: """ Casts the raw value to a string representing the tensor shape. @@ -158,7 +158,7 @@ class Tensor(BaseModel): def tensor(self) -> Union[np.ndarray, "torch.Tensor"]: return self.deserialize() - def tolist(self) -> List[object]: + def tolist(self) -> list[object]: return self.deserialize().tolist() def numpy(self) -> "numpy.ndarray": @@ -237,7 +237,7 @@ def serialize(tensor_: Union["np.ndarray", "torch.Tensor"]) -> "Tensor": ) # Represents the shape of the tensor. - shape: List[int] = Field( + shape: list[int] = Field( title="shape", description="Tensor shape. This field defines the dimensions of the tensor as a list of integers, such as [10, 10] for a 2D tensor with shape (10, 10).", examples=[10, 10], diff --git a/bittensor/threadpool.py b/bittensor/threadpool.py index 857f732dd7..633f35bbe3 100644 --- a/bittensor/threadpool.py +++ b/bittensor/threadpool.py @@ -167,16 +167,16 @@ def __init__( @classmethod def add_args(cls, parser: argparse.ArgumentParser, prefix: str = None): """Accept specific arguments from parser""" - prefix_str = "" if prefix == None else prefix + "." + prefix_str = "" if prefix is None else prefix + "." try: default_max_workers = ( os.getenv("BT_PRIORITY_MAX_WORKERS") - if os.getenv("BT_PRIORITY_MAX_WORKERS") != None + if os.getenv("BT_PRIORITY_MAX_WORKERS") is not None else 5 ) default_maxsize = ( os.getenv("BT_PRIORITY_MAXSIZE") - if os.getenv("BT_PRIORITY_MAXSIZE") != None + if os.getenv("BT_PRIORITY_MAXSIZE") is not None else 10 ) parser.add_argument( diff --git a/bittensor/utils/__init__.py b/bittensor/utils/__init__.py index 7a96320c4a..62359aa0e9 100644 --- a/bittensor/utils/__init__.py +++ b/bittensor/utils/__init__.py @@ -32,9 +32,9 @@ U64_MAX = 18446744073709551615 -def ss58_to_vec_u8(ss58_address: str) -> List[int]: +def ss58_to_vec_u8(ss58_address: str) -> list[int]: ss58_bytes: bytes = bittensor.utils.ss58_address_to_bytes(ss58_address) - encoded_address: List[int] = [int(byte) for byte in ss58_bytes] + encoded_address: list[int] = [int(byte) for byte in ss58_bytes] return encoded_address @@ -46,7 +46,7 @@ def _unbiased_topk( largest=True, axis=0, return_type: str = "numpy", -) -> Union[Tuple[np.ndarray, np.ndarray], Tuple["torch.Tensor", "torch.LongTensor"]]: +) -> Union[tuple[np.ndarray, np.ndarray], tuple["torch.Tensor", "torch.LongTensor"]]: """Selects topk as in torch.topk but does not bias lower indices when values are equal. Args: values: (np.ndarray) if using numpy, (torch.Tensor) if using torch: @@ -100,7 +100,7 @@ def unbiased_topk( sorted: bool = True, largest: bool = True, axis: int = 0, -) -> Union[Tuple[np.ndarray, np.ndarray], Tuple["torch.Tensor", "torch.LongTensor"]]: +) -> Union[tuple[np.ndarray, np.ndarray], tuple["torch.Tensor", "torch.LongTensor"]]: """Selects topk as in torch.topk but does not bias lower indices when values are equal. Args: values: (np.ndarray) if using numpy, (torch.Tensor) if using torch: @@ -162,12 +162,12 @@ def strtobool(val: str) -> Union[bool, Literal["==SUPRESS=="]]: elif val in ("n", "no", "f", "false", "off", "0"): return False else: - raise ValueError("invalid truth value %r" % (val,)) + raise ValueError(f"invalid truth value {val!r}") def get_explorer_root_url_by_network_from_map( - network: str, network_map: Dict[str, Dict[str, str]] -) -> Optional[Dict[str, str]]: + network: str, network_map: dict[str, dict[str, str]] +) -> Optional[dict[str, str]]: r""" Returns the explorer root url for the given network name from the given network map. @@ -179,7 +179,7 @@ def get_explorer_root_url_by_network_from_map( The explorer url for the given network. Or None if the network is not in the network map. """ - explorer_urls: Optional[Dict[str, str]] = {} + explorer_urls: Optional[dict[str, str]] = {} for entity_nm, entity_network_map in network_map.items(): if network in entity_network_map: explorer_urls[entity_nm] = entity_network_map[network] @@ -188,8 +188,8 @@ def get_explorer_root_url_by_network_from_map( def get_explorer_url_for_network( - network: str, block_hash: str, network_map: Dict[str, str] -) -> Optional[List[str]]: + network: str, block_hash: str, network_map: dict[str, str] +) -> Optional[list[str]]: r""" Returns the explorer url for the given block hash and network. @@ -203,9 +203,9 @@ def get_explorer_url_for_network( Or None if the network is not known. """ - explorer_urls: Optional[Dict[str, str]] = {} + explorer_urls: Optional[dict[str, str]] = {} # Will be None if the network is not known. i.e. not in network_map - explorer_root_urls: Optional[Dict[str, str]] = ( + explorer_root_urls: Optional[dict[str, str]] = ( get_explorer_root_url_by_network_from_map(network, network_map) ) @@ -239,7 +239,7 @@ def U64_NORMALIZED_FLOAT(x: int) -> float: return float(x) / float(U64_MAX) -def u8_key_to_ss58(u8_key: List[int]) -> str: +def u8_key_to_ss58(u8_key: list[int]) -> str: r""" Converts a u8-encoded account key to an ss58 address. diff --git a/bittensor/utils/_register_cuda.py b/bittensor/utils/_register_cuda.py index fe563a34a9..74147ca5e4 100644 --- a/bittensor/utils/_register_cuda.py +++ b/bittensor/utils/_register_cuda.py @@ -3,7 +3,6 @@ import io import math from contextlib import redirect_stdout -from typing import Tuple import numpy as np from Crypto.Hash import keccak @@ -17,7 +16,7 @@ def solve_cuda( difficulty: int, limit: int, dev_id: int = 0, -) -> Tuple[np.int64, bytes]: +) -> tuple[np.int64, bytes]: """ Solves the PoW problem using CUDA. Args: diff --git a/bittensor/utils/registration.py b/bittensor/utils/registration.py index 543a868388..668e3d4174 100644 --- a/bittensor/utils/registration.py +++ b/bittensor/utils/registration.py @@ -10,7 +10,7 @@ from dataclasses import dataclass from datetime import timedelta from queue import Empty, Full -from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from typing import Any, Callable, Optional, Union import backoff import numpy @@ -231,7 +231,7 @@ def run(self): @staticmethod def create_shared_memory() -> ( - Tuple[multiprocessing.Array, multiprocessing.Value, multiprocessing.Array] + tuple[multiprocessing.Array, multiprocessing.Value, multiprocessing.Array] ): """Creates shared memory for the solver processes to use.""" curr_block = multiprocessing.Array("h", 32, lock=True) # byte array @@ -561,7 +561,7 @@ def _solve_for_difficulty_fast( while still updating the block information after a different number of nonces, to increase the transparency of the process while still keeping the speed. """ - if num_processes == None: + if num_processes is None: # get the number of allowed processes for this process num_processes = min(1, get_cpu_count()) @@ -684,7 +684,7 @@ def _solve_for_difficulty_fast( num_time = 0 for finished_queue in finished_queues: try: - proc_num = finished_queue.get(timeout=0.1) + finished_queue.get(timeout=0.1) num_time += 1 except Empty: @@ -735,7 +735,7 @@ def _solve_for_difficulty_fast( @backoff.on_exception(backoff.constant, Exception, interval=1, max_tries=3) def _get_block_with_retry( subtensor: "bittensor.subtensor", netuid: int -) -> Tuple[int, int, bytes]: +) -> tuple[int, int, bytes]: """ Gets the current block number, difficulty, and block hash from the substrate node. @@ -779,7 +779,7 @@ def __init__(self, force: bool = False): def __enter__(self): self._old_start_method = multiprocessing.get_start_method(allow_none=True) - if self._old_start_method == None: + if self._old_start_method is None: self._old_start_method = "spawn" # default to spawn multiprocessing.set_start_method("spawn", force=self._force) @@ -799,7 +799,7 @@ def _check_for_newest_block_and_update( curr_block_num: multiprocessing.Value, update_curr_block: Callable, check_block: "multiprocessing.Lock", - solvers: List[_Solver], + solvers: list[_Solver], curr_stats: RegistrationStatistics, ) -> int: """ @@ -871,7 +871,7 @@ def _solve_for_difficulty_fast_cuda( output_in_place: bool = True, update_interval: int = 50_000, tpb: int = 512, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, n_samples: int = 10, alpha_: float = 0.80, log_verbose: bool = False, @@ -1032,7 +1032,7 @@ def _solve_for_difficulty_fast_cuda( # Get times for each solver for finished_queue in finished_queues: try: - proc_num = finished_queue.get(timeout=0.1) + finished_queue.get(timeout=0.1) num_time += 1 except Empty: @@ -1082,7 +1082,7 @@ def _solve_for_difficulty_fast_cuda( def _terminate_workers_and_wait_for_exit( - workers: List[multiprocessing.Process], + workers: list[multiprocessing.Process], ) -> None: for worker in workers: worker.terminate() @@ -1095,12 +1095,12 @@ def create_pow( netuid: int, output_in_place: bool = True, cuda: bool = False, - dev_id: Union[List[int], int] = 0, + dev_id: Union[list[int], int] = 0, tpb: int = 256, num_processes: int = None, update_interval: int = None, log_verbose: bool = False, -) -> Optional[Dict[str, Any]]: +) -> Optional[dict[str, Any]]: """ Creates a proof of work for the given subtensor and wallet. Args: diff --git a/bittensor/utils/subtensor.py b/bittensor/utils/subtensor.py index d9c92e16eb..44bef0e005 100644 --- a/bittensor/utils/subtensor.py +++ b/bittensor/utils/subtensor.py @@ -22,7 +22,7 @@ import json import logging import os -from typing import Any, Dict, Optional, Union +from typing import Any, Optional, Union from substrateinterface.base import SubstrateInterface @@ -41,7 +41,7 @@ # https://github.com/polkascan/py-scale-codec/blob/master/scalecodec/type_registry/core.json#L1024 # A class object is created dynamically at runtime. # Circleci linter complains about string represented classes like 'PalletMetadataV14'. -def _get_errors_from_pallet(pallet) -> Optional[Dict[str, Dict[str, str]]]: +def _get_errors_from_pallet(pallet) -> Optional[dict[str, dict[str, str]]]: """Extracts and returns error information from the given pallet metadata. Args: @@ -68,7 +68,7 @@ def _get_errors_from_pallet(pallet) -> Optional[Dict[str, Dict[str, str]]]: } -def _save_errors_to_cache(uniq_version: str, errors: Dict[str, Dict[str, str]]): +def _save_errors_to_cache(uniq_version: str, errors: dict[str, dict[str, str]]): """Saves error details and unique version identifier to a JSON file. Args: @@ -83,7 +83,7 @@ def _save_errors_to_cache(uniq_version: str, errors: Dict[str, Dict[str, str]]): _logger.warning(f"Error saving to file: {e}") -def _get_errors_from_cache() -> Optional[Dict[str, Dict[str, Dict[str, str]]]]: +def _get_errors_from_cache() -> Optional[dict[str, dict[str, dict[str, str]]]]: """Retrieves and returns the cached error information from a JSON file, if it exists. Returns: @@ -104,7 +104,7 @@ def _get_errors_from_cache() -> Optional[Dict[str, Dict[str, Dict[str, str]]]]: def get_subtensor_errors( substrate: SubstrateInterface, -) -> Union[Dict[str, Dict[str, str]], Dict[Any, Any]]: +) -> Union[dict[str, dict[str, str]], dict[Any, Any]]: """Fetches or retrieves cached Subtensor error definitions using metadata. Args: diff --git a/bittensor/utils/test_utils.py b/bittensor/utils/test_utils.py index fdaa1bda95..6113554c0b 100644 --- a/bittensor/utils/test_utils.py +++ b/bittensor/utils/test_utils.py @@ -1,11 +1,10 @@ import socket from random import randint -from typing import Set max_tries = 10 -def get_random_unused_port(allocated_ports: Set = set()): +def get_random_unused_port(allocated_ports: set = set()): def port_in_use(port: int) -> bool: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: return s.connect_ex(("localhost", port)) == 0 diff --git a/bittensor/utils/weight_utils.py b/bittensor/utils/weight_utils.py index 141e7e3726..c1f0f47b71 100644 --- a/bittensor/utils/weight_utils.py +++ b/bittensor/utils/weight_utils.py @@ -20,7 +20,7 @@ # DEALINGS IN THE SOFTWARE. import hashlib -from typing import List, Tuple, Union +from typing import Union import numpy as np from numpy.typing import NDArray @@ -85,7 +85,7 @@ def normalize_max_weight( def convert_weight_uids_and_vals_to_tensor( - n: int, uids: List[int], weights: List[int] + n: int, uids: list[int], weights: list[int] ) -> Union[NDArray[np.float32], "torch.FloatTensor"]: r"""Converts weights and uids from chain representation into a np.array (inverse operation from convert_weights_and_uids_for_emit) Args: @@ -115,7 +115,7 @@ def convert_weight_uids_and_vals_to_tensor( def convert_root_weight_uids_and_vals_to_tensor( - n: int, uids: List[int], weights: List[int], subnets: List[int] + n: int, uids: list[int], weights: list[int], subnets: list[int] ) -> Union[NDArray[np.float32], "torch.FloatTensor"]: r"""Converts root weights and uids from chain representation into a np.array or torch FloatTensor (inverse operation from convert_weights_and_uids_for_emit) Args: @@ -152,7 +152,7 @@ def convert_root_weight_uids_and_vals_to_tensor( def convert_bond_uids_and_vals_to_tensor( - n: int, uids: List[int], bonds: List[int] + n: int, uids: list[int], bonds: list[int] ) -> Union[NDArray[np.int64], "torch.LongTensor"]: r"""Converts bond and uids from chain representation into a np.array. Args: @@ -179,7 +179,7 @@ def convert_bond_uids_and_vals_to_tensor( def convert_weights_and_uids_for_emit( uids: Union[NDArray[np.int64], "torch.LongTensor"], weights: Union[NDArray[np.float32], "torch.FloatTensor"], -) -> Tuple[List[int], List[int]]: +) -> tuple[list[int], list[int]]: r"""Converts weights into integer u32 representation that sum to MAX_INT_WEIGHT. Args: uids (:obj:`np.int64,`): @@ -236,8 +236,8 @@ def process_weights_for_netuid( metagraph: "bittensor.metagraph" = None, exclude_quantile: int = 0, ) -> Union[ - Tuple["torch.Tensor", "torch.FloatTensor"], - Tuple[NDArray[np.int64], NDArray[np.float32]], + tuple["torch.Tensor", "torch.FloatTensor"], + tuple[NDArray[np.int64], NDArray[np.float32]], ]: bittensor.logging.debug("process_weights_for_netuid()") bittensor.logging.debug("weights", weights) @@ -350,10 +350,10 @@ def process_weights_for_netuid( def generate_weight_hash( address: str, netuid: int, - uids: List[int], - values: List[int], + uids: list[int], + values: list[int], version_key: int, - salt: List[int], + salt: list[int], ) -> str: """ Generate a valid commit hash from the provided weights. diff --git a/bittensor/wallet.py b/bittensor/wallet.py index 5fe196b489..f46b3633cc 100644 --- a/bittensor/wallet.py +++ b/bittensor/wallet.py @@ -20,7 +20,7 @@ import argparse import copy import os -from typing import Dict, Optional, Tuple, Union, overload +from typing import Optional, Union, overload from substrateinterface import Keypair from termcolor import colored @@ -140,7 +140,7 @@ def add_args(cls, parser: argparse.ArgumentParser, prefix: str = None): parser (argparse.ArgumentParser): Argument parser object. prefix (str): Argument prefix. """ - prefix_str = "" if prefix == None else prefix + "." + prefix_str = "" if prefix is None else prefix + "." try: default_name = os.getenv("BT_WALLET_NAME") or "default" default_hotkey = os.getenv("BT_WALLET_NAME") or "default" @@ -433,7 +433,7 @@ def hotkey(self) -> "bittensor.Keypair": KeyFileError: Raised if the file is corrupt of non-existent. CryptoKeyError: Raised if the user enters an incorrec password for an encrypted keyfile. """ - if self._hotkey == None: + if self._hotkey is None: self._hotkey = self.hotkey_file.keypair return self._hotkey @@ -447,7 +447,7 @@ def coldkey(self) -> "bittensor.Keypair": KeyFileError: Raised if the file is corrupt of non-existent. CryptoKeyError: Raised if the user enters an incorrec password for an encrypted keyfile. """ - if self._coldkey == None: + if self._coldkey is None: self._coldkey = self.coldkey_file.keypair return self._coldkey @@ -461,7 +461,7 @@ def coldkeypub(self) -> "bittensor.Keypair": KeyFileError: Raised if the file is corrupt of non-existent. CryptoKeyError: Raised if the user enters an incorrect password for an encrypted keyfile. """ - if self._coldkeypub == None: + if self._coldkeypub is None: self._coldkeypub = self.coldkeypub_file.keypair return self._coldkeypub @@ -691,7 +691,7 @@ def regenerate_coldkey( @overload def regenerate_coldkey( self, - json: Optional[Tuple[Union[str, Dict], str]] = None, + json: Optional[tuple[Union[str, dict], str]] = None, use_password: bool = True, overwrite: bool = False, suppress: bool = False, @@ -798,7 +798,7 @@ def regenerate_hotkey( @overload def regenerate_hotkey( self, - json: Optional[Tuple[Union[str, Dict], str]] = None, + json: Optional[tuple[Union[str, dict], str]] = None, use_password: bool = True, overwrite: bool = False, suppress: bool = False, diff --git a/setup.py b/setup.py index f6fca7f7e8..283a25a712 100644 --- a/setup.py +++ b/setup.py @@ -19,7 +19,6 @@ import os import pathlib import re -from io import open from os import path from setuptools import find_packages, setup @@ -27,7 +26,6 @@ def read_requirements(path): requirements = [] - git_requirements = [] with pathlib.Path(path).open() as requirements_txt: for line in requirements_txt: diff --git a/tests/e2e_tests/utils.py b/tests/e2e_tests/utils.py index 757324444b..cba33c5db2 100644 --- a/tests/e2e_tests/utils.py +++ b/tests/e2e_tests/utils.py @@ -1,4 +1,3 @@ -from typing import List from substrateinterface import Keypair @@ -13,7 +12,7 @@ def setup_wallet(uri: str): wallet.set_coldkeypub(keypair=keypair, encrypt=False, overwrite=True) wallet.set_hotkey(keypair=keypair, encrypt=False, overwrite=True) - def exec_command(command, extra_args: List[str]): + def exec_command(command, extra_args: list[str]): parser = bittensor.cli.__create_parser__() args = extra_args + [ "--no_prompt", diff --git a/tests/integration_tests/test_cli.py b/tests/integration_tests/test_cli.py index d458dfff60..07a083ecaf 100644 --- a/tests/integration_tests/test_cli.py +++ b/tests/integration_tests/test_cli.py @@ -23,7 +23,6 @@ import unittest from copy import deepcopy from types import SimpleNamespace -from typing import Dict from unittest.mock import MagicMock, patch import pytest @@ -455,7 +454,7 @@ def test_unstake_with_specific_hotkeys(self, _): config.all_hotkeys = False # Notice no max_stake specified - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { # All have more than 5.0 stake "hk0": Balance.from_float(10.0), "hk1": Balance.from_float(11.1), @@ -531,7 +530,7 @@ def test_unstake_with_all_hotkeys(self, _): config.all_hotkeys = True # Notice no max_stake specified - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { # All have more than 5.0 stake "hk0": Balance.from_float(10.0), "hk1": Balance.from_float(11.1), @@ -610,7 +609,7 @@ def test_unstake_with_exclude_hotkeys_from_all(self, _): config.hotkeys = ["hk1"] # Exclude hk1 config.all_hotkeys = True - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { # All have more than 5.0 stake "hk0": Balance.from_float(10.0), "hk1": Balance.from_float(11.1), @@ -696,7 +695,7 @@ def test_unstake_with_multiple_hotkeys_max_stake(self, _): config.hotkeys = ["hk0", "hk1", "hk2"] config.all_hotkeys = False - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { # All have more than 5.0 stake "hk0": Balance.from_float(10.0), "hk1": Balance.from_float(4.9), @@ -785,7 +784,7 @@ def test_unstake_with_thresholds(self, _): config.all_hotkeys = False # Notice no max_stake specified - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { "hk0": Balance.from_float(10.0), "hk1": Balance.from_float(11.1), "hk2": Balance.from_float(12.2), @@ -856,7 +855,7 @@ def test_unstake_all(self, _): config.hotkeys = ["hk0"] config.all_hotkeys = False - mock_stakes: Dict[str, Balance] = {"hk0": Balance.from_float(10.0)} + mock_stakes: dict[str, Balance] = {"hk0": Balance.from_float(10.0)} mock_coldkey_kp = _get_mock_keypair(0, self.id()) @@ -1198,7 +1197,7 @@ def test_stake_with_multiple_hotkeys_max_stake(self, _): mock_balance = Balance.from_float(config.max_stake * 3) - mock_stakes: Dict[str, Balance] = { + mock_stakes: dict[str, Balance] = { "hk0": Balance.from_float(0.0), "hk1": Balance.from_float(config.max_stake * 2), "hk2": Balance.from_float(0.0), @@ -1581,7 +1580,7 @@ def test_stake_with_single_hotkey_max_stake_enough_stake(self, _): mock_balance = Balance.from_float(config.max_stake * 3) - mock_stakes: Dict[str, Balance] = { # has enough stake, more than max_stake + mock_stakes: dict[str, Balance] = { # has enough stake, more than max_stake "hk0": Balance.from_float(config.max_stake * 2) } @@ -1729,7 +1728,7 @@ def test_delegate_stake(self, _): config.amount = 5.0 config.wallet.name = "w1" - mock_balances: Dict[str, Balance] = { + mock_balances: dict[str, Balance] = { # All have more than 5.0 stake "w0": { "hk0": Balance.from_float(10.0), @@ -1814,7 +1813,7 @@ def test_undelegate_stake(self, _): config.amount = 5.0 config.wallet.name = "w1" - mock_balances: Dict[str, Balance] = { + mock_balances: dict[str, Balance] = { # All have more than 5.0 stake "w0": { "hk0": Balance.from_float(10.0), @@ -1918,7 +1917,7 @@ def test_transfer(self, _): config.amount = 3.2 config.wallet.name = "w1" - mock_balances: Dict[str, Balance] = { + mock_balances: dict[str, Balance] = { "w0": Balance.from_float(10.0), "w1": Balance.from_float(config.amount + 0.001), } @@ -1986,7 +1985,7 @@ def test_transfer_not_enough_balance(self, _): config.amount = 3.2 config.wallet.name = "w1" - mock_balances: Dict[str, Balance] = { + mock_balances: dict[str, Balance] = { "w0": Balance.from_float(10.0), "w1": Balance.from_float(config.amount - 0.1), # not enough balance } diff --git a/tests/integration_tests/test_cli_no_network.py b/tests/integration_tests/test_cli_no_network.py index 7e7aca817a..f86c15c109 100644 --- a/tests/integration_tests/test_cli_no_network.py +++ b/tests/integration_tests/test_cli_no_network.py @@ -300,7 +300,7 @@ def test_list_no_wallet(self, _, __): cli.run() def test_btcli_help(self, _, __): - with pytest.raises(SystemExit) as pytest_wrapped_e: + with pytest.raises(SystemExit): with patch( "argparse.ArgumentParser._print_message", return_value=None ) as mock_print_message: diff --git a/tests/integration_tests/test_subtensor_integration.py b/tests/integration_tests/test_subtensor_integration.py index 6a95502d6e..df6f5de12a 100644 --- a/tests/integration_tests/test_subtensor_integration.py +++ b/tests/integration_tests/test_subtensor_integration.py @@ -368,7 +368,7 @@ def test_commit_weights(self): weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit( uids=uids, weights=weights ) - commit_hash = bittensor.utils.weight_utils.generate_weight_hash( + bittensor.utils.weight_utils.generate_weight_hash( address=self.wallet.hotkey.ss58_address, netuid=3, uids=weight_uids, @@ -397,7 +397,7 @@ def test_commit_weights_inclusion(self): uids=uids, weights=weights ) - commit_hash = bittensor.utils.weight_utils.generate_weight_hash( + bittensor.utils.weight_utils.generate_weight_hash( address=self.wallet.hotkey.ss58_address, netuid=1, uids=weight_uids, @@ -431,7 +431,7 @@ def test_commit_weights_failed(self): uids=uids, weights=weights ) - commit_hash = bittensor.utils.weight_utils.generate_weight_hash( + bittensor.utils.weight_utils.generate_weight_hash( address=self.wallet.hotkey.ss58_address, netuid=3, uids=weight_uids, @@ -681,11 +681,11 @@ def test_registration_multiprocessed_already_registered(self): # patch solution queue to return None with patch( "multiprocessing.queues.Queue.get", return_value=None - ) as mock_queue_get: + ): # patch time queue get to raise Empty exception with patch( "multiprocessing.queues.Queue.get_nowait", side_effect=QueueEmpty - ) as mock_queue_get_nowait: + ): wallet = _get_mock_wallet( hotkey=_get_mock_keypair(0, self.id()), coldkey=_get_mock_keypair(1, self.id()), diff --git a/tests/unit_tests/extrinsics/test_registration.py b/tests/unit_tests/extrinsics/test_registration.py index 3eabbb47bc..dca55ac3db 100644 --- a/tests/unit_tests/extrinsics/test_registration.py +++ b/tests/unit_tests/extrinsics/test_registration.py @@ -79,7 +79,7 @@ def test_run_faucet_extrinsic_happy_path( with patch( "bittensor.utils.registration._solve_for_difficulty_fast", return_value=mock_pow_solution, - ) as mock_create_pow, patch("rich.prompt.Confirm.ask", return_value=True): + ), patch("rich.prompt.Confirm.ask", return_value=True): from bittensor.extrinsics.registration import run_faucet_extrinsic # Arrange diff --git a/tests/unit_tests/extrinsics/test_senate.py b/tests/unit_tests/extrinsics/test_senate.py index 699190be27..9964ee8731 100644 --- a/tests/unit_tests/extrinsics/test_senate.py +++ b/tests/unit_tests/extrinsics/test_senate.py @@ -68,7 +68,7 @@ def test_register_senate_extrinsic( process_events=MagicMock(), error_message="error", ), - ) as mock_submit_extrinsic, patch.object( + ), patch.object( mock_wallet, "is_senate_member", return_value=is_registered ): # Act diff --git a/tests/unit_tests/test_dendrite.py b/tests/unit_tests/test_dendrite.py index e97ae3f975..cc74c09d92 100644 --- a/tests/unit_tests/test_dendrite.py +++ b/tests/unit_tests/test_dendrite.py @@ -101,14 +101,14 @@ async def test_aclose(dendrite_obj, setup_axon): axon = setup_axon # Use context manager to open an async session async with dendrite_obj: - resp = await dendrite_obj([axon], SynapseDummy(input=1), deserialize=False) + await dendrite_obj([axon], SynapseDummy(input=1), deserialize=False) # Close should automatically be called on the session after context manager scope assert dendrite_obj._session is None class AsyncMock(Mock): def __call__(self, *args, **kwargs): - sup = super(AsyncMock, self) + sup = super() async def coro(): return sup.__call__(*args, **kwargs) diff --git a/tests/unit_tests/test_keyfile.py b/tests/unit_tests/test_keyfile.py index fb62d3f4b9..7d030e42e9 100644 --- a/tests/unit_tests/test_keyfile.py +++ b/tests/unit_tests/test_keyfile.py @@ -547,7 +547,7 @@ def test_overwriting(keyfile_setup_teardown): ) bob = bittensor.Keypair.create_from_uri("/Bob") - with pytest.raises(bittensor.KeyFileError) as pytest_wrapped_e: + with pytest.raises(bittensor.KeyFileError): with mock.patch("builtins.input", return_value="n"): keyfile.set_keypair( bob, encrypt=True, overwrite=False, password="thisisafakepassword" diff --git a/tests/unit_tests/test_logging.py b/tests/unit_tests/test_logging.py index aaebea4113..d4d036fb2f 100644 --- a/tests/unit_tests/test_logging.py +++ b/tests/unit_tests/test_logging.py @@ -132,7 +132,7 @@ def test_enable_file_logging_with_new_config(tmp_path): """ log_dir = tmp_path / "logs" log_dir.mkdir() # Create the temporary directory - log_file_path = log_dir / DEFAULT_LOG_FILE_NAME + log_dir / DEFAULT_LOG_FILE_NAME # check no file handler is created config = LoggingConfig(debug=False, trace=False, record_log=True, logging_dir=None) diff --git a/tests/unit_tests/test_overview.py b/tests/unit_tests/test_overview.py index 638ab4df4c..04a498f827 100644 --- a/tests/unit_tests/test_overview.py +++ b/tests/unit_tests/test_overview.py @@ -94,7 +94,7 @@ def test_get_total_balance( with patch( "bittensor.wallet", return_value=mock_wallet - ) as mock_wallet_constructor, patch( + ), patch( "bittensor.commands.overview.get_coldkey_wallets_for_path", return_value=[mock_wallet] if config_all else [], ), patch( diff --git a/tests/unit_tests/test_subtensor.py b/tests/unit_tests/test_subtensor.py index 0517c743ac..77e44f1ee5 100644 --- a/tests/unit_tests/test_subtensor.py +++ b/tests/unit_tests/test_subtensor.py @@ -41,7 +41,7 @@ def test_serve_axon_with_external_ip_set(): mock_subtensor = MagicMock(spec=bittensor.subtensor, serve_axon=mock_serve_axon) - mock_add_insecure_port = mock.MagicMock(return_value=None) + mock.MagicMock(return_value=None) mock_wallet = MagicMock( spec=bittensor.wallet, coldkey=MagicMock(), @@ -1836,7 +1836,7 @@ def test_get_all_subnets_info_success(mocker, subtensor): ) # Call - result = subtensor.get_all_subnets_info(block) + subtensor.get_all_subnets_info(block) # Asserts subtensor.substrate.get_block_hash.assert_called_once_with(block) @@ -1915,7 +1915,7 @@ def test_get_subnet_info_success(mocker, subtensor): ) # Call - result = subtensor.get_subnet_info(netuid, block) + subtensor.get_subnet_info(netuid, block) # Asserts subtensor.substrate.get_block_hash.assert_called_once_with(block) @@ -1970,7 +1970,7 @@ def test_get_subnet_info_retry(mocker, subtensor): ) # Call - result = subtensor.get_subnet_info(netuid, block) + subtensor.get_subnet_info(netuid, block) # Asserts subtensor.substrate.get_block_hash.assert_called_with(block) @@ -1994,7 +1994,7 @@ def test_get_subnet_hyperparameters_success(mocker, subtensor): ) # Call - result = subtensor.get_subnet_hyperparameters(netuid, block) + subtensor.get_subnet_hyperparameters(netuid, block) # Asserts subtensor.query_runtime_api.assert_called_once_with( @@ -2041,7 +2041,7 @@ def test_get_subnet_hyperparameters_hex_without_prefix(mocker, subtensor): mocker.patch.object(subtensor_module.SubnetHyperparameters, "from_vec_u8") # Call - result = subtensor.get_subnet_hyperparameters(netuid, block) + subtensor.get_subnet_hyperparameters(netuid, block) # Asserts subtensor.query_runtime_api.assert_called_once_with( @@ -2170,7 +2170,6 @@ def test_get_delegate_take_no_data(mocker, subtensor): # Prep hotkey_ss58 = "hotkey_ss58" block = 123 - delegate_take_value = 32768 mocker.patch.object(subtensor, "query_subtensor", return_value=None) spy_u16_normalized_float = mocker.spy(subtensor_module, "U16_NORMALIZED_FLOAT") diff --git a/tests/unit_tests/utils/test_utils.py b/tests/unit_tests/utils/test_utils.py index 1d3945cd2b..87e8648da4 100644 --- a/tests/unit_tests/utils/test_utils.py +++ b/tests/unit_tests/utils/test_utils.py @@ -30,18 +30,18 @@ def test_convert_weight_and_uids(): # min weight < 0 weights[5] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # min uid < 0 weights[5] = 0 uids[3] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # len(uids) != len(weights) uids[3] = 3 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights[1:]) # sum(weights) == 0 diff --git a/tests/unit_tests/utils/test_weight_utils.py b/tests/unit_tests/utils/test_weight_utils.py index 913b2e9cfa..483d7d20eb 100644 --- a/tests/unit_tests/utils/test_weight_utils.py +++ b/tests/unit_tests/utils/test_weight_utils.py @@ -31,18 +31,18 @@ def test_convert_weight_and_uids(): # min weight < 0 weights[5] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # min uid < 0 weights[5] = 0 uids[3] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # len(uids) != len(weights) uids[3] = 3 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights[1:]) # sum(weights) == 0 @@ -63,16 +63,16 @@ def test_convert_weight_and_uids_torch(force_legacy_torch_compat_api): # min weight < 0 weights[5] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # min uid < 0 weights[5] = 0 uids[3] = -1 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights) # len(uids) != len(weights) uids[3] = 3 - with pytest.raises(ValueError) as pytest_wrapped_e: + with pytest.raises(ValueError): weight_utils.convert_weights_and_uids_for_emit(uids, weights[1:]) # sum(weights) == 0 From 3317b0fc5a09e0091e7f7121ad7f43aa8238bab0 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:53:44 +0200 Subject: [PATCH 05/15] relatively straight forward fixes of `ruff check` errors --- bittensor/chain_data.py | 2 +- bittensor/commands/inspect.py | 7 ++----- bittensor/utils/__init__.py | 17 ++++++++++++----- ruff.toml | 2 ++ 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/bittensor/chain_data.py b/bittensor/chain_data.py index 7d8e837a78..f5260c2133 100644 --- a/bittensor/chain_data.py +++ b/bittensor/chain_data.py @@ -554,7 +554,7 @@ class NeuronInfoLite: last_update: int validator_permit: bool prometheus_info: Optional["PrometheusInfo"] - axon_info: "axon_info" + axon_info: "AxonInfo" pruning_score: int is_null: bool = False diff --git a/bittensor/commands/inspect.py b/bittensor/commands/inspect.py index f295e0941b..0519c485f2 100644 --- a/bittensor/commands/inspect.py +++ b/bittensor/commands/inspect.py @@ -16,6 +16,8 @@ # DEALINGS IN THE SOFTWARE. import argparse +import os +from typing import Optional from rich.prompt import Prompt from rich.table import Table @@ -34,11 +36,6 @@ console = bittensor.__console__ -import os -from typing import Optional - -import bittensor - def _get_coldkey_wallets_for_path(path: str) -> list["bittensor.wallet"]: try: diff --git a/bittensor/utils/__init__.py b/bittensor/utils/__init__.py index 62359aa0e9..3f8c1b4183 100644 --- a/bittensor/utils/__init__.py +++ b/bittensor/utils/__init__.py @@ -1,9 +1,7 @@ # The MIT License (MIT) # Copyright © 2022 Opentensor Foundation # Copyright © 2023 Opentensor Technologies Inc -import hashlib -import os - +# # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated # documentation files (the “Software”), to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, @@ -15,7 +13,9 @@ # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. -from typing import Callable, Dict, List, Literal, Tuple + +import hashlib +from typing import Callable, Literal, Optional, Union import numpy as np import requests @@ -25,7 +25,14 @@ from .registration import torch, use_torch from .version import VersionCheckError, check_version, version_checking -from .wallet_utils import * # noqa F401 +from .wallet_utils import ( + create_identity_dict, + decode_hex_identity_dict, + get_ss58_format, + is_valid_bittensor_address_or_public_key, + is_valid_ed25519_pubkey, + is_valid_ss58_address, +) RAOPERTAO = 1e9 U16_MAX = 65535 diff --git a/ruff.toml b/ruff.toml index fd240d1de4..ca338ad5c7 100644 --- a/ruff.toml +++ b/ruff.toml @@ -18,3 +18,5 @@ ignore = [ [lint.per-file-ignores] "__init__.py" = ["F401"] "test/**" = ["D", "F403", "F405"] +"bittensor/__init__.py" = ["E402"] # FIXME to be changed and tested afterwards +"bittensor/commands/__init__.py" = ["E402"] # FIXME to be changed and tested afterwards From 129d89acea5c9d061906bd88a48990e03805bcde Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:55:42 +0200 Subject: [PATCH 06/15] exempt currently existing E722 (broad exception catch) --- bittensor/axon.py | 2 +- bittensor/commands/list.py | 6 +++--- bittensor/commands/utils.py | 2 +- bittensor/commands/wallets.py | 2 +- bittensor/config.py | 8 ++++---- bittensor/dendrite.py | 4 ++-- bittensor/keyfile.py | 2 +- 7 files changed, 13 insertions(+), 13 deletions(-) diff --git a/bittensor/axon.py b/bittensor/axon.py index 9a124c8640..a424c155b6 100644 --- a/bittensor/axon.py +++ b/bittensor/axon.py @@ -1144,7 +1144,7 @@ async def preprocess(self, request: Request) -> bittensor.Synapse: # Extracts the request name from the URL path. try: request_name = request.url.path.split("/")[1] - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. raise InvalidRequestNameError( f"Improperly formatted request. Could not parser request {request.url.path}." ) diff --git a/bittensor/commands/list.py b/bittensor/commands/list.py index 9cd6211238..aa3633d4a8 100644 --- a/bittensor/commands/list.py +++ b/bittensor/commands/list.py @@ -70,7 +70,7 @@ def run(cli): coldkeypub_str = wallet_for_name.coldkeypub.ss58_address else: coldkeypub_str = "?" - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. coldkeypub_str = "?" wallet_tree = root.add( @@ -92,10 +92,10 @@ def run(cli): hotkey_str = hotkey_for_name.hotkey.ss58_address else: hotkey_str = "?" - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. hotkey_str = "?" wallet_tree.add(f"[bold grey]{h_name} ({hotkey_str})") - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. continue if len(wallets) == 0: diff --git a/bittensor/commands/utils.py b/bittensor/commands/utils.py index d7a2c07385..e0a7f8cce5 100644 --- a/bittensor/commands/utils.py +++ b/bittensor/commands/utils.py @@ -75,7 +75,7 @@ def check_netuid_set( netuid = netuid[0] try: config.netuid = int(netuid) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. raise ValueError('netuid must be an integer or "None" (if applicable)') diff --git a/bittensor/commands/wallets.py b/bittensor/commands/wallets.py index 912a5d4005..960a980871 100644 --- a/bittensor/commands/wallets.py +++ b/bittensor/commands/wallets.py @@ -1083,7 +1083,7 @@ def create_transfer_history_table(transfers): for item in transfers: try: tao_amount = int(item["amount"]) / RAOPERTAO - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. tao_amount = item["amount"] table.add_row( item["id"], diff --git a/bittensor/config.py b/bittensor/config.py index 1e212a6778..6094dd5806 100644 --- a/bittensor/config.py +++ b/bittensor/config.py @@ -82,7 +82,7 @@ def __init__( type=str, help="If set, defaults are overridden by passed file.", ) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. # this can fail if --config has already been added. pass @@ -93,7 +93,7 @@ def __init__( help="""If flagged, config will check that only exact arguments have been set.""", default=False, ) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. # this can fail if --strict has already been added. pass @@ -104,7 +104,7 @@ def __init__( help="Set ``true`` to stop cli version checking.", default=False, ) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. # this can fail if --no_version_checking has already been added. pass @@ -116,7 +116,7 @@ def __init__( help="Set ``true`` to stop cli from prompting the user.", default=False, ) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. # this can fail if --no_version_checking has already been added. pass diff --git a/bittensor/dendrite.py b/bittensor/dendrite.py index ac7528b4ee..598a855517 100644 --- a/bittensor/dendrite.py +++ b/bittensor/dendrite.py @@ -314,7 +314,7 @@ def query( try: loop = asyncio.get_event_loop() result = loop.run_until_complete(self.forward(*args, **kwargs)) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. new_loop = asyncio.new_event_loop() asyncio.set_event_loop(new_loop) result = loop.run_until_complete(self.forward(*args, **kwargs)) @@ -701,7 +701,7 @@ def process_server_response( # Set the attribute in the local synapse from the corresponding # attribute in the server synapse setattr(local_synapse, key, getattr(server_synapse, key)) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. # Ignore errors during attribute setting pass else: diff --git a/bittensor/keyfile.py b/bittensor/keyfile.py index cf5dd8c08a..81252ca579 100644 --- a/bittensor/keyfile.py +++ b/bittensor/keyfile.py @@ -84,7 +84,7 @@ def deserialize_keypair_from_keyfile_data(keyfile_data: bytes) -> "bittensor.Key keyfile_data = keyfile_data.decode() try: keyfile_dict = dict(json.loads(keyfile_data)) - except: + except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. string_value = str(keyfile_data) if string_value[:2] == "0x": string_value = ss58_encode(string_value) From 330cb5cd3f4cbb0329442d07aba2098eaf3d7b5a Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 08:58:26 +0200 Subject: [PATCH 07/15] safe import sorting --- bittensor/extrinsics/network.py | 5 ++--- bittensor/extrinsics/serving.py | 6 ++---- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/bittensor/extrinsics/network.py b/bittensor/extrinsics/network.py index b98b8b29a2..e5ef6c3ba5 100644 --- a/bittensor/extrinsics/network.py +++ b/bittensor/extrinsics/network.py @@ -21,6 +21,8 @@ import bittensor +from ..commands.network import HYPERPARAMS + def register_subnetwork_extrinsic( subtensor: "bittensor.subtensor", @@ -113,9 +115,6 @@ def find_event_attributes_in_extrinsic_receipt(response, event_name) -> list: return [-1] -from ..commands.network import HYPERPARAMS - - def set_hyperparameter_extrinsic( subtensor: "bittensor.subtensor", wallet: "bittensor.wallet", diff --git a/bittensor/extrinsics/serving.py b/bittensor/extrinsics/serving.py index 806803c023..0db0bde088 100644 --- a/bittensor/extrinsics/serving.py +++ b/bittensor/extrinsics/serving.py @@ -16,7 +16,9 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. import json +from typing import Optional +from retry import retry from rich.prompt import Confirm import bittensor @@ -259,10 +261,6 @@ def publish_metadata( raise MetadataError(response.error_message) -from typing import Optional - -from retry import retry - def get_metadata(self, netuid: int, hotkey: str, block: Optional[int] = None) -> str: @retry(delay=2, tries=3, backoff=2, max_delay=4) From f71ee3f677fdd75b8f231b25a82d638bb35c2479 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:06:38 +0200 Subject: [PATCH 08/15] fix redefinitions and E721,E723 errors --- bittensor/metagraph.py | 2 +- bittensor/subtensor.py | 2 +- bittensor/utils/balance.py | 6 ------ .../test_subtensor_integration.py | 15 ++++----------- tests/unit_tests/test_axon.py | 2 +- tests/unit_tests/utils/test_weight_utils.py | 2 +- 6 files changed, 8 insertions(+), 21 deletions(-) diff --git a/bittensor/metagraph.py b/bittensor/metagraph.py index f560db5aa2..9b626da446 100644 --- a/bittensor/metagraph.py +++ b/bittensor/metagraph.py @@ -200,7 +200,7 @@ def R(self) -> Union[NDArray, "torch.nn.Parameter"]: return self.ranks @property - def I(self) -> Union[NDArray, "torch.nn.Parameter"]: + def I(self) -> Union[NDArray, "torch.nn.Parameter"]: # noqa: E743 """ Incentive values of neurons represent the rewards they receive for their contributions to the network. The Bittensor network employs an incentive mechanism that rewards neurons based on their diff --git a/bittensor/subtensor.py b/bittensor/subtensor.py index a863f8a68a..9e58437c81 100644 --- a/bittensor/subtensor.py +++ b/bittensor/subtensor.py @@ -3084,7 +3084,7 @@ def _encode_params( for i, param in enumerate(call_definition["params"]): # type: ignore scale_obj = self.substrate.create_scale_object(param["type"]) - if type(params) is list: + if type(params) is list: # noqa: E721 param_data += scale_obj.encode(params[i]) else: if param["name"] not in params: diff --git a/bittensor/utils/balance.py b/bittensor/utils/balance.py index 63ca6cd5ba..2917aa179c 100644 --- a/bittensor/utils/balance.py +++ b/bittensor/utils/balance.py @@ -226,12 +226,6 @@ def __rfloordiv__(self, other: Union[int, float, "Balance"]): except (ValueError, TypeError): raise NotImplementedError("Unsupported type") - def __int__(self) -> int: - return self.rao - - def __float__(self) -> float: - return self.tao - def __nonzero__(self) -> bool: return bool(self.rao) diff --git a/tests/integration_tests/test_subtensor_integration.py b/tests/integration_tests/test_subtensor_integration.py index df6f5de12a..73baa4c383 100644 --- a/tests/integration_tests/test_subtensor_integration.py +++ b/tests/integration_tests/test_subtensor_integration.py @@ -113,7 +113,7 @@ def test_network_overrides(self): def test_get_current_block(self): block = self.subtensor.get_current_block() - assert type(block) == int + assert type(block) == int # noqa: E721 def test_unstake(self): self.subtensor._do_unstake = MagicMock(return_value=True) @@ -313,13 +313,6 @@ def test_transfer_dest_as_bytes(self): def test_set_weights(self): chain_weights = [0] - class success: - def __init__(self): - self.is_success = True - - def process_events(self): - return True - self.subtensor.set_weights = MagicMock(return_value=True) self.subtensor._do_set_weights = MagicMock(return_value=(True, None)) @@ -608,13 +601,13 @@ def test_commit_and_reveal_weights_inclusion(self): def test_get_balance(self): fake_coldkey = _get_mock_coldkey(0) balance = self.subtensor.get_balance(address=fake_coldkey) - assert type(balance) == bittensor.utils.balance.Balance + assert type(balance) == bittensor.utils.balance.Balance # noqa: E721 def test_get_balances(self): balances = self.subtensor.get_balances() - assert type(balances) == dict + assert type(balances) == dict # noqa: E721 for i in balances: - assert type(balances[i]) == bittensor.utils.balance.Balance + assert type(balances[i]) == bittensor.utils.balance.Balance # noqa: E721 def test_get_uid_by_hotkey_on_subnet(self): mock_coldkey_kp = _get_mock_keypair(0, self.id()) diff --git a/tests/unit_tests/test_axon.py b/tests/unit_tests/test_axon.py index 29755de941..e96bc03036 100644 --- a/tests/unit_tests/test_axon.py +++ b/tests/unit_tests/test_axon.py @@ -82,7 +82,7 @@ def wrong_verify_fn(synapse: Synapse) -> bool: server.attach(forward_fn, blacklist_fn, priority_fn, wrong_verify_fn) -def test_attach(): +def test_attach__inheritance(): # Create a mock AxonServer instance server = bittensor.axon() diff --git a/tests/unit_tests/utils/test_weight_utils.py b/tests/unit_tests/utils/test_weight_utils.py index 483d7d20eb..74a1ea0021 100644 --- a/tests/unit_tests/utils/test_weight_utils.py +++ b/tests/unit_tests/utils/test_weight_utils.py @@ -336,7 +336,7 @@ def test_convert_root_weight_uids_and_vals_to_tensor_happy_paths( ), # All zero weights ], ) -def test_convert_root_weight_uids_and_vals_to_tensor_edge_cases( +def test_convert_root_weight_uids_and_vals_to_tensor_edge_cases__torch( test_id, n, uids, weights, subnets, expected, force_legacy_torch_compat_api ): # Act From e0460b97c27ace55f72c014d0b987960596160e5 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:22:00 +0200 Subject: [PATCH 09/15] fix problems related to bittensor.synapse=bittensor.synapse.Synapse style of exports --- bittensor/__init__.py | 120 ++++++++++++++++++++++-------------------- ruff.toml | 2 +- 2 files changed, 64 insertions(+), 58 deletions(-) diff --git a/bittensor/__init__.py b/bittensor/__init__.py index a4b3d8dd6e..05eeeebea2 100644 --- a/bittensor/__init__.py +++ b/bittensor/__init__.py @@ -206,30 +206,6 @@ def debug(on: bool = True): }, } -from substrateinterface import Keypair # noqa: F401 - -# Allows avoiding name spacing conflicts and continue access to the `subtensor` module with `subtensor_module` name -from . import subtensor as subtensor_module -from .axon import axon as axon -from .btlogging import logging -from .chain_data import ( - AxonInfo, - DelegateInfo, - DelegateInfoLite, - IPInfo, - NeuronInfo, - NeuronInfoLite, - PrometheusInfo, - ProposalCallData, - ProposalVoteData, - StakeInfo, - SubnetHyperparameters, - SubnetInfo, -) -from .cli import COMMANDS as ALL_COMMANDS -from .cli import cli as cli -from .config import DefaultConfig, InvalidConfigFile, T, config -from .dendrite import dendrite as dendrite from .errors import ( BlacklistedException, ChainConnectionError, @@ -256,54 +232,84 @@ def debug(on: bool = True): UnknownSynapseError, UnstakeError, ) + +from substrateinterface import Keypair # noqa: F401 +from .config import InvalidConfigFile, DefaultConfig, config, T from .keyfile import ( - Mockkeyfile, - ask_password_to_encrypt, - decrypt_keyfile_data, + serialized_keypair_to_keyfile_data, deserialize_keypair_from_keyfile_data, - encrypt_keyfile_data, - get_coldkey_password_from_environment, - keyfile, - keyfile_data_encryption_method, - keyfile_data_is_encrypted, + validate_password, + ask_password_to_encrypt, + keyfile_data_is_encrypted_nacl, keyfile_data_is_encrypted_ansible, keyfile_data_is_encrypted_legacy, - keyfile_data_is_encrypted_nacl, + keyfile_data_is_encrypted, + keyfile_data_encryption_method, legacy_encrypt_keyfile_data, - serialized_keypair_to_keyfile_data, - validate_password, + encrypt_keyfile_data, + get_coldkey_password_from_environment, + decrypt_keyfile_data, + keyfile, + Mockkeyfile, ) -from .metagraph import metagraph as metagraph -from .mock.keyfile_mock import MockKeyfile as MockKeyfile -from .mock.subtensor_mock import MockSubtensor as MockSubtensor -from .mock.wallet_mock import MockWallet as MockWallet -from .stream import StreamingSynapse -from .subnets import SubnetsAPI as SubnetsAPI +from .wallet import display_mnemonic_msg, wallet -# Double import allows using class `Subtensor` by referencing `bittensor.Subtensor` and `bittensor.subtensor`. -# This will be available for a while until we remove reference `bittensor.subtensor` -from .subtensor import Subtensor -from .subtensor import Subtensor as subtensor -from .synapse import Synapse, TerminalInfo -from .tensor import Tensor, tensor -from .threadpool import PriorityThreadPoolExecutor as PriorityThreadPoolExecutor from .utils import ( - U16_NORMALIZED_FLOAT, - U64_NORMALIZED_FLOAT, - get_explorer_root_url_by_network_from_map, - get_explorer_url_for_network, - hash, - ss58_address_to_bytes, ss58_to_vec_u8, + unbiased_topk, + version_checking, strtobool, strtobool_with_default, + get_explorer_root_url_by_network_from_map, + get_explorer_url_for_network, + ss58_address_to_bytes, + U16_NORMALIZED_FLOAT, + U64_NORMALIZED_FLOAT, u8_key_to_ss58, - unbiased_topk, - version_checking, + hash, wallet_utils, ) + from .utils.balance import Balance as Balance -from .wallet import display_mnemonic_msg, wallet +from .chain_data import ( + AxonInfo, + NeuronInfo, + NeuronInfoLite, + PrometheusInfo, + DelegateInfo, + DelegateInfoLite, + StakeInfo, + SubnetInfo, + SubnetHyperparameters, + IPInfo, + ProposalCallData, + ProposalVoteData, +) + +# Allows avoiding name spacing conflicts and continue access to the `subtensor` module with `subtensor_module` name +from . import subtensor as subtensor_module + +# Double import allows using class `Subtensor` by referencing `bittensor.Subtensor` and `bittensor.subtensor`. +# This will be available for a while until we remove reference `bittensor.subtensor` +from .subtensor import Subtensor +from .subtensor import Subtensor as subtensor + +from .cli import cli as cli, COMMANDS as ALL_COMMANDS +from .btlogging import logging +from .metagraph import metagraph as metagraph +from .threadpool import PriorityThreadPoolExecutor as PriorityThreadPoolExecutor + +from .synapse import TerminalInfo, Synapse +from .stream import StreamingSynapse +from .tensor import tensor, Tensor +from .axon import axon as axon +from .dendrite import dendrite as dendrite + +from .mock.keyfile_mock import MockKeyfile as MockKeyfile +from .mock.subtensor_mock import MockSubtensor as MockSubtensor +from .mock.wallet_mock import MockWallet as MockWallet + +from .subnets import SubnetsAPI as SubnetsAPI configs = [ axon.config(), diff --git a/ruff.toml b/ruff.toml index ca338ad5c7..867322b2d8 100644 --- a/ruff.toml +++ b/ruff.toml @@ -18,5 +18,5 @@ ignore = [ [lint.per-file-ignores] "__init__.py" = ["F401"] "test/**" = ["D", "F403", "F405"] -"bittensor/__init__.py" = ["E402"] # FIXME to be changed and tested afterwards +"bittensor/__init__.py" = ["E402", "I001", ] # FIXME to be changed and tested afterwards "bittensor/commands/__init__.py" = ["E402"] # FIXME to be changed and tested afterwards From 4ae38e1066d7a9d139d821ee1a1810e1d8774be9 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:22:19 +0200 Subject: [PATCH 10/15] fix missing _get_mock_keypair export --- tests/helpers/helpers.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/helpers/helpers.py b/tests/helpers/helpers.py index 964f8cb186..440a5ab9a1 100644 --- a/tests/helpers/helpers.py +++ b/tests/helpers/helpers.py @@ -24,6 +24,9 @@ from bittensor.mock.wallet_mock import MockWallet as _MockWallet from bittensor.mock.wallet_mock import get_mock_coldkey as _get_mock_coldkey from bittensor.mock.wallet_mock import get_mock_hotkey as _get_mock_hotkey +from bittensor.mock.wallet_mock import ( + get_mock_keypair as _get_mock_keypair, # noqa: F401 +) from bittensor.mock.wallet_mock import get_mock_wallet as _get_mock_wallet From 1a93a40f7c14b95a051e7b567fee727d950949bf Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:39:18 +0200 Subject: [PATCH 11/15] apply `ruff format` --- bittensor/commands/delegates.py | 12 +-- bittensor/commands/list.py | 4 +- bittensor/commands/register.py | 3 +- bittensor/commands/root.py | 9 +- bittensor/commands/senate.py | 4 +- bittensor/dendrite.py | 18 ++-- bittensor/extrinsics/commit_weights.py | 1 - bittensor/extrinsics/delegation.py | 24 ++--- bittensor/extrinsics/prometheus.py | 3 +- bittensor/extrinsics/root.py | 4 +- bittensor/extrinsics/serving.py | 1 - bittensor/extrinsics/set_weights.py | 4 +- bittensor/extrinsics/staking.py | 4 +- bittensor/extrinsics/transfer.py | 4 +- bittensor/extrinsics/unstaking.py | 4 +- bittensor/keyfile.py | 40 ++------ bittensor/utils/weight_utils.py | 4 +- tests/e2e_tests/utils.py | 1 - tests/integration_tests/test_cli.py | 16 ++-- .../test_subtensor_integration.py | 4 +- .../unit_tests/extrinsics/test_delegation.py | 62 +++++++------ tests/unit_tests/extrinsics/test_network.py | 23 +++-- .../extrinsics/test_registration.py | 90 ++++++++++-------- tests/unit_tests/extrinsics/test_root.py | 30 +++--- tests/unit_tests/extrinsics/test_senate.py | 93 ++++++++++--------- tests/unit_tests/extrinsics/test_serving.py | 35 ++++--- .../unit_tests/extrinsics/test_set_weights.py | 20 ++-- tests/unit_tests/extrinsics/test_staking.py | 69 ++++++++------ tests/unit_tests/extrinsics/test_unstaking.py | 61 ++++++------ tests/unit_tests/test_overview.py | 25 ++--- tests/unit_tests/test_wallet.py | 22 +++-- 31 files changed, 354 insertions(+), 340 deletions(-) diff --git a/bittensor/commands/delegates.py b/bittensor/commands/delegates.py index 5c313ea291..4f9b29b9b5 100644 --- a/bittensor/commands/delegates.py +++ b/bittensor/commands/delegates.py @@ -288,7 +288,9 @@ def show_delegates( / float(prev_stake) ) if rate_change_in_stake > 0: - rate_change_in_stake_str = f"[green]{rate_change_in_stake:.2f}%[/green]" + rate_change_in_stake_str = ( + f"[green]{rate_change_in_stake:.2f}%[/green]" + ) elif rate_change_in_stake < 0: rate_change_in_stake_str = f"[red]{rate_change_in_stake:.2f}%[/red]" else: @@ -429,9 +431,7 @@ def check_config(config: "bittensor.config"): show_delegates(delegates, prev_delegates=prev_delegates) delegate_index = Prompt.ask("Enter delegate index") config.delegate_ss58key = str(delegates[int(delegate_index)].hotkey_ss58) - console.print( - f"Selected: [yellow]{config.delegate_ss58key}[/yellow]" - ) + console.print(f"Selected: [yellow]{config.delegate_ss58key}[/yellow]") if not config.is_set("wallet.name") and not config.no_prompt: wallet_name = Prompt.ask("Enter wallet name", default=defaults.wallet.name) @@ -570,9 +570,7 @@ def check_config(config: "bittensor.config"): show_delegates(delegates, prev_delegates=prev_delegates) delegate_index = Prompt.ask("Enter delegate index") config.delegate_ss58key = str(delegates[int(delegate_index)].hotkey_ss58) - console.print( - f"Selected: [yellow]{config.delegate_ss58key}[/yellow]" - ) + console.print(f"Selected: [yellow]{config.delegate_ss58key}[/yellow]") # Get amount. if not config.get("amount") and not config.get("unstake_all"): diff --git a/bittensor/commands/list.py b/bittensor/commands/list.py index aa3633d4a8..1699543027 100644 --- a/bittensor/commands/list.py +++ b/bittensor/commands/list.py @@ -73,9 +73,7 @@ def run(cli): except: # noqa: E722 # FIXME: This is a broad exception catch, should be narrowed down. coldkeypub_str = "?" - wallet_tree = root.add( - f"\n[bold white]{w_name} ({coldkeypub_str})" - ) + wallet_tree = root.add(f"\n[bold white]{w_name} ({coldkeypub_str})") hotkeys_path = os.path.join(cli.config.wallet.path, w_name, "hotkeys") try: hotkeys = next(os.walk(os.path.expanduser(hotkeys_path))) diff --git a/bittensor/commands/register.py b/bittensor/commands/register.py index 6502250fea..d55454dcc1 100644 --- a/bittensor/commands/register.py +++ b/bittensor/commands/register.py @@ -104,7 +104,8 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): Confirm.ask( f"Your balance is: [bold green]{balance}[/bold green]\nThe cost to register by recycle is [bold red]{current_recycle}[/bold red]\nDo you want to continue?", default=False, - ) is False + ) + is False ): sys.exit(1) diff --git a/bittensor/commands/root.py b/bittensor/commands/root.py index ba79f46475..9527325511 100644 --- a/bittensor/commands/root.py +++ b/bittensor/commands/root.py @@ -144,9 +144,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) senate_members = subtensor.get_senate_members() - root_neurons: list[bittensor.NeuronInfoLite] = subtensor.neurons_lite( - netuid=0 - ) + root_neurons: list[bittensor.NeuronInfoLite] = subtensor.neurons_lite(netuid=0) delegate_info: Optional[dict[str, DelegatesDetails]] = get_delegates_details( url=bittensor.__delegates_details_url__ ) @@ -501,10 +499,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ", ".join( map( str, - [ - f"{float(1 / len(subnets)):.2f}" - for subnet in subnets - ][:3], + [f"{float(1 / len(subnets)):.2f}" for subnet in subnets][:3], ) ) + " ..." diff --git a/bittensor/commands/senate.py b/bittensor/commands/senate.py index 19c0665bf7..fdfd884ea9 100644 --- a/bittensor/commands/senate.py +++ b/bittensor/commands/senate.py @@ -215,9 +215,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): ) table = Table(show_footer=False) - table.title = ( - f"[white]Proposals\t\tActive Proposals: {len(proposals)}\t\tSenate Size: {len(senate_members)}" - ) + table.title = f"[white]Proposals\t\tActive Proposals: {len(proposals)}\t\tSenate Size: {len(senate_members)}" table.add_column( "[overline white]HASH", footer_style="overline white", diff --git a/bittensor/dendrite.py b/bittensor/dendrite.py index 598a855517..0f439290d6 100644 --- a/bittensor/dendrite.py +++ b/bittensor/dendrite.py @@ -97,9 +97,7 @@ class DendriteMixin: >>> d( bittensor.axon(), bittensor.Synapse ) """ - def __init__( - self, wallet: bittensor.wallet | bittensor.Keypair | None = None - ): + def __init__(self, wallet: bittensor.wallet | bittensor.Keypair | None = None): """ Initializes the Dendrite object, setting up essential properties. @@ -325,7 +323,9 @@ def query( async def forward( self, - axons: list[bittensor.AxonInfo | bittensor.axon] | bittensor.AxonInfo | bittensor.axon, + axons: list[bittensor.AxonInfo | bittensor.axon] + | bittensor.AxonInfo + | bittensor.axon, synapse: bittensor.Synapse = bittensor.Synapse(), timeout: float = 12, deserialize: bool = True, @@ -418,7 +418,11 @@ async def query_all_axons( async def single_axon_response( target_axon, - ) -> AsyncGenerator[Any, Any] | bittensor.Synapse | bittensor.StreamingSynapse: + ) -> ( + AsyncGenerator[Any, Any] + | bittensor.Synapse + | bittensor.StreamingSynapse + ): """ Manages the request and response process for a single axon, supporting both streaming and non-streaming modes. @@ -815,9 +819,7 @@ def __del__(self): class dendrite(DendriteMixin, BaseModel): # type: ignore - def __init__( - self, wallet: bittensor.wallet | bittensor.Keypair | None = None - ): + def __init__(self, wallet: bittensor.wallet | bittensor.Keypair | None = None): if use_torch(): torch.nn.Module.__init__(self) DendriteMixin.__init__(self, wallet) diff --git a/bittensor/extrinsics/commit_weights.py b/bittensor/extrinsics/commit_weights.py index 62b9c3de43..b8f84e9c0c 100644 --- a/bittensor/extrinsics/commit_weights.py +++ b/bittensor/extrinsics/commit_weights.py @@ -18,7 +18,6 @@ """Module commit weights and reveal weights extrinsic.""" - from rich.prompt import Confirm import bittensor diff --git a/bittensor/extrinsics/delegation.py b/bittensor/extrinsics/delegation.py index 401c788ab2..c5f74cb970 100644 --- a/bittensor/extrinsics/delegation.py +++ b/bittensor/extrinsics/delegation.py @@ -55,9 +55,7 @@ def nominate_extrinsic( # Check if the hotkey is already a delegate. if subtensor.is_hotkey_delegate(wallet.hotkey.ss58_address): - logger.error( - f"Hotkey {wallet.hotkey.ss58_address} is already a delegate." - ) + logger.error(f"Hotkey {wallet.hotkey.ss58_address} is already a delegate.") return False with bittensor.__console__.status( @@ -83,16 +81,12 @@ def nominate_extrinsic( return success except Exception as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) except NominationError as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) @@ -386,9 +380,7 @@ def decrease_take_extrinsic( return success except (TakeError, Exception) as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) @@ -444,16 +436,12 @@ def increase_take_extrinsic( return success except Exception as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) except TakeError as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) diff --git a/bittensor/extrinsics/prometheus.py b/bittensor/extrinsics/prometheus.py index b10e607a11..00a0a79cef 100644 --- a/bittensor/extrinsics/prometheus.py +++ b/bittensor/extrinsics/prometheus.py @@ -99,8 +99,7 @@ def prometheus_extrinsic( ) bittensor.__console__.print( - ":white_heavy_check_mark: [white]Prometheus already served.[/white]".format( - ) + ":white_heavy_check_mark: [white]Prometheus already served.[/white]".format() ) return True diff --git a/bittensor/extrinsics/root.py b/bittensor/extrinsics/root.py index 044c877559..cfab7eccbd 100644 --- a/bittensor/extrinsics/root.py +++ b/bittensor/extrinsics/root.py @@ -210,9 +210,7 @@ def set_root_weights_extrinsic( except Exception as e: # TODO( devs ): lets remove all of the bittensor.__console__ calls and replace with the bittensor logger. - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) diff --git a/bittensor/extrinsics/serving.py b/bittensor/extrinsics/serving.py index 0db0bde088..c028c59463 100644 --- a/bittensor/extrinsics/serving.py +++ b/bittensor/extrinsics/serving.py @@ -261,7 +261,6 @@ def publish_metadata( raise MetadataError(response.error_message) - def get_metadata(self, netuid: int, hotkey: str, block: Optional[int] = None) -> str: @retry(delay=2, tries=3, backoff=2, max_delay=4) def make_substrate_call_with_retry(): diff --git a/bittensor/extrinsics/set_weights.py b/bittensor/extrinsics/set_weights.py index cd3644ab35..78dccded04 100644 --- a/bittensor/extrinsics/set_weights.py +++ b/bittensor/extrinsics/set_weights.py @@ -128,9 +128,7 @@ def set_weights_extrinsic( return False, error_message except Exception as e: - bittensor.__console__.print( - f":cross_mark: [red]Failed[/red]: error:{e}" - ) + bittensor.__console__.print(f":cross_mark: [red]Failed[/red]: error:{e}") bittensor.logging.warning( prefix="Set weights", suffix="Failed: " + str(e) ) diff --git a/bittensor/extrinsics/staking.py b/bittensor/extrinsics/staking.py index 1b4d5dd848..a72fc33ff0 100644 --- a/bittensor/extrinsics/staking.py +++ b/bittensor/extrinsics/staking.py @@ -375,9 +375,7 @@ def add_stake_multiple_extrinsic( ) continue except bittensor.errors.StakeError as e: - bittensor.__console__.print( - f":cross_mark: [red]Stake Error: {e}[/red]" - ) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") continue if successful_stakes != 0: diff --git a/bittensor/extrinsics/transfer.py b/bittensor/extrinsics/transfer.py index aa7e02afb0..63a8366c83 100644 --- a/bittensor/extrinsics/transfer.py +++ b/bittensor/extrinsics/transfer.py @@ -119,9 +119,7 @@ def transfer_extrinsic( bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) - bittensor.__console__.print( - f"[green]Block Hash: {block_hash}[/green]" - ) + bittensor.__console__.print(f"[green]Block Hash: {block_hash}[/green]") explorer_urls = bittensor.utils.get_explorer_url_for_network( subtensor.network, block_hash, bittensor.__network_explorer_map__ diff --git a/bittensor/extrinsics/unstaking.py b/bittensor/extrinsics/unstaking.py index e88978c333..da01097e80 100644 --- a/bittensor/extrinsics/unstaking.py +++ b/bittensor/extrinsics/unstaking.py @@ -387,9 +387,7 @@ def unstake_multiple_extrinsic( ) continue except bittensor.errors.StakeError as e: - bittensor.__console__.print( - f":cross_mark: [red]Stake Error: {e}[/red]" - ) + bittensor.__console__.print(f":cross_mark: [red]Stake Error: {e}[/red]") continue if successful_unstakes != 0: diff --git a/bittensor/keyfile.py b/bittensor/keyfile.py index 81252ca579..fba5204af4 100644 --- a/bittensor/keyfile.py +++ b/bittensor/keyfile.py @@ -344,9 +344,7 @@ def decrypt_keyfile_data( decrypted_keyfile_data = cipher_suite.decrypt(keyfile_data) # Unknown. else: - raise bittensor.KeyFileError( - f"keyfile data: {keyfile_data} is corrupt" - ) + raise bittensor.KeyFileError(f"keyfile data: {keyfile_data} is corrupt") except (InvalidSignature, InvalidKey, InvalidToken): raise bittensor.KeyFileError("Invalid password") @@ -620,17 +618,11 @@ def encrypt(self, password: str = None): KeyFileError: Raised if the file does not exist, is not readable, or writable. """ if not self.exists_on_device(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} does not exist" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} does not exist") if not self.is_readable(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not readable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not readable") if not self.is_writable(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not writable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not writable") keyfile_data = self._read_keyfile_data_from_file() if not keyfile_data_is_encrypted(keyfile_data): as_keypair = deserialize_keypair_from_keyfile_data(keyfile_data) @@ -647,17 +639,11 @@ def decrypt(self, password: str = None): KeyFileError: Raised if the file does not exist, is not readable, writable, corrupted, or if the password is incorrect. """ if not self.exists_on_device(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} does not exist" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} does not exist") if not self.is_readable(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not readable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not readable") if not self.is_writable(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not writable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not writable") keyfile_data = self._read_keyfile_data_from_file() if keyfile_data_is_encrypted(keyfile_data): keyfile_data = decrypt_keyfile_data( @@ -676,13 +662,9 @@ def _read_keyfile_data_from_file(self) -> bytes: KeyFileError: Raised if the file does not exist or is not readable. """ if not self.exists_on_device(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} does not exist" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} does not exist") if not self.is_readable(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not readable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not readable") with open(self.path, "rb") as file: data = file.read() return data @@ -699,9 +681,7 @@ def _write_keyfile_data_to_file(self, keyfile_data: bytes, overwrite: bool = Fal # Check overwrite. if self.exists_on_device() and not overwrite: if not self._may_overwrite(): - raise bittensor.KeyFileError( - f"Keyfile at: {self.path} is not writable" - ) + raise bittensor.KeyFileError(f"Keyfile at: {self.path} is not writable") with open(self.path, "wb") as keyfile: keyfile.write(keyfile_data) # Set file permissions. diff --git a/bittensor/utils/weight_utils.py b/bittensor/utils/weight_utils.py index c1f0f47b71..70495c3f45 100644 --- a/bittensor/utils/weight_utils.py +++ b/bittensor/utils/weight_utils.py @@ -196,9 +196,7 @@ def convert_weights_and_uids_for_emit( weights = weights.tolist() uids = uids.tolist() if min(weights) < 0: - raise ValueError( - f"Passed weight is negative cannot exist on chain {weights}" - ) + raise ValueError(f"Passed weight is negative cannot exist on chain {weights}") if min(uids) < 0: raise ValueError(f"Passed uid is negative cannot exist on chain {uids}") if len(uids) != len(weights): diff --git a/tests/e2e_tests/utils.py b/tests/e2e_tests/utils.py index cba33c5db2..ecab98e1ca 100644 --- a/tests/e2e_tests/utils.py +++ b/tests/e2e_tests/utils.py @@ -1,4 +1,3 @@ - from substrateinterface import Keypair import bittensor diff --git a/tests/integration_tests/test_cli.py b/tests/integration_tests/test_cli.py index 07a083ecaf..e424780c7b 100644 --- a/tests/integration_tests/test_cli.py +++ b/tests/integration_tests/test_cli.py @@ -250,9 +250,7 @@ def test_overview_not_in_first_subnet(self, _): print("Registering mock wallets to subnets...") for netuid, wallet in mock_registrations: - print( - f"Registering wallet {wallet.hotkey_str} to subnet {netuid}" - ) + print(f"Registering wallet {wallet.hotkey_str} to subnet {netuid}") _ = _subtensor_mock.force_register_neuron( netuid=netuid, coldkey=wallet.coldkey.ss58_address, @@ -2511,11 +2509,13 @@ def test_set_identity_command( mock_wallet.coldkey.ss58_address = "fake_coldkey_ss58_address" mock_wallet.coldkey = MagicMock() - with patch("bittensor.subtensor", return_value=mock_subtensor), patch( - "bittensor.wallet", return_value=mock_wallet - ), patch("bittensor.__console__", MagicMock()), patch( - "rich.prompt.Prompt.ask", side_effect=["y", "y"] - ), patch("sys.exit") as mock_exit: + with ( + patch("bittensor.subtensor", return_value=mock_subtensor), + patch("bittensor.wallet", return_value=mock_wallet), + patch("bittensor.__console__", MagicMock()), + patch("rich.prompt.Prompt.ask", side_effect=["y", "y"]), + patch("sys.exit") as mock_exit, + ): # Act if expected_exception: with pytest.raises(expected_exception) as exc_info: diff --git a/tests/integration_tests/test_subtensor_integration.py b/tests/integration_tests/test_subtensor_integration.py index 73baa4c383..5b8993ec0b 100644 --- a/tests/integration_tests/test_subtensor_integration.py +++ b/tests/integration_tests/test_subtensor_integration.py @@ -672,9 +672,7 @@ def test_registration_multiprocessed_already_registered(self): mock_neuron.is_null = True # patch solution queue to return None - with patch( - "multiprocessing.queues.Queue.get", return_value=None - ): + with patch("multiprocessing.queues.Queue.get", return_value=None): # patch time queue get to raise Empty exception with patch( "multiprocessing.queues.Queue.get_nowait", side_effect=QueueEmpty diff --git a/tests/unit_tests/extrinsics/test_delegation.py b/tests/unit_tests/extrinsics/test_delegation.py index 7213e321ac..56bff0bbfa 100644 --- a/tests/unit_tests/extrinsics/test_delegation.py +++ b/tests/unit_tests/extrinsics/test_delegation.py @@ -61,11 +61,14 @@ def test_nominate_extrinsic( expected_result, ): # Arrange - with patch.object( - mock_subtensor, "is_hotkey_delegate", return_value=already_delegate - ), patch.object( - mock_subtensor, "_do_nominate", return_value=nomination_success - ) as mock_nominate: + with ( + patch.object( + mock_subtensor, "is_hotkey_delegate", return_value=already_delegate + ), + patch.object( + mock_subtensor, "_do_nominate", return_value=nomination_success + ) as mock_nominate, + ): if raises_exception: mock_subtensor._do_nominate.side_effect = raises_exception @@ -242,17 +245,20 @@ def test_delegate_extrinsic( wallet_balance = Balance.from_tao(500) wallet_insufficient_balance = Balance.from_tao(0.002) - with patch("rich.prompt.Confirm.ask", return_value=prompt_response), patch.object( - mock_subtensor, - "get_balance", - return_value=wallet_balance - if balance_sufficient - else wallet_insufficient_balance, - ), patch.object( - mock_subtensor, "is_hotkey_delegate", return_value=is_delegate - ), patch.object( - mock_subtensor, "_do_delegation", return_value=transaction_success - ) as mock_delegate: + with ( + patch("rich.prompt.Confirm.ask", return_value=prompt_response), + patch.object( + mock_subtensor, + "get_balance", + return_value=wallet_balance + if balance_sufficient + else wallet_insufficient_balance, + ), + patch.object(mock_subtensor, "is_hotkey_delegate", return_value=is_delegate), + patch.object( + mock_subtensor, "_do_delegation", return_value=transaction_success + ) as mock_delegate, + ): if raises_error: mock_delegate.side_effect = raises_error @@ -404,17 +410,19 @@ def test_undelegate_extrinsic( # Arrange wallet_balance = Balance.from_tao(500) - with patch("rich.prompt.Confirm.ask", return_value=prompt_response), patch.object( - mock_subtensor, "is_hotkey_delegate", return_value=is_delegate - ), patch.object( - mock_subtensor, "get_balance", return_value=wallet_balance - ), patch.object( - mock_subtensor, - "get_stake_for_coldkey_and_hotkey", - return_value=Balance.from_tao(current_stake), - ), patch.object( - mock_subtensor, "_do_undelegation", return_value=transaction_success - ) as mock_undelegate: + with ( + patch("rich.prompt.Confirm.ask", return_value=prompt_response), + patch.object(mock_subtensor, "is_hotkey_delegate", return_value=is_delegate), + patch.object(mock_subtensor, "get_balance", return_value=wallet_balance), + patch.object( + mock_subtensor, + "get_stake_for_coldkey_and_hotkey", + return_value=Balance.from_tao(current_stake), + ), + patch.object( + mock_subtensor, "_do_undelegation", return_value=transaction_success + ) as mock_undelegate, + ): if raises_error: mock_undelegate.side_effect = raises_error diff --git a/tests/unit_tests/extrinsics/test_network.py b/tests/unit_tests/extrinsics/test_network.py index d7d6947ed3..db66edaa42 100644 --- a/tests/unit_tests/extrinsics/test_network.py +++ b/tests/unit_tests/extrinsics/test_network.py @@ -132,16 +132,19 @@ def test_set_hyperparameter_extrinsic( expected_result, ): # Arrange - with patch.object( - mock_subtensor, - "get_subnet_owner", - return_value=mock_wallet.coldkeypub.ss58_address - if is_owner - else mock_other_owner_wallet.coldkeypub.ss58_address, - ), patch.object( - mock_subtensor.substrate, - "submit_extrinsic", - return_value=MagicMock(is_success=extrinsic_success), + with ( + patch.object( + mock_subtensor, + "get_subnet_owner", + return_value=mock_wallet.coldkeypub.ss58_address + if is_owner + else mock_other_owner_wallet.coldkeypub.ss58_address, + ), + patch.object( + mock_subtensor.substrate, + "submit_extrinsic", + return_value=MagicMock(is_success=extrinsic_success), + ), ): # Act result = set_hyperparameter_extrinsic( diff --git a/tests/unit_tests/extrinsics/test_registration.py b/tests/unit_tests/extrinsics/test_registration.py index dca55ac3db..37db25a1e7 100644 --- a/tests/unit_tests/extrinsics/test_registration.py +++ b/tests/unit_tests/extrinsics/test_registration.py @@ -76,10 +76,13 @@ def test_run_faucet_extrinsic_happy_path( log_verbose, expected, ): - with patch( - "bittensor.utils.registration._solve_for_difficulty_fast", - return_value=mock_pow_solution, - ), patch("rich.prompt.Confirm.ask", return_value=True): + with ( + patch( + "bittensor.utils.registration._solve_for_difficulty_fast", + return_value=mock_pow_solution, + ), + patch("rich.prompt.Confirm.ask", return_value=True), + ): from bittensor.extrinsics.registration import run_faucet_extrinsic # Arrange @@ -133,8 +136,9 @@ def test_run_faucet_extrinsic_happy_path( def test_run_faucet_extrinsic_edge_cases( mock_subtensor, mock_wallet, cuda, torch_cuda_available, prompt_response, expected ): - with patch("torch.cuda.is_available", return_value=torch_cuda_available), patch( - "rich.prompt.Confirm.ask", return_value=prompt_response + with ( + patch("torch.cuda.is_available", return_value=torch_cuda_available), + patch("rich.prompt.Confirm.ask", return_value=prompt_response), ): from bittensor.extrinsics.registration import run_faucet_extrinsic @@ -259,19 +263,23 @@ def test_burned_register_extrinsic( test_id, ): # Arrange - with patch.object( - mock_subtensor, "subnet_exists", return_value=subnet_exists - ), patch.object( - mock_subtensor, - "get_neuron_for_pubkey_and_subnet", - return_value=MagicMock(is_null=neuron_is_null), - ), patch.object( - mock_subtensor, - "_do_burned_register", - return_value=(recycle_success, "Mock error message"), - ), patch.object( - mock_subtensor, "is_hotkey_registered", return_value=is_registered - ), patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm: + with ( + patch.object(mock_subtensor, "subnet_exists", return_value=subnet_exists), + patch.object( + mock_subtensor, + "get_neuron_for_pubkey_and_subnet", + return_value=MagicMock(is_null=neuron_is_null), + ), + patch.object( + mock_subtensor, + "_do_burned_register", + return_value=(recycle_success, "Mock error message"), + ), + patch.object( + mock_subtensor, "is_hotkey_registered", return_value=is_registered + ), + patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm, + ): # Act result = burned_register_extrinsic( subtensor=mock_subtensor, wallet=mock_wallet, netuid=123, prompt=True @@ -307,14 +315,15 @@ def test_register_extrinsic_without_pow( test_id, ): # Arrange - with patch.object( - mock_subtensor, "subnet_exists", return_value=subnet_exists - ), patch.object( - mock_subtensor, - "get_neuron_for_pubkey_and_subnet", - return_value=MagicMock(is_null=neuron_is_null), - ), patch("rich.prompt.Confirm.ask", return_value=prompt_response), patch( - "torch.cuda.is_available", return_value=cuda_available + with ( + patch.object(mock_subtensor, "subnet_exists", return_value=subnet_exists), + patch.object( + mock_subtensor, + "get_neuron_for_pubkey_and_subnet", + return_value=MagicMock(is_null=neuron_is_null), + ), + patch("rich.prompt.Confirm.ask", return_value=prompt_response), + patch("torch.cuda.is_available", return_value=cuda_available), ): # Act result = register_extrinsic( @@ -362,17 +371,22 @@ def test_register_extrinsic_with_pow( test_id, ): # Arrange - with patch( - "bittensor.utils.registration._solve_for_difficulty_fast", - return_value=mock_pow_solution if pow_success else None, - ), patch( - "bittensor.utils.registration._solve_for_difficulty_fast_cuda", - return_value=mock_pow_solution if pow_success else None, - ), patch.object( - mock_subtensor, - "_do_pow_register", - return_value=(registration_success, "key is already registered"), - ), patch("torch.cuda.is_available", return_value=cuda): + with ( + patch( + "bittensor.utils.registration._solve_for_difficulty_fast", + return_value=mock_pow_solution if pow_success else None, + ), + patch( + "bittensor.utils.registration._solve_for_difficulty_fast_cuda", + return_value=mock_pow_solution if pow_success else None, + ), + patch.object( + mock_subtensor, + "_do_pow_register", + return_value=(registration_success, "key is already registered"), + ), + patch("torch.cuda.is_available", return_value=cuda), + ): # Act if pow_success: mock_pow_solution.is_stale.return_value = pow_stale diff --git a/tests/unit_tests/extrinsics/test_root.py b/tests/unit_tests/extrinsics/test_root.py index 6c79d05a2a..0b8ba22053 100644 --- a/tests/unit_tests/extrinsics/test_root.py +++ b/tests/unit_tests/extrinsics/test_root.py @@ -86,11 +86,14 @@ def test_root_register_extrinsic( # Arrange mock_subtensor.is_hotkey_registered.side_effect = hotkey_registered - with patch.object( - mock_subtensor, - "_do_root_register", - return_value=(registration_success, "Error registering"), - ) as mock_register, patch("rich.prompt.Confirm.ask", return_value=user_response): + with ( + patch.object( + mock_subtensor, + "_do_root_register", + return_value=(registration_success, "Error registering"), + ) as mock_register, + patch("rich.prompt.Confirm.ask", return_value=user_response), + ): # Act result = root_register_extrinsic( subtensor=mock_subtensor, @@ -187,13 +190,16 @@ def test_set_root_weights_extrinsic( expected_success, ): # Arrange - with patch.object( - mock_subtensor, "_do_set_weights", return_value=(expected_success, "Mock error") - ), patch.object( - mock_subtensor, "min_allowed_weights", return_value=0 - ), patch.object(mock_subtensor, "max_weight_limit", return_value=1), patch( - "rich.prompt.Confirm.ask", return_value=user_response - ) as mock_confirm: + with ( + patch.object( + mock_subtensor, + "_do_set_weights", + return_value=(expected_success, "Mock error"), + ), + patch.object(mock_subtensor, "min_allowed_weights", return_value=0), + patch.object(mock_subtensor, "max_weight_limit", return_value=1), + patch("rich.prompt.Confirm.ask", return_value=user_response) as mock_confirm, + ): # Act result = set_root_weights_extrinsic( subtensor=mock_subtensor, diff --git a/tests/unit_tests/extrinsics/test_senate.py b/tests/unit_tests/extrinsics/test_senate.py index 9964ee8731..5fc21dbdf0 100644 --- a/tests/unit_tests/extrinsics/test_senate.py +++ b/tests/unit_tests/extrinsics/test_senate.py @@ -56,20 +56,21 @@ def test_register_senate_extrinsic( test_id, ): # Arrange - with patch( - "bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt - ), patch("bittensor.extrinsics.senate.time.sleep"), patch.object( - mock_subtensor.substrate, "compose_call" - ), patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), patch.object( - mock_subtensor.substrate, - "submit_extrinsic", - return_value=MagicMock( - is_success=response_success, - process_events=MagicMock(), - error_message="error", + with ( + patch("bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt), + patch("bittensor.extrinsics.senate.time.sleep"), + patch.object(mock_subtensor.substrate, "compose_call"), + patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), + patch.object( + mock_subtensor.substrate, + "submit_extrinsic", + return_value=MagicMock( + is_success=response_success, + process_events=MagicMock(), + error_message="error", + ), ), - ), patch.object( - mock_wallet, "is_senate_member", return_value=is_registered + patch.object(mock_wallet, "is_senate_member", return_value=is_registered), ): # Act result = register_senate_extrinsic( @@ -149,25 +150,28 @@ def test_vote_senate_extrinsic( proposal_hash = "mock_hash" proposal_idx = 123 - with patch( - "bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt - ), patch("bittensor.extrinsics.senate.time.sleep"), patch.object( - mock_subtensor.substrate, "compose_call" - ), patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), patch.object( - mock_subtensor.substrate, - "submit_extrinsic", - return_value=MagicMock( - is_success=response_success, - process_events=MagicMock(), - error_message="error", + with ( + patch("bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt), + patch("bittensor.extrinsics.senate.time.sleep"), + patch.object(mock_subtensor.substrate, "compose_call"), + patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), + patch.object( + mock_subtensor.substrate, + "submit_extrinsic", + return_value=MagicMock( + is_success=response_success, + process_events=MagicMock(), + error_message="error", + ), + ), + patch.object( + mock_subtensor, + "get_vote_data", + return_value={ + "ayes": [mock_wallet.hotkey.ss58_address] if vote_in_ayes else [], + "nays": [mock_wallet.hotkey.ss58_address] if vote_in_nays else [], + }, ), - ), patch.object( - mock_subtensor, - "get_vote_data", - return_value={ - "ayes": [mock_wallet.hotkey.ss58_address] if vote_in_ayes else [], - "nays": [mock_wallet.hotkey.ss58_address] if vote_in_nays else [], - }, ): # Act result = vote_senate_extrinsic( @@ -213,19 +217,22 @@ def test_leave_senate_extrinsic( test_id, ): # Arrange - with patch( - "bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt - ), patch("bittensor.extrinsics.senate.time.sleep"), patch.object( - mock_subtensor.substrate, "compose_call" - ), patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), patch.object( - mock_subtensor.substrate, - "submit_extrinsic", - return_value=MagicMock( - is_success=response_success, - process_events=MagicMock(), - error_message="error", + with ( + patch("bittensor.extrinsics.senate.Confirm.ask", return_value=not prompt), + patch("bittensor.extrinsics.senate.time.sleep"), + patch.object(mock_subtensor.substrate, "compose_call"), + patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), + patch.object( + mock_subtensor.substrate, + "submit_extrinsic", + return_value=MagicMock( + is_success=response_success, + process_events=MagicMock(), + error_message="error", + ), ), - ), patch.object(mock_wallet, "is_senate_member", return_value=is_registered): + patch.object(mock_wallet, "is_senate_member", return_value=is_registered), + ): # Act result = leave_senate_extrinsic( subtensor=mock_subtensor, diff --git a/tests/unit_tests/extrinsics/test_serving.py b/tests/unit_tests/extrinsics/test_serving.py index e335cbe943..ea8e66237a 100644 --- a/tests/unit_tests/extrinsics/test_serving.py +++ b/tests/unit_tests/extrinsics/test_serving.py @@ -281,12 +281,15 @@ def test_serve_axon_extrinsic( ): mock_axon.external_ip = external_ip # Arrange - with patch( - "bittensor.utils.networking.get_external_ip", - side_effect=Exception("Failed to fetch IP") - if not external_ip_success - else MagicMock(return_value="192.168.1.1"), - ), patch.object(mock_subtensor, "serve", return_value=serve_success): + with ( + patch( + "bittensor.utils.networking.get_external_ip", + side_effect=Exception("Failed to fetch IP") + if not external_ip_success + else MagicMock(return_value="192.168.1.1"), + ), + patch.object(mock_subtensor, "serve", return_value=serve_success), + ): # Act if not external_ip_success: with pytest.raises(RuntimeError): @@ -350,15 +353,17 @@ def test_publish_metadata( test_id, ): # Arrange - with patch.object(mock_subtensor.substrate, "compose_call"), patch.object( - mock_subtensor.substrate, "create_signed_extrinsic" - ), patch.object( - mock_subtensor.substrate, - "submit_extrinsic", - return_value=MagicMock( - is_success=response_success, - process_events=MagicMock(), - error_message="error", + with ( + patch.object(mock_subtensor.substrate, "compose_call"), + patch.object(mock_subtensor.substrate, "create_signed_extrinsic"), + patch.object( + mock_subtensor.substrate, + "submit_extrinsic", + return_value=MagicMock( + is_success=response_success, + process_events=MagicMock(), + error_message="error", + ), ), ): # Act diff --git a/tests/unit_tests/extrinsics/test_set_weights.py b/tests/unit_tests/extrinsics/test_set_weights.py index da45fd24f3..d1c354530c 100644 --- a/tests/unit_tests/extrinsics/test_set_weights.py +++ b/tests/unit_tests/extrinsics/test_set_weights.py @@ -70,14 +70,18 @@ def test_set_weights_extrinsic( ): uids_tensor = torch.tensor(uids, dtype=torch.int64) weights_tensor = torch.tensor(weights, dtype=torch.float32) - with patch( - "bittensor.utils.weight_utils.convert_weights_and_uids_for_emit", - return_value=(uids_tensor, weights_tensor), - ), patch("rich.prompt.Confirm.ask", return_value=user_accepts), patch.object( - mock_subtensor, - "_do_set_weights", - return_value=(expected_success, "Mock error message"), - ) as mock_do_set_weights: + with ( + patch( + "bittensor.utils.weight_utils.convert_weights_and_uids_for_emit", + return_value=(uids_tensor, weights_tensor), + ), + patch("rich.prompt.Confirm.ask", return_value=user_accepts), + patch.object( + mock_subtensor, + "_do_set_weights", + return_value=(expected_success, "Mock error message"), + ) as mock_do_set_weights, + ): result, message = set_weights_extrinsic( subtensor=mock_subtensor, wallet=mock_wallet, diff --git a/tests/unit_tests/extrinsics/test_staking.py b/tests/unit_tests/extrinsics/test_staking.py index 006283cddd..28fb6f3299 100644 --- a/tests/unit_tests/extrinsics/test_staking.py +++ b/tests/unit_tests/extrinsics/test_staking.py @@ -119,25 +119,29 @@ def test_add_stake_extrinsic( if staking_balance > bittensor.Balance.from_rao(1000): staking_balance = staking_balance - bittensor.Balance.from_rao(1000) - with patch.object( - mock_subtensor, "_do_stake", return_value=expected_success - ) as mock_add_stake, patch.object( - mock_subtensor, "get_balance", return_value=Balance.from_tao(100) - ), patch.object( - mock_subtensor, - "get_stake_for_coldkey_and_hotkey", - return_value=Balance.from_tao(50), - ), patch.object( - mock_subtensor, - "get_hotkey_owner", - return_value=mock_wallet.coldkeypub.ss58_address - if hotkey_owner - else mock_other_owner_wallet.coldkeypub.ss58_address, - ), patch.object( - mock_subtensor, "is_hotkey_delegate", return_value=hotkey_delegate - ), patch.object(mock_subtensor, "get_delegate_take", return_value=0.01), patch( - "rich.prompt.Confirm.ask", return_value=user_accepts - ) as mock_confirm: + with ( + patch.object( + mock_subtensor, "_do_stake", return_value=expected_success + ) as mock_add_stake, + patch.object(mock_subtensor, "get_balance", return_value=Balance.from_tao(100)), + patch.object( + mock_subtensor, + "get_stake_for_coldkey_and_hotkey", + return_value=Balance.from_tao(50), + ), + patch.object( + mock_subtensor, + "get_hotkey_owner", + return_value=mock_wallet.coldkeypub.ss58_address + if hotkey_owner + else mock_other_owner_wallet.coldkeypub.ss58_address, + ), + patch.object( + mock_subtensor, "is_hotkey_delegate", return_value=hotkey_delegate + ), + patch.object(mock_subtensor, "get_delegate_take", return_value=0.01), + patch("rich.prompt.Confirm.ask", return_value=user_accepts) as mock_confirm, + ): # Act if not hotkey_owner and not hotkey_delegate: with pytest.raises(exception): @@ -496,17 +500,22 @@ def stake_side_effect(hotkey_ss58, *args, **kwargs): index = hotkey_ss58s.index(hotkey_ss58) return stake_responses[index] - with patch.object( - mock_subtensor, "get_balance", return_value=Balance.from_tao(wallet_balance) - ), patch.object( - mock_subtensor, "is_hotkey_delegate", side_effect=hotkey_delegate_side_effect - ), patch.object( - mock_subtensor, "get_hotkey_owner", side_effect=owner_side_effect - ), patch.object( - mock_subtensor, "_do_stake", side_effect=stake_side_effect - ) as mock_do_stake, patch.object( - mock_subtensor, "tx_rate_limit", return_value=0 - ), patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm: + with ( + patch.object( + mock_subtensor, "get_balance", return_value=Balance.from_tao(wallet_balance) + ), + patch.object( + mock_subtensor, + "is_hotkey_delegate", + side_effect=hotkey_delegate_side_effect, + ), + patch.object(mock_subtensor, "get_hotkey_owner", side_effect=owner_side_effect), + patch.object( + mock_subtensor, "_do_stake", side_effect=stake_side_effect + ) as mock_do_stake, + patch.object(mock_subtensor, "tx_rate_limit", return_value=0), + patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm, + ): # Act if exception: with pytest.raises(exception) as exc_info: diff --git a/tests/unit_tests/extrinsics/test_unstaking.py b/tests/unit_tests/extrinsics/test_unstaking.py index 62b3abb642..4f4e2a906b 100644 --- a/tests/unit_tests/extrinsics/test_unstaking.py +++ b/tests/unit_tests/extrinsics/test_unstaking.py @@ -71,19 +71,21 @@ def test_unstake_extrinsic( mock_current_stake = Balance.from_tao(50) mock_current_balance = Balance.from_tao(100) - with patch.object( - mock_subtensor, "_do_unstake", return_value=(expected_success) - ), patch.object( - mock_subtensor, "get_balance", return_value=mock_current_balance - ), patch.object( - mock_subtensor, - "get_minimum_required_stake", - side_effect=mock_get_minimum_required_stake, - ), patch.object( - mock_subtensor, - "get_stake_for_coldkey_and_hotkey", - return_value=mock_current_stake, - ), patch("rich.prompt.Confirm.ask", return_value=user_accepts) as mock_confirm: + with ( + patch.object(mock_subtensor, "_do_unstake", return_value=(expected_success)), + patch.object(mock_subtensor, "get_balance", return_value=mock_current_balance), + patch.object( + mock_subtensor, + "get_minimum_required_stake", + side_effect=mock_get_minimum_required_stake, + ), + patch.object( + mock_subtensor, + "get_stake_for_coldkey_and_hotkey", + return_value=mock_current_stake, + ), + patch("rich.prompt.Confirm.ask", return_value=user_accepts) as mock_confirm, + ): result = unstake_extrinsic( subtensor=mock_subtensor, wallet=mock_wallet, @@ -281,19 +283,26 @@ def unstake_side_effect(hotkey_ss58, *args, **kwargs): index = hotkey_ss58s.index(hotkey_ss58) return unstake_responses[index] - with patch.object( - mock_subtensor, "_do_unstake", side_effect=unstake_side_effect - ) as mock_unstake, patch.object( - mock_subtensor, - "get_minimum_required_stake", - side_effect=mock_get_minimum_required_stake, - ), patch.object( - mock_subtensor, "get_balance", return_value=Balance.from_tao(wallet_balance) - ), patch.object(mock_subtensor, "tx_rate_limit", return_value=0), patch.object( - mock_subtensor, - "get_stake_for_coldkey_and_hotkey", - return_value=mock_current_stake, - ), patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm: + with ( + patch.object( + mock_subtensor, "_do_unstake", side_effect=unstake_side_effect + ) as mock_unstake, + patch.object( + mock_subtensor, + "get_minimum_required_stake", + side_effect=mock_get_minimum_required_stake, + ), + patch.object( + mock_subtensor, "get_balance", return_value=Balance.from_tao(wallet_balance) + ), + patch.object(mock_subtensor, "tx_rate_limit", return_value=0), + patch.object( + mock_subtensor, + "get_stake_for_coldkey_and_hotkey", + return_value=mock_current_stake, + ), + patch("rich.prompt.Confirm.ask", return_value=prompt_response) as mock_confirm, + ): # Act if exception: with pytest.raises(exception) as exc_info: diff --git a/tests/unit_tests/test_overview.py b/tests/unit_tests/test_overview.py index 04a498f827..70d5e4cb84 100644 --- a/tests/unit_tests/test_overview.py +++ b/tests/unit_tests/test_overview.py @@ -92,17 +92,20 @@ def test_get_total_balance( mock_wallet.coldkeypub_file.exists_on_device.return_value = exists_on_device mock_wallet.coldkeypub_file.is_encrypted.return_value = is_encrypted - with patch( - "bittensor.wallet", return_value=mock_wallet - ), patch( - "bittensor.commands.overview.get_coldkey_wallets_for_path", - return_value=[mock_wallet] if config_all else [], - ), patch( - "bittensor.commands.overview.get_all_wallets_for_path", - return_value=[mock_wallet], - ), patch( - "bittensor.commands.overview.get_hotkey_wallets_for_wallet", - return_value=[mock_wallet], + with ( + patch("bittensor.wallet", return_value=mock_wallet), + patch( + "bittensor.commands.overview.get_coldkey_wallets_for_path", + return_value=[mock_wallet] if config_all else [], + ), + patch( + "bittensor.commands.overview.get_all_wallets_for_path", + return_value=[mock_wallet], + ), + patch( + "bittensor.commands.overview.get_hotkey_wallets_for_wallet", + return_value=[mock_wallet], + ), ): # Act result_hotkeys, result_balance = OverviewCommand._get_total_balance( diff --git a/tests/unit_tests/test_wallet.py b/tests/unit_tests/test_wallet.py index 9288af72c8..875e80c2b8 100644 --- a/tests/unit_tests/test_wallet.py +++ b/tests/unit_tests/test_wallet.py @@ -170,8 +170,9 @@ def test_check_and_update_encryption_not_updated(wallet_update_setup): legacy_wallet = create_legacy_wallet( default_legacy_password=default_legacy_password ) - with patch("getpass.getpass", return_value="wrong_password"), patch.object( - Confirm, "ask", return_value=False + with ( + patch("getpass.getpass", return_value="wrong_password"), + patch.object(Confirm, "ask", return_value=False), ): assert not legacy_wallet.coldkey_file.check_and_update_encryption() @@ -237,8 +238,9 @@ def check_new_hotkey_file(keyfile): old_hotkey_path = legacy_wallet.hotkey_file.path # update legacy_wallet from ansible to nacl - with patch("getpass.getpass", return_value=legacy_password), patch.object( - Confirm, "ask", return_value=True + with ( + patch("getpass.getpass", return_value=legacy_password), + patch.object(Confirm, "ask", return_value=True), ): legacy_wallet.coldkey_file.check_and_update_encryption() @@ -463,9 +465,10 @@ def test_regen_coldkey_mnemonic(mock_wallet, mnemonic, expected_exception): """Test the `regenerate_coldkey` method of the wallet class, which regenerates the cold key pair from a mnemonic. We test different input formats of mnemonics and check if the function works as expected. """ - with patch.object(mock_wallet, "set_coldkey") as mock_set_coldkey, patch.object( - mock_wallet, "set_coldkeypub" - ) as mock_set_coldkeypub: + with ( + patch.object(mock_wallet, "set_coldkey") as mock_set_coldkey, + patch.object(mock_wallet, "set_coldkeypub") as mock_set_coldkeypub, + ): if expected_exception: with pytest.raises(expected_exception): mock_wallet.regenerate_coldkey( @@ -492,8 +495,9 @@ def test_regen_coldkey_overwrite_functionality( ss58_addr = "5D5cwd8DX6ij7nouVcoxDuWtJfiR1BnzCkiBVTt7DU8ft5Ta" seed_str = "0x659c024d5be809000d0d93fe378cfde020846150b01c49a201fc2a02041f7636" - with patch.object(mock_wallet, "set_coldkey") as mock_set_coldkey, patch( - "builtins.input", return_value=user_input + with ( + patch.object(mock_wallet, "set_coldkey") as mock_set_coldkey, + patch("builtins.input", return_value=user_input), ): if expected_exception: with pytest.raises(KeyFileError): From b38c72d2d97a99df9dd7a610090b2f8c8b36a846 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:41:56 +0200 Subject: [PATCH 12/15] add `ruff check` to CI --- .circleci/config.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7ea959790e..d9fd2d9363 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -37,7 +37,13 @@ jobs: key: v2-pypi-py-ruff-<< parameters.python-version >> - run: - name: Ruff format check + name: Ruff linter check + command: | + . .venv/bin/activate + ruff check --diff --unsafe-fixes . + + - run: + name: Ruff format command: | . .venv/bin/activate ruff format --diff . From 16c877214feb2f5399da454e2bef81525259a4d4 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 09:54:28 +0200 Subject: [PATCH 13/15] use bittensor.Subtensor(...) instead of bittensor.subtensor(...) --- README.md | 2 +- bittensor/commands/delegates.py | 30 +++++++++---------- bittensor/commands/identity.py | 8 ++--- bittensor/commands/inspect.py | 4 +-- bittensor/commands/metagraph.py | 6 ++-- bittensor/commands/network.py | 30 +++++++++---------- bittensor/commands/overview.py | 16 +++++----- bittensor/commands/register.py | 20 ++++++------- bittensor/commands/root.py | 24 +++++++-------- bittensor/commands/senate.py | 22 +++++++------- bittensor/commands/stake.py | 8 ++--- bittensor/commands/transfer.py | 6 ++-- bittensor/commands/unstake.py | 4 +-- bittensor/commands/utils.py | 2 +- bittensor/commands/wallets.py | 4 +-- bittensor/commands/weights.py | 8 ++--- bittensor/extrinsics/commit_weights.py | 4 +-- bittensor/extrinsics/delegation.py | 10 +++---- bittensor/extrinsics/network.py | 4 +-- bittensor/extrinsics/prometheus.py | 4 +-- bittensor/extrinsics/registration.py | 8 ++--- bittensor/extrinsics/root.py | 4 +-- bittensor/extrinsics/senate.py | 6 ++-- bittensor/extrinsics/serving.py | 8 ++--- bittensor/extrinsics/set_weights.py | 2 +- bittensor/extrinsics/staking.py | 6 ++-- bittensor/extrinsics/transfer.py | 2 +- bittensor/extrinsics/unstaking.py | 8 ++--- bittensor/metagraph.py | 8 ++--- bittensor/utils/registration.py | 8 ++--- bittensor/utils/weight_utils.py | 2 +- contrib/DEBUGGING.md | 2 +- .../weights/test_commit_weights.py | 2 +- tests/integration_tests/test_cli.py | 4 +-- .../test_subtensor_integration.py | 8 ++--- 35 files changed, 147 insertions(+), 147 deletions(-) diff --git a/README.md b/README.md index b9284f2a5b..2a16a97577 100644 --- a/README.md +++ b/README.md @@ -244,7 +244,7 @@ Subtensor: Interfaces with bittensor's blockchain and can perform operations lik ```python import bittensor # Bittensor's chain interface. -subtensor = bittensor.subtensor() +subtensor = bittensor.Subtensor() # Get the chain block subtensor.get_current_block() # Transfer Tao to a destination address. diff --git a/bittensor/commands/delegates.py b/bittensor/commands/delegates.py index 4f9b29b9b5..3e9f6c7a64 100644 --- a/bittensor/commands/delegates.py +++ b/bittensor/commands/delegates.py @@ -365,7 +365,7 @@ def run(cli: "bittensor.cli"): try: config = cli.config.copy() wallet = bittensor.wallet(config=config) - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) subtensor.delegate( @@ -407,7 +407,7 @@ def check_config(config: "bittensor.config"): if not config.get("delegate_ss58key"): # Check for delegates. with bittensor.__console__.status(":satellite: Loading delegates..."): - subtensor = bittensor.subtensor(config=config, log_verbose=False) + subtensor = bittensor.Subtensor(config=config, log_verbose=False) delegates: list[bittensor.DelegateInfo] = subtensor.get_delegates() try: prev_delegates = subtensor.get_delegates( @@ -494,7 +494,7 @@ def run(cli: "bittensor.cli"): """Undelegates stake from a chain delegate.""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) DelegateUnstakeCommand._run(cli, subtensor) @@ -503,7 +503,7 @@ def run(cli: "bittensor.cli"): subtensor.close() bittensor.logging.debug("closing subtensor connection") - def _run(self: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(self: "bittensor.cli", subtensor: "bittensor.Subtensor"): """Undelegates stake from a chain delegate.""" config = self.config.copy() wallet = bittensor.wallet(config=config) @@ -546,7 +546,7 @@ def check_config(config: "bittensor.config"): if not config.get("delegate_ss58key"): # Check for delegates. with bittensor.__console__.status(":satellite: Loading delegates..."): - subtensor = bittensor.subtensor(config=config, log_verbose=False) + subtensor = bittensor.Subtensor(config=config, log_verbose=False) delegates: list[bittensor.DelegateInfo] = subtensor.get_delegates() try: prev_delegates = subtensor.get_delegates( @@ -634,7 +634,7 @@ def run(cli: "bittensor.cli"): cli.config.subtensor.chain_endpoint = ( "wss://archive.chain.opentensor.ai:443" ) - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) ListDelegatesLiteCommand._run(cli, subtensor) @@ -644,7 +644,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r""" List all delegates on the network. """ @@ -716,7 +716,7 @@ def run(cli: "bittensor.cli"): cli.config.subtensor.chain_endpoint = ( "wss://archive.chain.opentensor.ai:443" ) - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) ListDelegatesCommand._run(cli, subtensor) @@ -726,7 +726,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r""" List all delegates on the network. """ @@ -798,7 +798,7 @@ class NominateCommand: def run(cli: "bittensor.cli"): r"""Nominate wallet.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) NominateCommand._run(cli, subtensor) @@ -808,7 +808,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Nominate wallet.""" wallet = bittensor.wallet(config=cli.config) @@ -922,7 +922,7 @@ def run(cli: "bittensor.cli"): """Delegates stake to a chain delegate.""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) MyDelegatesCommand._run(cli, subtensor) @@ -932,7 +932,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): """Delegates stake to a chain delegate.""" config = cli.config.copy() if config.get("all", d=None): @@ -1115,7 +1115,7 @@ class SetTakeCommand: def run(cli: "bittensor.cli"): r"""Set delegate take.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SetTakeCommand._run(cli, subtensor) @@ -1125,7 +1125,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Set delegate take.""" config = cli.config.copy() wallet = bittensor.wallet(config=cli.config) diff --git a/bittensor/commands/identity.py b/bittensor/commands/identity.py index e075940bba..3f6826720c 100644 --- a/bittensor/commands/identity.py +++ b/bittensor/commands/identity.py @@ -59,7 +59,7 @@ class SetIdentityCommand: def run(cli: "bittensor.cli"): r"""Create a new or update existing identity on-chain.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SetIdentityCommand._run(cli, subtensor) @@ -68,7 +68,7 @@ def run(cli: "bittensor.cli"): subtensor.close() bittensor.logging.debug("closing subtensor connection") - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Create a new or update existing identity on-chain.""" console = bittensor.__console__ @@ -276,7 +276,7 @@ class GetIdentityCommand: def run(cli: "bittensor.cli"): r"""Queries the subtensor chain for user identity.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) GetIdentityCommand._run(cli, subtensor) @@ -285,7 +285,7 @@ def run(cli: "bittensor.cli"): subtensor.close() bittensor.logging.debug("closing subtensor connection") - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): console = bittensor.__console__ with console.status(":satellite: [bold green]Querying chain identity..."): diff --git a/bittensor/commands/inspect.py b/bittensor/commands/inspect.py index 0519c485f2..641faa617d 100644 --- a/bittensor/commands/inspect.py +++ b/bittensor/commands/inspect.py @@ -115,7 +115,7 @@ class InspectCommand: def run(cli: "bittensor.cli"): r"""Inspect a cold, hot pair.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) InspectCommand._run(cli, subtensor) @@ -125,7 +125,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): if cli.config.get("all", d=False) is True: wallets = _get_coldkey_wallets_for_path(cli.config.wallet.path) all_hotkeys = get_all_wallets_for_path(cli.config.wallet.path) diff --git a/bittensor/commands/metagraph.py b/bittensor/commands/metagraph.py index 3cdc6b03a2..46430c53ed 100644 --- a/bittensor/commands/metagraph.py +++ b/bittensor/commands/metagraph.py @@ -76,7 +76,7 @@ class MetagraphCommand: def run(cli: "bittensor.cli"): r"""Prints an entire metagraph.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) MetagraphCommand._run(cli, subtensor) @@ -85,7 +85,7 @@ def run(cli: "bittensor.cli"): subtensor.close() bittensor.logging.debug("closing subtensor connection") - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Prints an entire metagraph.""" console = bittensor.__console__ console.print( @@ -238,7 +238,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): @staticmethod def check_config(config: "bittensor.config"): check_netuid_set( - config, subtensor=bittensor.subtensor(config=config, log_verbose=False) + config, subtensor=bittensor.Subtensor(config=config, log_verbose=False) ) @staticmethod diff --git a/bittensor/commands/network.py b/bittensor/commands/network.py index 109d03013d..5a82ccb169 100644 --- a/bittensor/commands/network.py +++ b/bittensor/commands/network.py @@ -66,7 +66,7 @@ def run(cli: "bittensor.cli"): r"""Register a subnetwork""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) RegisterSubnetworkCommand._run(cli, subtensor) @@ -76,7 +76,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register a subnetwork""" wallet = bittensor.wallet(config=cli.config) @@ -153,7 +153,7 @@ def run(cli: "bittensor.cli"): r"""View locking cost of creating a new subnetwork""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) SubnetLockCostCommand._run(cli, subtensor) @@ -163,7 +163,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View locking cost of creating a new subnetwork""" cli.config.copy() try: @@ -229,7 +229,7 @@ class SubnetListCommand: def run(cli: "bittensor.cli"): r"""List all subnet netuids in the network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SubnetListCommand._run(cli, subtensor) @@ -239,7 +239,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""List all subnet netuids in the network.""" subnets: list[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() @@ -357,7 +357,7 @@ class SubnetSudoCommand: def run(cli: "bittensor.cli"): r"""Set subnet hyperparameters.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SubnetSudoCommand._run(cli, subtensor) @@ -369,7 +369,7 @@ def run(cli: "bittensor.cli"): @staticmethod def _run( cli: "bittensor.cli", - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", ): r"""Set subnet hyperparameters.""" wallet = bittensor.wallet(config=cli.config) @@ -404,7 +404,7 @@ def check_config(config: "bittensor.config"): if not config.is_set("netuid") and not config.no_prompt: check_netuid_set( - config, bittensor.subtensor(config=config, log_verbose=False) + config, bittensor.Subtensor(config=config, log_verbose=False) ) @staticmethod @@ -466,7 +466,7 @@ class SubnetHyperparamsCommand: def run(cli: "bittensor.cli"): r"""View hyperparameters of a subnetwork.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SubnetHyperparamsCommand._run(cli, subtensor) @@ -476,7 +476,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View hyperparameters of a subnetwork.""" subnet: bittensor.SubnetHyperparameters = subtensor.get_subnet_hyperparameters( cli.config.netuid @@ -502,7 +502,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): def check_config(config: "bittensor.config"): if not config.is_set("netuid") and not config.no_prompt: check_netuid_set( - config, bittensor.subtensor(config=config, log_verbose=False) + config, bittensor.Subtensor(config=config, log_verbose=False) ) @staticmethod @@ -568,7 +568,7 @@ class SubnetGetHyperparamsCommand: def run(cli: "bittensor.cli"): r"""View hyperparameters of a subnetwork.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SubnetGetHyperparamsCommand._run(cli, subtensor) @@ -578,7 +578,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View hyperparameters of a subnetwork.""" subnet: bittensor.SubnetHyperparameters = subtensor.get_subnet_hyperparameters( cli.config.netuid @@ -604,7 +604,7 @@ def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): def check_config(config: "bittensor.config"): if not config.is_set("netuid") and not config.no_prompt: check_netuid_set( - config, bittensor.subtensor(config=config, log_verbose=False) + config, bittensor.Subtensor(config=config, log_verbose=False) ) @staticmethod diff --git a/bittensor/commands/overview.py b/bittensor/commands/overview.py index c43bae04b4..ad94ac23f3 100644 --- a/bittensor/commands/overview.py +++ b/bittensor/commands/overview.py @@ -84,7 +84,7 @@ class OverviewCommand: def run(cli: "bittensor.cli"): r"""Prints an overview for the wallet's colkey.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) OverviewCommand._run(cli, subtensor) @@ -96,7 +96,7 @@ def run(cli: "bittensor.cli"): @staticmethod def _get_total_balance( total_balance: "bittensor.Balance", - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", cli: "bittensor.cli", ) -> tuple[list["bittensor.wallet"], "bittensor.Balance"]: if cli.config.get("all", d=None): @@ -182,7 +182,7 @@ def _process_neuron_results( neurons[str(netuid)] = neurons_result return neurons - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Prints an overview for the wallet's colkey.""" console = bittensor.__console__ wallet = bittensor.wallet(config=cli.config) @@ -616,12 +616,12 @@ def _get_neurons_for_netuid( ) -> tuple[int, list["bittensor.NeuronInfoLite"], Optional[str]]: subtensor_config, netuid, hot_wallets = args_tuple - result: list["bittensor.NeuronInfoLite"] = [] + result: list[bittensor.NeuronInfoLite] = [] try: - subtensor = bittensor.subtensor(config=subtensor_config, log_verbose=False) + subtensor = bittensor.Subtensor(config=subtensor_config, log_verbose=False) - all_neurons: list["bittensor.NeuronInfoLite"] = subtensor.neurons_lite( + all_neurons: list[bittensor.NeuronInfoLite] = subtensor.neurons_lite( netuid=netuid ) # Map the hotkeys to uids @@ -649,10 +649,10 @@ def _get_de_registered_stake_for_coldkey_wallet( subtensor_config, all_hotkey_addresses, coldkey_wallet = args_tuple # List of (hotkey_addr, our_stake) tuples. - result: list[tuple[str, "bittensor.Balance"]] = [] + result: list[tuple[str, bittensor.Balance]] = [] try: - subtensor = bittensor.subtensor(config=subtensor_config, log_verbose=False) + subtensor = bittensor.Subtensor(config=subtensor_config, log_verbose=False) # Pull all stake for our coldkey all_stake_info_for_coldkey = subtensor.get_stake_info_for_coldkey( diff --git a/bittensor/commands/register.py b/bittensor/commands/register.py index d55454dcc1..99385ef2f1 100644 --- a/bittensor/commands/register.py +++ b/bittensor/commands/register.py @@ -67,7 +67,7 @@ def run(cli: "bittensor.cli"): r"""Register neuron by recycling some TAO.""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) RegisterCommand._run(cli, subtensor) @@ -77,7 +77,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register neuron by recycling some TAO.""" wallet = bittensor.wallet(config=cli.config) @@ -146,7 +146,7 @@ def check_config(config: "bittensor.config"): config.subtensor.chain_endpoint = endpoint check_netuid_set( - config, subtensor=bittensor.subtensor(config=config, log_verbose=False) + config, subtensor=bittensor.Subtensor(config=config, log_verbose=False) ) if not config.is_set("wallet.name") and not config.no_prompt: @@ -197,7 +197,7 @@ class PowRegisterCommand: def run(cli: "bittensor.cli"): r"""Register neuron.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) PowRegisterCommand._run(cli, subtensor) @@ -207,7 +207,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register neuron.""" wallet = bittensor.wallet(config=cli.config) @@ -345,7 +345,7 @@ def check_config(config: "bittensor.config"): config.subtensor.chain_endpoint = endpoint check_netuid_set( - config, subtensor=bittensor.subtensor(config=config, log_verbose=False) + config, subtensor=bittensor.Subtensor(config=config, log_verbose=False) ) if not config.is_set("wallet.name") and not config.no_prompt: @@ -399,7 +399,7 @@ class RunFaucetCommand: def run(cli: "bittensor.cli"): r"""Register neuron.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RunFaucetCommand._run(cli, subtensor) @@ -409,7 +409,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register neuron.""" wallet = bittensor.wallet(config=cli.config) success = subtensor.run_faucet( @@ -527,7 +527,7 @@ class SwapHotkeyCommand: def run(cli: "bittensor.cli"): r"""Swap your hotkey for all registered axons on the network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) SwapHotkeyCommand._run(cli, subtensor) @@ -537,7 +537,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Swap your hotkey for all registered axons on the network.""" wallet = bittensor.wallet(config=cli.config) diff --git a/bittensor/commands/root.py b/bittensor/commands/root.py index 9527325511..ec3761e2d2 100644 --- a/bittensor/commands/root.py +++ b/bittensor/commands/root.py @@ -57,7 +57,7 @@ class RootRegisterCommand: def run(cli: "bittensor.cli"): r"""Register to root network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootRegisterCommand._run(cli, subtensor) @@ -67,7 +67,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register to root network.""" wallet = bittensor.wallet(config=cli.config) @@ -127,7 +127,7 @@ class RootList: def run(cli: "bittensor.cli"): r"""List the root network""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootList._run(cli, subtensor) @@ -137,7 +137,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""List the root network""" console.print( f":satellite: Syncing with chain: [white]{subtensor.network}[/white] ..." @@ -264,7 +264,7 @@ class RootSetBoostCommand: def run(cli: "bittensor.cli"): r"""Set weights for root network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootSetBoostCommand._run(cli, subtensor) @@ -274,7 +274,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Set weights for root network.""" wallet = bittensor.wallet(config=cli.config) @@ -382,7 +382,7 @@ class RootSetSlashCommand: def run(cli: "bittensor.cli"): """Set weights for root network with decreased values.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootSetSlashCommand._run(cli, subtensor) @@ -392,7 +392,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): wallet = bittensor.wallet(config=cli.config) bittensor.__console__.print( @@ -472,7 +472,7 @@ class RootSetWeightsCommand: def run(cli: "bittensor.cli"): r"""Set weights for root network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootSetWeightsCommand._run(cli, subtensor) @@ -482,7 +482,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Set weights for root network.""" wallet = bittensor.wallet(config=cli.config) subnets: list[bittensor.SubnetInfo] = subtensor.get_all_subnets_info() @@ -583,7 +583,7 @@ class RootGetWeightsCommand: def run(cli: "bittensor.cli"): r"""Get weights for root network.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RootGetWeightsCommand._run(cli, subtensor) @@ -593,7 +593,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Get weights for root network.""" weights = subtensor.weights(0) diff --git a/bittensor/commands/senate.py b/bittensor/commands/senate.py index fdfd884ea9..7ac3f7f531 100644 --- a/bittensor/commands/senate.py +++ b/bittensor/commands/senate.py @@ -53,7 +53,7 @@ def run(cli: "bittensor.cli"): r"""View Bittensor's governance protocol proposals""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) SenateCommand._run(cli, subtensor) @@ -63,7 +63,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View Bittensor's governance protocol proposals""" console = bittensor.__console__ console.print( @@ -190,7 +190,7 @@ def run(cli: "bittensor.cli"): r"""View Bittensor's governance protocol proposals""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) ProposalsCommand._run(cli, subtensor) @@ -200,7 +200,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View Bittensor's governance protocol proposals""" console = bittensor.__console__ console.print( @@ -307,7 +307,7 @@ def run(cli: "bittensor.cli"): r"""View Bittensor's governance protocol proposals active votes""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) ShowVotesCommand._run(cli, subtensor) @@ -317,7 +317,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""View Bittensor's governance protocol proposals active votes""" console.print( f":satellite: Syncing with chain: [white]{cli.config.subtensor.network}[/white] ..." @@ -409,7 +409,7 @@ def run(cli: "bittensor.cli"): r"""Register to participate in Bittensor's governance protocol proposals""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) SenateRegisterCommand._run(cli, subtensor) @@ -419,7 +419,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Register to participate in Bittensor's governance protocol proposals""" wallet = bittensor.wallet(config=cli.config) @@ -487,7 +487,7 @@ def run(cli: "bittensor.cli"): r"""Discard membership in Bittensor's governance protocol proposals""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) SenateLeaveCommand._run(cli, subtensor) @@ -559,7 +559,7 @@ def run(cli: "bittensor.cli"): r"""Vote in Bittensor's governance protocol proposals""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) VoteCommand._run(cli, subtensor) @@ -569,7 +569,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Vote in Bittensor's governance protocol proposals""" wallet = bittensor.wallet(config=cli.config) diff --git a/bittensor/commands/stake.py b/bittensor/commands/stake.py index 564e7e3aba..48ec36cee3 100644 --- a/bittensor/commands/stake.py +++ b/bittensor/commands/stake.py @@ -71,7 +71,7 @@ def run(cli: "bittensor.cli"): r"""Stake token of amount to hotkey(s).""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) StakeCommand._run(cli, subtensor) @@ -81,7 +81,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Stake token of amount to hotkey(s).""" config = cli.config.copy() wallet = bittensor.wallet(config=config) @@ -364,7 +364,7 @@ class StakeShow: def run(cli: "bittensor.cli"): r"""Show all stake accounts.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) StakeShow._run(cli, subtensor) @@ -374,7 +374,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Show all stake accounts.""" if cli.config.get("all", d=False) is True: wallets = _get_coldkey_wallets_for_path(cli.config.wallet.path) diff --git a/bittensor/commands/transfer.py b/bittensor/commands/transfer.py index f23f33471d..c85db9a9e9 100644 --- a/bittensor/commands/transfer.py +++ b/bittensor/commands/transfer.py @@ -56,7 +56,7 @@ class TransferCommand: def run(cli: "bittensor.cli"): r"""Transfer token of amount to destination.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) TransferCommand._run(cli, subtensor) @@ -66,7 +66,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Transfer token of amount to destination.""" wallet = bittensor.wallet(config=cli.config) subtensor.transfer( @@ -94,7 +94,7 @@ def check_config(config: "bittensor.config"): # Get current balance and print to user. if not config.no_prompt: wallet = bittensor.wallet(config=config) - subtensor = bittensor.subtensor(config=config, log_verbose=False) + subtensor = bittensor.Subtensor(config=config, log_verbose=False) with bittensor.__console__.status(":satellite: Checking Balance..."): account_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address) bittensor.__console__.print( diff --git a/bittensor/commands/unstake.py b/bittensor/commands/unstake.py index ac1f859eac..3525863783 100644 --- a/bittensor/commands/unstake.py +++ b/bittensor/commands/unstake.py @@ -158,7 +158,7 @@ def run(cli: "bittensor.cli"): r"""Unstake token of amount from hotkey(s).""" try: config = cli.config.copy() - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=config, log_verbose=False ) UnStakeCommand._run(cli, subtensor) @@ -168,7 +168,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Unstake token of amount from hotkey(s).""" config = cli.config.copy() wallet = bittensor.wallet(config=config) diff --git a/bittensor/commands/utils.py b/bittensor/commands/utils.py index e0a7f8cce5..1e8ee210e8 100644 --- a/bittensor/commands/utils.py +++ b/bittensor/commands/utils.py @@ -48,7 +48,7 @@ def check_choice(self, value: str) -> bool: def check_netuid_set( config: "bittensor.config", - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", allow_none: bool = False, ): if subtensor.network != "nakamoto": diff --git a/bittensor/commands/wallets.py b/bittensor/commands/wallets.py index 960a980871..cf3040d5b3 100644 --- a/bittensor/commands/wallets.py +++ b/bittensor/commands/wallets.py @@ -766,7 +766,7 @@ class WalletBalanceCommand: def run(cli: "bittensor.cli"): """Check the balance of the wallet.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) WalletBalanceCommand._run(cli, subtensor) @@ -776,7 +776,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): bittensor.wallet(config=cli.config) wallet_names = [] diff --git a/bittensor/commands/weights.py b/bittensor/commands/weights.py index 218ae7c627..84bcd845e2 100644 --- a/bittensor/commands/weights.py +++ b/bittensor/commands/weights.py @@ -55,7 +55,7 @@ class CommitWeightCommand: def run(cli: "bittensor.cli"): r"""Commit weights for a specific subnet.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) CommitWeightCommand._run(cli, subtensor) @@ -65,7 +65,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Commit weights for a specific subnet""" wallet = bittensor.wallet(config=cli.config) @@ -186,7 +186,7 @@ class RevealWeightCommand: def run(cli: "bittensor.cli"): r"""Reveal weights for a specific subnet.""" try: - subtensor: "bittensor.subtensor" = bittensor.subtensor( + subtensor: bittensor.Subtensor = bittensor.Subtensor( config=cli.config, log_verbose=False ) RevealWeightCommand._run(cli, subtensor) @@ -196,7 +196,7 @@ def run(cli: "bittensor.cli"): bittensor.logging.debug("closing subtensor connection") @staticmethod - def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"): + def _run(cli: "bittensor.cli", subtensor: "bittensor.Subtensor"): r"""Reveal weights for a specific subnet.""" wallet = bittensor.wallet(config=cli.config) diff --git a/bittensor/extrinsics/commit_weights.py b/bittensor/extrinsics/commit_weights.py index b8f84e9c0c..edb49a8e19 100644 --- a/bittensor/extrinsics/commit_weights.py +++ b/bittensor/extrinsics/commit_weights.py @@ -24,7 +24,7 @@ def commit_weights_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, commit_hash: str, @@ -69,7 +69,7 @@ def commit_weights_extrinsic( def reveal_weights_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, uids: list[int], diff --git a/bittensor/extrinsics/delegation.py b/bittensor/extrinsics/delegation.py index c5f74cb970..468ec6aae2 100644 --- a/bittensor/extrinsics/delegation.py +++ b/bittensor/extrinsics/delegation.py @@ -37,7 +37,7 @@ def nominate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_finalization: bool = False, wait_for_inclusion: bool = True, @@ -95,7 +95,7 @@ def nominate_extrinsic( def delegate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", delegate_ss58: Optional[str] = None, amount: Optional[Union[Balance, float]] = None, @@ -216,7 +216,7 @@ def delegate_extrinsic( def undelegate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", delegate_ss58: Optional[str] = None, amount: Optional[Union[Balance, float]] = None, @@ -333,7 +333,7 @@ def undelegate_extrinsic( def decrease_take_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: Optional[str] = None, take: int = 0, @@ -389,7 +389,7 @@ def decrease_take_extrinsic( def increase_take_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: Optional[str] = None, take: int = 0, diff --git a/bittensor/extrinsics/network.py b/bittensor/extrinsics/network.py index e5ef6c3ba5..13381d991e 100644 --- a/bittensor/extrinsics/network.py +++ b/bittensor/extrinsics/network.py @@ -25,7 +25,7 @@ def register_subnetwork_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, @@ -116,7 +116,7 @@ def find_event_attributes_in_extrinsic_receipt(response, event_name) -> list: def set_hyperparameter_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, parameter: str, diff --git a/bittensor/extrinsics/prometheus.py b/bittensor/extrinsics/prometheus.py index 00a0a79cef..b0eca05362 100644 --- a/bittensor/extrinsics/prometheus.py +++ b/bittensor/extrinsics/prometheus.py @@ -22,7 +22,7 @@ def prometheus_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", port: int, netuid: int, @@ -70,7 +70,7 @@ def prometheus_extrinsic( else: external_ip = ip - call_params: "bittensor.PrometheusServeCallParams" = { + call_params: bittensor.PrometheusServeCallParams = { "version": bittensor.__version_as_int__, "ip": net.ip_to_int(external_ip), "port": port, diff --git a/bittensor/extrinsics/registration.py b/bittensor/extrinsics/registration.py index 6ddba2a41b..5ee8efe87a 100644 --- a/bittensor/extrinsics/registration.py +++ b/bittensor/extrinsics/registration.py @@ -31,7 +31,7 @@ def register_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, wait_for_inclusion: bool = False, @@ -216,7 +216,7 @@ def register_extrinsic( def burned_register_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, wait_for_inclusion: bool = False, @@ -322,7 +322,7 @@ class MaxAttemptsException(Exception): def run_faucet_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, @@ -468,7 +468,7 @@ def run_faucet_extrinsic( def swap_hotkey_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", new_wallet: "bittensor.wallet", wait_for_inclusion: bool = False, diff --git a/bittensor/extrinsics/root.py b/bittensor/extrinsics/root.py index cfab7eccbd..6844711bd3 100644 --- a/bittensor/extrinsics/root.py +++ b/bittensor/extrinsics/root.py @@ -33,7 +33,7 @@ def root_register_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, @@ -103,7 +103,7 @@ def root_register_extrinsic( @legacy_torch_api_compat def set_root_weights_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuids: Union[NDArray[np.int64], "torch.LongTensor", list[int]], weights: Union[NDArray[np.float32], "torch.FloatTensor", list[float]], diff --git a/bittensor/extrinsics/senate.py b/bittensor/extrinsics/senate.py index 493eeb8043..2c810744a6 100644 --- a/bittensor/extrinsics/senate.py +++ b/bittensor/extrinsics/senate.py @@ -25,7 +25,7 @@ def register_senate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, @@ -100,7 +100,7 @@ def register_senate_extrinsic( def leave_senate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", wait_for_inclusion: bool = False, wait_for_finalization: bool = True, @@ -175,7 +175,7 @@ def leave_senate_extrinsic( def vote_senate_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", proposal_hash: str, proposal_idx: int, diff --git a/bittensor/extrinsics/serving.py b/bittensor/extrinsics/serving.py index c028c59463..65cc3d20ca 100644 --- a/bittensor/extrinsics/serving.py +++ b/bittensor/extrinsics/serving.py @@ -28,7 +28,7 @@ def serve_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", ip: str, port: int, @@ -69,7 +69,7 @@ def serve_extrinsic( """ # Decrypt hotkey wallet.hotkey - params: "bittensor.AxonServeCallParams" = { + params: bittensor.AxonServeCallParams = { "version": bittensor.__version_as_int__, "ip": net.ip_to_int(ip), "port": port, @@ -141,7 +141,7 @@ def serve_extrinsic( def serve_axon_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", netuid: int, axon: "bittensor.Axon", wait_for_inclusion: bool = False, @@ -200,7 +200,7 @@ def serve_axon_extrinsic( def publish_metadata( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, type: str, diff --git a/bittensor/extrinsics/set_weights.py b/bittensor/extrinsics/set_weights.py index 78dccded04..61ccffc34f 100644 --- a/bittensor/extrinsics/set_weights.py +++ b/bittensor/extrinsics/set_weights.py @@ -32,7 +32,7 @@ def set_weights_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, uids: Union[NDArray[np.int64], "torch.LongTensor", list], diff --git a/bittensor/extrinsics/staking.py b/bittensor/extrinsics/staking.py index a72fc33ff0..e20cf38468 100644 --- a/bittensor/extrinsics/staking.py +++ b/bittensor/extrinsics/staking.py @@ -26,7 +26,7 @@ def add_stake_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: Optional[str] = None, amount: Optional[Union[Balance, float]] = None, @@ -185,7 +185,7 @@ def add_stake_extrinsic( def add_stake_multiple_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58s: list[str], amounts: Optional[list[Union[Balance, float]]] = None, @@ -392,7 +392,7 @@ def add_stake_multiple_extrinsic( def __do_add_stake_single( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: str, amount: "bittensor.Balance", diff --git a/bittensor/extrinsics/transfer.py b/bittensor/extrinsics/transfer.py index 63a8366c83..cca3e45f05 100644 --- a/bittensor/extrinsics/transfer.py +++ b/bittensor/extrinsics/transfer.py @@ -27,7 +27,7 @@ def transfer_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", dest: str, amount: Union[Balance, float], diff --git a/bittensor/extrinsics/unstaking.py b/bittensor/extrinsics/unstaking.py index da01097e80..c88f85db5a 100644 --- a/bittensor/extrinsics/unstaking.py +++ b/bittensor/extrinsics/unstaking.py @@ -26,7 +26,7 @@ def __do_remove_stake_single( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: str, amount: "bittensor.Balance", @@ -74,7 +74,7 @@ def __do_remove_stake_single( def check_threshold_amount( - subtensor: "bittensor.subtensor", unstaking_balance: Balance + subtensor: "bittensor.Subtensor", unstaking_balance: Balance ) -> bool: """ Checks if the unstaking amount is above the threshold or 0 @@ -100,7 +100,7 @@ def check_threshold_amount( def unstake_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58: Optional[str] = None, amount: Optional[Union[Balance, float]] = None, @@ -224,7 +224,7 @@ def unstake_extrinsic( def unstake_multiple_extrinsic( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", hotkey_ss58s: list[str], amounts: Optional[list[Union[Balance, float]]] = None, diff --git a/bittensor/metagraph.py b/bittensor/metagraph.py index 9b626da446..4037e0c78b 100644 --- a/bittensor/metagraph.py +++ b/bittensor/metagraph.py @@ -505,7 +505,7 @@ def sync( For example:: - subtensor = bittensor.subtensor(network='archive') + subtensor = bittensor.Subtensor(network='archive') """ # Initialize subtensor @@ -552,7 +552,7 @@ def _initialize_subtensor(self, subtensor): """ if not subtensor: # TODO: Check and test the initialization of the new subtensor - subtensor = bittensor.subtensor(network=self.network) + subtensor = bittensor.Subtensor(network=self.network) return subtensor def _assign_neurons(self, block, lite, subtensor): @@ -671,7 +671,7 @@ def _process_weights_or_bonds( len(self.neurons), list(uids), list(values) ).astype(np.float32) ) - tensor_param: Union["torch.nn.Parameter", NDArray] = ( + tensor_param: Union["torch.nn.Parameter", NDArray] = ( # noqa: UP037 ( torch.nn.Parameter(torch.stack(data_array), requires_grad=False) if len(data_array) @@ -734,7 +734,7 @@ def _process_root_weights( ) ) - tensor_param: Union[NDArray, "torch.nn.Parameter"] = ( + tensor_param: Union[NDArray, "torch.nn.Parameter"] = ( # noqa: UP037 ( torch.nn.Parameter(torch.stack(data_array), requires_grad=False) if len(data_array) diff --git a/bittensor/utils/registration.py b/bittensor/utils/registration.py index 668e3d4174..18846dbede 100644 --- a/bittensor/utils/registration.py +++ b/bittensor/utils/registration.py @@ -133,7 +133,7 @@ class POWSolution: difficulty: int seal: bytes - def is_stale(self, subtensor: "bittensor.subtensor") -> bool: + def is_stale(self, subtensor: "bittensor.Subtensor") -> bool: """Returns True if the POW is stale. This means the block the POW is solved for is within 3 blocks of the current block. """ @@ -734,7 +734,7 @@ def _solve_for_difficulty_fast( @backoff.on_exception(backoff.constant, Exception, interval=1, max_tries=3) def _get_block_with_retry( - subtensor: "bittensor.subtensor", netuid: int + subtensor: "bittensor.Subtensor", netuid: int ) -> tuple[int, int, bytes]: """ Gets the current block number, difficulty, and block hash from the substrate node. @@ -790,7 +790,7 @@ def __exit__(self, *args): def _check_for_newest_block_and_update( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", netuid: int, old_block_number: int, hotkey_bytes: bytes, @@ -865,7 +865,7 @@ def _check_for_newest_block_and_update( def _solve_for_difficulty_fast_cuda( - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", wallet: "bittensor.wallet", netuid: int, output_in_place: bool = True, diff --git a/bittensor/utils/weight_utils.py b/bittensor/utils/weight_utils.py index 70495c3f45..8c55b61ac4 100644 --- a/bittensor/utils/weight_utils.py +++ b/bittensor/utils/weight_utils.py @@ -230,7 +230,7 @@ def process_weights_for_netuid( uids: Union[NDArray[np.int64], "torch.Tensor"], weights: Union[NDArray[np.float32], "torch.Tensor"], netuid: int, - subtensor: "bittensor.subtensor", + subtensor: "bittensor.Subtensor", metagraph: "bittensor.metagraph" = None, exclude_quantile: int = 0, ) -> Union[ diff --git a/contrib/DEBUGGING.md b/contrib/DEBUGGING.md index 093e3432bf..914b944416 100644 --- a/contrib/DEBUGGING.md +++ b/contrib/DEBUGGING.md @@ -104,7 +104,7 @@ import bittensor wallet = bittensor.wallet() # Bittensor's chain interface. -subtensor = bittensor.subtensor() +subtensor = bittensor.Subtensor() # Bittensor's chain state object. metagraph = bittensor.metagraph(netuid=1) diff --git a/tests/e2e_tests/subcommands/weights/test_commit_weights.py b/tests/e2e_tests/subcommands/weights/test_commit_weights.py index 13e7aedef7..4b1f231d29 100644 --- a/tests/e2e_tests/subcommands/weights/test_commit_weights.py +++ b/tests/e2e_tests/subcommands/weights/test_commit_weights.py @@ -53,7 +53,7 @@ def test_commit_and_reveal_weights(local_chain): ], ) - subtensor = bittensor.subtensor(network="ws://localhost:9945") + subtensor = bittensor.Subtensor(network="ws://localhost:9945") # Enable Commit Reveal result = subtensor.set_hyperparameter( diff --git a/tests/integration_tests/test_cli.py b/tests/integration_tests/test_cli.py index e424780c7b..811bab16e3 100644 --- a/tests/integration_tests/test_cli.py +++ b/tests/integration_tests/test_cli.py @@ -2074,7 +2074,7 @@ def test_register(self, _): mock_create_wallet.assert_called_once() # Verify that the wallet was registered - subtensor = bittensor.subtensor(config) + subtensor = bittensor.Subtensor(config) registered = subtensor.is_hotkey_registered_on_subnet( hotkey_ss58=mock_wallet.hotkey.ss58_address, netuid=1 ) @@ -2120,7 +2120,7 @@ def test_stake(self, _): config.model = "core_server" config.hotkey = "hk0" - subtensor = bittensor.subtensor(config) + subtensor = bittensor.Subtensor(config) mock_wallet = generate_wallet(hotkey=_get_mock_keypair(100, self.id())) diff --git a/tests/integration_tests/test_subtensor_integration.py b/tests/integration_tests/test_subtensor_integration.py index 5b8993ec0b..b073b64297 100644 --- a/tests/integration_tests/test_subtensor_integration.py +++ b/tests/integration_tests/test_subtensor_integration.py @@ -91,7 +91,7 @@ def test_network_overrides(self): with patch("substrateinterface.SubstrateInterface.reload_type_registry"): print(bittensor.subtensor, type(bittensor.subtensor)) # Choose network arg over config - sub1 = bittensor.subtensor(config=config1, network="local") + sub1 = bittensor.Subtensor(config=config1, network="local") self.assertEqual( sub1.chain_endpoint, bittensor.__local_entrypoint__, @@ -99,14 +99,14 @@ def test_network_overrides(self): ) # Choose network config over chain_endpoint config - sub2 = bittensor.subtensor(config=config0) + sub2 = bittensor.Subtensor(config=config0) self.assertNotEqual( sub2.chain_endpoint, bittensor.__finney_entrypoint__, # Here we expect the endpoint corresponding to the network "finney" msg="config.network should override config.chain_endpoint", ) - sub3 = bittensor.subtensor(config=config1) + sub3 = bittensor.Subtensor(config=config1) # Should pick local instead of finney (default) assert sub3.network == "local" assert sub3.chain_endpoint == bittensor.__local_entrypoint__ @@ -822,7 +822,7 @@ class ExitEarly(Exception): ) def test_defaults_to_finney(self): - sub = bittensor.subtensor() + sub = bittensor.Subtensor() assert sub.network == "finney" assert sub.chain_endpoint == bittensor.__finney_entrypoint__ From 74997cda81d82642845625ce2b5f615d14524a12 Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 10:05:23 +0200 Subject: [PATCH 14/15] fix previously untested test_attach test --- tests/unit_tests/test_axon.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/unit_tests/test_axon.py b/tests/unit_tests/test_axon.py index e96bc03036..75f55035d0 100644 --- a/tests/unit_tests/test_axon.py +++ b/tests/unit_tests/test_axon.py @@ -42,33 +42,33 @@ def test_attach(): server = bittensor.axon() # Define the Synapse type - class Synapse(bittensor.Synapse): + class DummySynapse(bittensor.Synapse): pass # Define the functions with the correct signatures - def forward_fn(synapse: Synapse) -> Any: + def forward_fn(synapse: DummySynapse) -> Any: pass - def blacklist_fn(synapse: Synapse) -> bool: - return True + def blacklist_fn(synapse: DummySynapse) -> tuple[bool, str]: + return True, "" - def priority_fn(synapse: Synapse) -> float: + def priority_fn(synapse: DummySynapse) -> float: return 1.0 - def verify_fn(synapse: Synapse) -> None: + def verify_fn(synapse: DummySynapse) -> None: pass # Test attaching with correct signatures server.attach(forward_fn, blacklist_fn, priority_fn, verify_fn) # Define functions with incorrect signatures - def wrong_blacklist_fn(synapse: Synapse) -> int: + def wrong_blacklist_fn(synapse: DummySynapse) -> int: return 1 - def wrong_priority_fn(synapse: Synapse) -> int: + def wrong_priority_fn(synapse: DummySynapse) -> int: return 1 - def wrong_verify_fn(synapse: Synapse) -> bool: + def wrong_verify_fn(synapse: DummySynapse) -> bool: return True # Test attaching with incorrect signatures From 9cfe615da602987385757517d5e812a279a4cebb Mon Sep 17 00:00:00 2001 From: Maciej Urbanski Date: Tue, 4 Jun 2024 10:11:46 +0200 Subject: [PATCH 15/15] add `ruff check --fix .` to contrib README --- contrib/CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contrib/CONTRIBUTING.md b/contrib/CONTRIBUTING.md index f9f4ed5f34..9f785e7c89 100644 --- a/contrib/CONTRIBUTING.md +++ b/contrib/CONTRIBUTING.md @@ -76,7 +76,7 @@ You can contribute to Bittensor in one of two main ways (as well as many others) Here is a high-level summary: - Code consistency is crucial; adhere to established programming language conventions. -- Use `ruff format .` to format your Python code; it ensures readability and consistency. +- Use `ruff check --fix . && ruff format .` to format your Python code; it ensures readability and consistency. - Write concise Git commit messages; summarize changes in ~50 characters. - Follow these six commit rules: - Atomic Commits: Focus on one task or fix per commit.