htcli 1.1.0__py3-none-any.whl

src/htcli/config.py

@@ -0,0 +1,184 @@
+"""
+Configuration management for the Hypertensor CLI.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class NetworkConfig(BaseModel):
+    """Network configuration."""
+
+    endpoint: str = Field("wss://rpc.htcli.io/", description="RPC endpoint")
+    ws_endpoint: str = Field("wss://rpc.htcli.io/", description="WebSocket endpoint")
+    timeout: int = Field(30, description="Connection timeout in seconds")
+    retry_attempts: int = Field(3, description="Number of retry attempts")
+    network_type: str = Field(
+        "mainnet", description="Network type (mainnet/testnet/devnet)"
+    )
+    evm_compatible: bool = Field(
+        True, description="Whether network supports EVM compatibility"
+    )
+
+
+NETWORK_PROFILES: dict[str, dict[str, object]] = {
+    "mainnet": {
+        "endpoint": "wss://rpc.htcli.io/",
+        "ws_endpoint": "wss://rpc.htcli.io/",
+        "network_type": "mainnet",
+        "evm_compatible": True,
+    },
+    "testnet": {
+        "endpoint": "wss://testnet-rpc.hypertensor.io",
+        "ws_endpoint": "wss://testnet-ws.hypertensor.io",
+        "network_type": "testnet",
+        "evm_compatible": False,
+    },
+    "local": {
+        "endpoint": "ws://127.0.0.1:9944",
+        "ws_endpoint": "ws://127.0.0.1:9944",
+        "network_type": "devnet",
+        "evm_compatible": False,
+    },
+}
+
+NETWORK_ALIASES = {
+    "main": "mainnet",
+    "mainnet": "mainnet",
+    "test": "testnet",
+    "testnet": "testnet",
+    "local": "local",
+    "dev": "local",
+    "devnet": "local",
+}
+
+
+def apply_network_profile(config: "Config", network_name: str) -> "Config":
+    """Apply a named network profile to the active config."""
+    normalized = NETWORK_ALIASES.get(network_name.strip().lower())
+    if normalized is None:
+        valid = ", ".join(sorted(NETWORK_ALIASES))
+        raise ValueError(f"Unknown network '{network_name}'. Expected one of: {valid}")
+
+    profile = NETWORK_PROFILES[normalized]
+    config.network.endpoint = str(profile["endpoint"])
+    config.network.ws_endpoint = str(profile["ws_endpoint"])
+    config.network.network_type = str(profile["network_type"])
+    config.network.evm_compatible = bool(profile["evm_compatible"])
+    return config
+
+
+class OutputConfig(BaseModel):
+    """Output configuration."""
+
+    format: str = Field("table", description="Output format (table/json/csv)")
+    verbose: bool = Field(False, description="Verbose output")
+    color: bool = Field(True, description="Enable colored output")
+    color_scheme: str = Field(
+        "default",
+        description="Color scheme (default/dark/light/high_contrast/soft)",
+    )
+
+
+class FilterConfig(BaseModel):
+    """Filter configuration."""
+
+    mine: bool = Field(False, description="Filter results to show only user assets")
+
+
+class WalletConfig(BaseModel):
+    """Wallet configuration."""
+
+    path: str = Field("~/.htcli/wallets", description="Wallet storage path")
+    default_name: str = Field("default", description="Default wallet name")
+    encryption_enabled: bool = Field(True, description="Enable wallet encryption")
+    default_key_type: str = Field(
+        "ecdsa",
+        description="Default key type for new wallets (ecdsa/sr25519/ed25519)",
+    )
+    mainnet_key_type: str = Field(
+        "ecdsa", description="Required key type for mainnet (EVM compatibility)"
+    )
+    testnet_key_type: str = Field("sr25519", description="Default key type for testnet")
+
+
+class Config(BaseModel):
+    """Main configuration."""
+
+    network: NetworkConfig = Field(default_factory=NetworkConfig)
+    output: OutputConfig = Field(default_factory=OutputConfig)
+    wallet: WalletConfig = Field(default_factory=WalletConfig)
+    filter: FilterConfig = Field(default_factory=FilterConfig)
+
+
+def load_config(config_file: Optional[Path] = None) -> Config:
+    """Load configuration from file or use defaults."""
+    if config_file and config_file.exists():
+        # Load from file
+        import yaml
+
+        with open(config_file) as f:
+            config_data = yaml.safe_load(f)
+        return Config(**config_data)
+    else:
+        # Try to load from YAML config file created by config commands
+        yaml_config_path = Path.home() / ".htcli" / "config.yaml"
+        if yaml_config_path.exists():
+            try:
+                import yaml
+
+                with open(yaml_config_path) as f:
+                    yaml_config_data = yaml.safe_load(f)
+                # Load directly as YAML already matches Pydantic Config structure
+                return Config(**yaml_config_data)
+            except Exception:
+                # If YAML config is invalid or can't be read, fall through to env vars/defaults
+                pass
+
+        # Use environment variables or defaults
+        network_config = NetworkConfig(
+            endpoint=os.getenv("HTCLI_NETWORK_ENDPOINT", "wss://rpc.htcli.io/"),
+            ws_endpoint=os.getenv("HTCLI_NETWORK_WS_ENDPOINT", "wss://rpc.htcli.io/"),
+            timeout=int(os.getenv("HTCLI_NETWORK_TIMEOUT", "30")),
+            retry_attempts=int(os.getenv("HTCLI_NETWORK_RETRY_ATTEMPTS", "3")),
+            network_type=os.getenv("HTCLI_NETWORK_TYPE", "mainnet"),
+            evm_compatible=os.getenv("HTCLI_NETWORK_EVM_COMPATIBLE", "true").lower()
+            == "true",
+        )
+
+        output_config = OutputConfig(
+            format=os.getenv("HTCLI_OUTPUT_FORMAT", "table"),
+            verbose=os.getenv("HTCLI_OUTPUT_VERBOSE", "false").lower() == "true",
+            color=os.getenv("HTCLI_OUTPUT_COLOR", "true").lower() == "true",
+            color_scheme=os.getenv("HTCLI_OUTPUT_COLOR_SCHEME", "default"),
+        )
+
+        wallet_config = WalletConfig(
+            path=os.getenv("HTCLI_WALLET_PATH", "~/.htcli/wallets"),
+            default_name=os.getenv("HTCLI_WALLET_DEFAULT_NAME", "default"),
+            encryption_enabled=os.getenv(
+                "HTCLI_WALLET_ENCRYPTION_ENABLED", "true"
+            ).lower()
+            == "true",
+            default_key_type=os.getenv("HTCLI_WALLET_DEFAULT_KEY_TYPE", "ecdsa"),
+            mainnet_key_type=os.getenv("HTCLI_WALLET_MAINNET_KEY_TYPE", "ecdsa"),
+            testnet_key_type=os.getenv("HTCLI_WALLET_TESTNET_KEY_TYPE", "sr25519"),
+        )
+
+        filter_config = FilterConfig(
+            mine=os.getenv("HTCLI_FILTER_MINE", "false").lower() == "true"
+        )
+
+        return Config(
+            network=network_config,
+            output=output_config,
+            wallet=wallet_config,
+            filter=filter_config,
+        )
+
+
+# Global configuration instance
+config_instance = load_config()

src/htcli/dependencies.py

@@ -0,0 +1,186 @@
+"""
+Dependencies for the Hypertensor CLI.
+"""
+
+import time
+from typing import Optional
+
+from .client import HypertensorClient
+from .config import Config
+from .utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+# Global client instance and config
+_client: Optional[HypertensorClient] = None
+_config: Optional[Config] = None
+
+
+def _retry_delay_seconds(attempt: int) -> int:
+    """Return bounded exponential backoff delay for a retry attempt."""
+    return min(2 ** attempt, 5)
+
+
+def _is_closed_websocket_error(error: Exception) -> bool:
+    """Classify common closed WebSocket failures without depending on one package."""
+    error_name = error.__class__.__name__
+    error_message = str(error).lower()
+    return (
+        error_name == "WebSocketConnectionClosedException"
+        or "websocket" in error_message
+        and ("closed" in error_message or "not connected" in error_message)
+    )
+
+
+def _websocket_is_connected(substrate) -> bool:
+    """Best-effort connection-state check that avoids network calls."""
+    websocket = getattr(substrate, "websocket", None)
+    if not websocket:
+        return True
+
+    if hasattr(websocket, "connected"):
+        return bool(websocket.connected)
+
+    sock = getattr(websocket, "sock", None)
+    if sock is None:
+        return False
+
+    if hasattr(sock, "connected"):
+        return bool(sock.connected)
+
+    return True
+
+
+def _client_needs_reconnect(client: HypertensorClient) -> bool:
+    """Check whether the global client should reconnect before use."""
+    if not client.substrate or not client.rpc or not client.extrinsics:
+        logger.debug("Connection layers missing, reconnecting...")
+        return True
+
+    try:
+        if not _websocket_is_connected(client.substrate):
+            logger.debug("WebSocket connection appears closed, reconnecting...")
+            return True
+    except Exception as check_error:
+        logger.debug(
+            f"Lightweight connection check failed: {check_error}, will reconnect"
+        )
+        return True
+
+    return False
+
+
+def _connect_with_retries(
+    client: HypertensorClient,
+    max_retries: int,
+    *,
+    force_reconnect: bool = False,
+    operation: str = "Connection",
+) -> tuple[bool, Optional[Exception]]:
+    """Connect or reconnect with bounded exponential backoff."""
+    retry_count = 0
+    last_error = None
+
+    while retry_count < max_retries:
+        try:
+            if client.connect(force_reconnect=force_reconnect):
+                logger.debug(
+                    f"{operation} succeeded (attempt {retry_count + 1})"
+                )
+                return True, None
+
+            retry_count += 1
+            if retry_count < max_retries:
+                logger.warning(
+                    f"{operation} attempt {retry_count} failed, retrying..."
+                )
+                time.sleep(_retry_delay_seconds(retry_count))
+        except Exception as error:
+            last_error = error
+            retry_count += 1
+            if retry_count < max_retries:
+                if _is_closed_websocket_error(error):
+                    logger.warning(
+                        f"{operation} attempt {retry_count} hit a closed WebSocket, retrying..."
+                    )
+                else:
+                    logger.warning(
+                        f"{operation} attempt {retry_count} failed: {error}, retrying..."
+                    )
+                time.sleep(_retry_delay_seconds(retry_count))
+            else:
+                logger.error(f"All {max_retries} {operation.lower()} attempts failed")
+
+    return False, last_error
+
+
+def set_client(client: HypertensorClient):
+    """Set the global client instance."""
+    global _client
+    _client = client
+
+
+def set_config(config: Config):
+    """Set the global config instance for lazy client initialization."""
+    global _config
+    _config = config
+
+
+def get_client() -> HypertensorClient:
+    """Get the global client instance, initializing it lazily if needed."""
+    global _client, _config
+
+    if _client is None:
+        if _config is None:
+            raise RuntimeError(
+                "Configuration not set. Please ensure config is loaded before using client."
+            )
+
+        # Initialize client only when first requested
+        _client = HypertensorClient(_config)
+
+        # Connect to blockchain when client is first accessed with retry logic
+        max_retries = _config.network.retry_attempts or 3
+        _, last_error = _connect_with_retries(
+            _client,
+            max_retries,
+            operation="Connection",
+        )
+
+        if not _client.is_connected():
+            error_msg = str(last_error) if last_error else "Connection failed after retries"
+            raise RuntimeError(
+                f"Failed to connect to blockchain after {max_retries} attempts. "
+                f"Please check your network connection and configuration. Last error: {error_msg}"
+            )
+    else:
+        needs_reconnect = _client_needs_reconnect(_client)
+
+        # Only reconnect if lightweight check indicates we need to
+        if needs_reconnect:
+            logger.debug("Connection appears lost, attempting to reconnect...")
+            # Try to reconnect with force flag to close old connection
+            max_retries = _config.network.retry_attempts or 3
+            _, last_error = _connect_with_retries(
+                _client,
+                max_retries,
+                force_reconnect=True,
+                operation="Reconnection",
+            )
+
+            # Final verification: do a lightweight check, not expensive query
+            if _client_needs_reconnect(_client):
+                error_msg = str(last_error) if last_error else "Reconnection failed after retries"
+                # Reset client to allow fresh connection on next call
+                _client = None
+                raise RuntimeError(
+                    f"Blockchain connection lost. Failed to reconnect after {max_retries} attempts. "
+                    f"Please check your network connection. Last error: {error_msg}"
+                )
+
+    return _client
+
+
+def get_config() -> Optional[Config]:
+    """Get the global config instance."""
+    return _config

src/htcli/errors/__init__.py

@@ -0,0 +1,63 @@
+"""
+Error handling module for htcli.
+"""
+
+from .base import (
+    AddressValidationError,
+    BalanceError,
+    HTCLIError,
+    KeyDeletionError,
+    KeyGenerationError,
+    NodeError,
+    NodeOperationError,
+    NodeRegistrationError,
+    SubnetActivationError,
+    SubnetError,
+    SubnetRegistrationError,
+    SubnetValidationError,
+    TransferError,
+    WalletError,
+)
+from .display import display_balance_info
+from .handlers import (
+    display_pydantic_validation_error,
+    format_pydantic_validation_error,
+    get_validation_suggestions,
+    handle_and_display_error,
+    handle_and_display_node_error,
+    handle_and_display_subnet_error,
+    handle_blockchain_error,
+    handle_node_error,
+    handle_subnet_error,
+    handle_substrate_error,
+    handle_wallet_error,
+)
+
+__all__ = [
+    "HTCLIError",
+    "WalletError",
+    "TransferError",
+    "BalanceError",
+    "KeyGenerationError",
+    "KeyDeletionError",
+    "NodeError",
+    "NodeOperationError",
+    "NodeRegistrationError",
+    "SubnetError",
+    "SubnetRegistrationError",
+    "SubnetActivationError",
+    "SubnetValidationError",
+    "AddressValidationError",
+    "handle_blockchain_error",
+    "handle_wallet_error",
+    "handle_and_display_error",
+    "handle_node_error",
+    "handle_and_display_node_error",
+    "handle_subnet_error",
+    "handle_and_display_subnet_error",
+    "handle_substrate_error",
+    "display_balance_info",
+    "display_pydantic_validation_error",
+    "format_pydantic_validation_error",
+    "get_validation_suggestions",
+]

src/htcli/errors/base.py

@@ -0,0 +1,141 @@
+"""
+Base error classes for htcli.
+"""
+
+from typing import Optional
+
+from rich.console import Console
+
+console = Console()
+
+
+class HTCLIError(Exception):
+    """Base exception class for htcli errors."""
+
+    def __init__(self, message: str, suggestions: Optional[list[str]] = None):
+        self.message = message
+        self.suggestions = suggestions or []
+        super().__init__(self.message)
+
+    def display(self):
+        """Display the error with suggestions."""
+        console.print(f"❌ {self.message}")
+
+        if self.suggestions:
+            console.print("\n[bold yellow]💡 Helpful Suggestions:[/bold yellow]")
+            for suggestion in self.suggestions:
+                console.print(f"• {suggestion}")
+
+
+class WalletError(HTCLIError):
+    """Base class for wallet-related errors."""
+
+    pass
+
+
+class TransferError(HTCLIError):
+    """Base class for transfer-related errors."""
+
+    pass
+
+
+class BalanceError(HTCLIError):
+    """Base class for balance-related errors."""
+
+    pass
+
+
+class KeyGenerationError(HTCLIError):
+    """Base class for key generation errors."""
+
+    pass
+
+
+class KeyDeletionError(HTCLIError):
+    """Base class for key deletion errors."""
+
+    pass
+
+
+class SubnetError(HTCLIError):
+    """Base class for subnet-related errors."""
+
+    pass
+
+
+class SubnetRegistrationError(HTCLIError):
+    """Custom exception for subnet registration errors."""
+
+    pass
+
+
+class InvalidPasswordError(HTCLIError):
+    """Custom exception for invalid wallet password."""
+
+
+class SubnetActivationError(SubnetError):
+    """Error during subnet activation."""
+
+    pass
+
+
+class SubnetValidationError(SubnetError):
+    """Error during subnet input validation."""
+
+    pass
+
+
+class AddressValidationError(HTCLIError):
+    """Error during address validation."""
+
+    pass
+
+
+class NodeError(HTCLIError):
+    """Base class for node-related errors."""
+
+    pass
+
+
+class NodeRegistrationError(NodeError):
+    """Custom exception for node registration errors."""
+
+    pass
+
+
+class NodeOperationError(NodeError):
+    """Error during node operations."""
+
+    pass
+
+
+class StakeError(HTCLIError):
+    """Base class for stake-related errors."""
+
+    pass
+
+
+class DelegateStakeError(StakeError):
+    """Error during delegate stake operations."""
+
+    pass
+
+
+# Add the custom exception to errors/base.py
+class AmbiguousWalletError(HTCLIError):
+    """Raised when multiple wallets match the given criteria."""
+    def __init__(self, name: str, matches: list[dict], is_hotkey: bool = False):
+        self.name = name
+        self.matches = matches
+        self.is_hotkey = is_hotkey
+        error_msg = (
+            f"Wallet '{name}' is ambiguous. Found {len(matches)} hotkey wallets "
+            f"with this name. Please specify owner_address or owner_coldkey_name to disambiguate:\n"
+        )
+        for match in matches:
+            owner_addr = match.get("owner_address", "Unknown")
+            owner_ck = match.get("owner_coldkey_name", "Unknown")
+            error_msg += (
+                f"  - Owner coldkey: {owner_ck} (address: {owner_addr})\n"
+            )
+        super().__init__(error_msg)

src/htcli/errors/display.py

@@ -0,0 +1,20 @@
+"""
+Display utility functions for error handling.
+"""
+
+from rich.console import Console
+
+console = Console()
+
+
+def display_balance_info(address: str, balance: float = 0):
+    """Display helpful information when balance is 0."""
+    if balance == 0:
+        console.print(
+            "\n[bold yellow]💡 Note:[/bold yellow] This wallet has no balance."
+        )
+        console.print(f"• To receive funds, share this address: [bold]{address}[/bold]")
+        console.print(
+            "• You can transfer funds from another wallet using: [bold]htcli wallet transfer[/bold]"
+        )
+        console.print("• Transaction fees are typically around 0.001-0.01 TENSOR")