htcli 1.1.0__py3-none-any.whl

src/htcli/client/offchain/config.py

@@ -0,0 +1,541 @@
+"""
+Off-chain configuration management operations.
+Handles local configuration files, network settings, and CLI preferences.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+from ...models.requests import (
+    ConfigGetRequest,
+    ConfigInitRequest,
+    ConfigSetRequest,
+    ConfigShowRequest,
+    ConfigValidateRequest,
+)
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ConfigManager:
+    """Manager for off-chain configuration operations."""
+
+    def __init__(self, config_dir: Optional[str] = None):
+        self.config_dir = Path(config_dir) if config_dir else Path.home() / ".htcli"
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.config_file = self.config_dir / "config.yaml"
+        self.default_config = {
+            "network": {
+                "endpoint": "wss://rpc.htcli.io/",
+                "ws_endpoint": "wss://rpc.htcli.io/",
+                "timeout": 30,
+                "retry_attempts": 3,
+                "chain": "hypertensor",  # Chain name (optional, can be auto-detected)
+            },
+            "wallet": {
+                "path": "~/.htcli/wallets",
+                "default_name": "default",
+                "encryption_enabled": True,
+            },
+            "output": {
+                "format": "table",
+                "verbose": False,
+                "color": True,
+            },
+        }
+
+    def load_config(self) -> dict:
+        """Load configuration from file or create default if not exists."""
+        try:
+            if self.config_file.exists():
+                with open(self.config_file) as f:
+                    if self.config_file.suffix.lower() == ".json":
+                        config = json.load(f)
+                    else:
+                        config = yaml.safe_load(f)
+
+                # Validate and clean config to only include fields from default_config
+                validated_config = self._validate_config(config)
+                return {
+                    "success": True,
+                    "message": "Configuration loaded successfully",
+                    "data": validated_config,
+                }
+            else:
+                # Create default config
+                return self.save_config(self.default_config)
+        except Exception as e:
+            logger.error(f"Failed to load config: {str(e)}")
+            raise
+
+    def save_config(self, config: dict) -> dict:
+        """Save configuration to file."""
+        try:
+            # Validate config structure
+            validated_config = self._validate_config(config)
+
+            with open(self.config_file, "w") as f:
+                if self.config_file.suffix.lower() == ".json":
+                    json.dump(validated_config, f, indent=2)
+                else:
+                    yaml.dump(
+                        validated_config,
+                        f,
+                        indent=2,
+                        default_flow_style=False,
+                        sort_keys=False,
+                    )
+
+            return {
+                "success": True,
+                "message": "Configuration saved successfully",
+                "data": validated_config,
+            }
+        except Exception as e:
+            logger.error(f"Failed to save config: {str(e)}")
+            raise
+
+    def get_setting(self, key_path: str) -> Any:
+        """Get a specific setting using dot notation (e.g., 'network.endpoint')."""
+        try:
+            config_result = self.load_config()
+            config = config_result["data"]
+
+            keys = key_path.split(".")
+            value = config
+
+            for key in keys:
+                if isinstance(value, dict) and key in value:
+                    value = value[key]
+                else:
+                    raise KeyError(f"Setting '{key_path}' not found")
+
+            return {
+                "success": True,
+                "message": f"Setting '{key_path}' retrieved successfully",
+                "data": value,
+            }
+        except Exception as e:
+            logger.error(f"Failed to get setting: {str(e)}")
+            raise
+
+    def set_setting(self, key_path: str, value: Any) -> dict:
+        """Set a specific setting using dot notation.
+
+        Only allows setting fields that are in default_config.
+        """
+        try:
+            # Validate that the key path is in default_config
+            keys = key_path.split(".")
+            if len(keys) < 2:
+                raise ValueError(
+                    f"Invalid key path: {key_path}. Must be in format 'section.field'"
+                )
+
+            section_name = keys[0]
+            field_name = keys[-1]
+
+            # Check if section exists in default_config
+            if section_name not in self.default_config:
+                raise ValueError(
+                    f"Invalid section '{section_name}'. "
+                    f"Available sections: {', '.join(self.default_config.keys())}"
+                )
+
+            # Check if field exists in default_config section
+            if field_name not in self.default_config[section_name]:
+                raise ValueError(
+                    f"Invalid field '{field_name}' in section '{section_name}'. "
+                    f"Available fields: {', '.join(self.default_config[section_name].keys())}"
+                )
+
+            # Load current config
+            config_result = self.load_config()
+            config = config_result["data"]
+
+            # Navigate to the parent of the target key
+            current = config
+            for key in keys[:-1]:
+                if key not in current:
+                    current[key] = {}
+                current = current[key]
+
+            # Set the value
+            current[keys[-1]] = value
+
+            # Save updated config (validation will ensure only valid fields are saved)
+            self.save_config(config)
+            return {
+                "success": True,
+                "message": f"Setting '{key_path}' updated successfully",
+                "data": {"key": key_path, "value": value},
+            }
+        except Exception as e:
+            logger.error(f"Failed to set setting: {str(e)}")
+            raise
+
+    def reset_config(self, confirm: bool = False) -> dict:
+        """Reset configuration to defaults."""
+        try:
+            if not confirm:
+                raise ValueError("Config reset requires explicit confirmation")
+
+            self.save_config(self.default_config)
+            return {
+                "success": True,
+                "message": "Configuration reset to defaults successfully",
+                "data": self.default_config,
+            }
+        except Exception as e:
+            logger.error(f"Failed to reset config: {str(e)}")
+            raise
+
+    def backup_config(self, backup_path: Optional[str] = None) -> dict:
+        """Create a backup of current configuration."""
+        try:
+            if backup_path is None:
+                backup_dir = self.config_dir / "backups"
+                backup_dir.mkdir(exist_ok=True)
+                backup_path = (
+                    backup_dir / f"config_backup_{int(Path().stat().st_ctime)}.json"
+                )
+
+            backup_file = Path(backup_path)
+            backup_file.parent.mkdir(parents=True, exist_ok=True)
+
+            if self.config_file.exists():
+                with (
+                    open(self.config_file) as src,
+                    open(backup_file, "w") as dst,
+                ):
+                    dst.write(src.read())
+
+                return {
+                    "success": True,
+                    "message": "Configuration backed up successfully",
+                    "data": {
+                        "backup_path": str(backup_file),
+                        "original_path": str(self.config_file),
+                    },
+                }
+            else:
+                raise ValueError("No configuration file to backup")
+        except Exception as e:
+            logger.error(f"Failed to backup config: {str(e)}")
+            raise
+
+    def restore_config(self, backup_path: str) -> dict:
+        """Restore configuration from backup."""
+        try:
+            backup_file = Path(backup_path)
+
+            if not backup_file.exists():
+                raise ValueError(f"Backup file '{backup_path}' not found")
+
+            # Try YAML first, then JSON for backward compatibility
+            with open(backup_file) as f:
+                if backup_path.endswith('.yaml') or backup_path.endswith('.yml'):
+                    config = yaml.safe_load(f)
+                else:
+                    # Try YAML first, fall back to JSON if it fails
+                    try:
+                        f.seek(0)
+                        config = yaml.safe_load(f)
+                    except Exception:
+                        import json
+                        f.seek(0)
+                        config = json.load(f)
+
+            self.save_config(config)
+            return {
+                "success": True,
+                "message": "Configuration restored from backup successfully",
+                "data": {"backup_path": backup_path, "config": config},
+            }
+        except Exception as e:
+            logger.error(f"Failed to restore config: {str(e)}")
+            raise
+
+    def list_network_profiles(self) -> dict:
+        """List available network profiles."""
+        try:
+            profiles = {
+                "mainnet": {
+                    "endpoint": "wss://rpc.htcli.io/",
+                    "ws_endpoint": "wss://rpc.htcli.io/",
+                    "chain": "hypertensor",
+                    "ss58_format": 0,
+                },
+                "testnet": {
+                    "endpoint": "wss://testnet-rpc.hypertensor.io",
+                    "ws_endpoint": "wss://testnet-ws.hypertensor.io",
+                    "chain": "hypertensor-testnet",
+                    "ss58_format": 0,
+                },
+                "local": {
+                    "endpoint": "ws://127.0.0.1:9944",
+                    "ws_endpoint": "ws://127.0.0.1:9944",
+                    "chain": "hypertensor-local",
+                    "ss58_format": 0,
+                },
+            }
+
+            return {
+                "success": True,
+                "message": "Network profiles retrieved successfully",
+                "data": profiles,
+            }
+        except Exception as e:
+            logger.error(f"Failed to list network profiles: {str(e)}")
+            raise
+
+    def switch_network(self, profile: str) -> dict:
+        """Switch to a different network profile."""
+        try:
+            profiles_result = self.list_network_profiles()
+            profiles = profiles_result["data"]
+
+            if profile not in profiles:
+                raise ValueError(f"Unknown network profile: {profile}")
+
+            network_config = profiles[profile]
+
+            # Update network settings
+            for key, value in network_config.items():
+                self.set_setting(f"network.{key}", value)
+
+            return {
+                "success": True,
+                "message": f"Switched to {profile} network successfully",
+                "data": {"profile": profile, "network_config": network_config},
+            }
+        except Exception as e:
+            logger.error(f"Failed to switch network: {str(e)}")
+            raise
+
+    def _merge_configs(self, default: dict, user: dict) -> dict:
+        """Recursively merge user config with defaults."""
+        result = default.copy()
+        for key, value in user.items():
+            if (
+                key in result
+                and isinstance(result[key], dict)
+                and isinstance(value, dict)
+            ):
+                result[key] = self._merge_configs(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    def _validate_config(self, config: dict) -> dict:
+        """Validate configuration structure and values.
+
+        Only keeps fields that are in default_config, removing any extra fields.
+        """
+        # Start with default config to ensure only valid fields are present
+        validated_config = {}
+
+        # Only include sections that are in default_config
+        for section_name, default_section in self.default_config.items():
+            if section_name in config:
+                # Only include fields that are in default_config
+                validated_section = {}
+                section_data = config[section_name]
+                for field_name in default_section.keys():
+                    if field_name in section_data:
+                        validated_section[field_name] = section_data[field_name]
+                    else:
+                        # Use default value if field is missing
+                        validated_section[field_name] = default_section[field_name]
+                validated_config[section_name] = validated_section
+            else:
+                # Use default section if section is missing
+                validated_config[section_name] = default_section.copy()
+
+        # Validate network endpoint format
+        endpoint = validated_config.get("network", {}).get("endpoint", "")
+        if endpoint and not (
+            endpoint.startswith("ws://") or endpoint.startswith("wss://")
+        ):
+            raise ValueError("Network endpoint must start with ws:// or wss://")
+
+        return validated_config
+
+
+# --- Client Functions ---
+
+# Default instance for client functions
+_manager = ConfigManager()
+
+
+def get_config_path(config_file: Optional[str] = None) -> Path:
+    """Gets the active configuration file path."""
+    if config_file:
+        return Path(config_file).expanduser()
+    return _manager.config_file
+
+
+def initialize_config(request: ConfigInitRequest) -> dict:
+    """Initializes and saves a new configuration."""
+    path = get_config_path(request.config_file)
+    # Use a temporary manager for non-default paths
+    manager = ConfigManager(path.parent) if request.config_file else _manager
+    # Ensure we write to the exact requested file path (not just default name)
+    if request.config_file:
+        manager.config_file = path
+
+    # Map request fields to the nested config structure
+    new_config = manager.default_config.copy()
+    new_config["network"]["endpoint"] = request.endpoint
+    new_config["network"]["ws_endpoint"] = request.ws_endpoint or request.endpoint
+    new_config["network"]["timeout"] = request.timeout
+    new_config["network"]["retry_attempts"] = request.retry_attempts
+    new_config["wallet"]["path"] = request.wallet_path
+    new_config["wallet"]["default_name"] = request.default_wallet or "default"
+    new_config["wallet"]["encryption_enabled"] = request.encryption_enabled
+    new_config["output"]["format"] = request.output_format
+    new_config["output"]["color"] = request.color
+    new_config["output"]["verbose"] = request.verbose
+
+    result = manager.save_config(new_config)
+
+    return {
+        "config_path": manager.config_file,
+        "created": True,
+        "message": result["message"],
+    }
+
+
+def load_config(request: ConfigShowRequest) -> dict:
+    """Loads configuration from disk."""
+    cfg_path = get_config_path(request.config_file)
+    manager = ConfigManager(cfg_path.parent) if request.config_file else _manager
+    if request.config_file:
+        manager.config_file = cfg_path
+    result = manager.load_config()
+    return {
+        "config_path": manager.config_file,
+        "config_data": result["data"],
+        "exists": result["success"],
+    }
+
+
+def save_config(config: dict, config_file: Optional[str] = None) -> dict:
+    """Saves configuration to disk."""
+    cfg_path = get_config_path(config_file)
+    manager = ConfigManager(cfg_path.parent) if config_file else _manager
+    if config_file:
+        manager.config_file = cfg_path
+    result = manager.save_config(config)
+    return {
+        "config_path": manager.config_file,
+        "message": result["message"],
+    }
+
+
+def set_config_value(request: ConfigSetRequest) -> dict:
+    """Sets a specific configuration value."""
+    cfg_path = get_config_path(request.config_file)
+    manager = ConfigManager(cfg_path.parent) if request.config_file else _manager
+    if request.config_file:
+        manager.config_file = cfg_path
+
+    try:
+        old_value_result = manager.get_setting(request.key)
+        old_value = old_value_result["data"]
+    except KeyError:
+        old_value = None
+
+    # Normalize values for comparison (convert to string, handle None, case-insensitive)
+    def normalize_value(val: Any) -> str:
+        if val is None:
+            return ""
+        # Convert to string and strip whitespace
+        val_str = str(val).strip()
+        # Handle boolean values (both actual bools and string representations)
+        if isinstance(val, bool):
+            return str(val).lower()
+        val_str_lower = val_str.lower()
+        if val_str_lower in ("true", "false"):
+            return val_str_lower
+        # Handle numeric values - normalize to avoid "30" vs "30.0" vs 30 mismatches
+        try:
+            # Try to convert to float first to handle decimals
+            num_val = float(val_str)
+            # If it's a whole number, normalize to int string representation
+            # This handles: 30 == "30" == "30.0" == 30.0
+            if num_val == int(num_val):
+                return str(int(num_val))
+            # For decimals, return the normalized float string
+            return str(num_val)
+        except (ValueError, TypeError):
+            # Not a number, return as lowercase string for case-insensitive comparison
+            return val_str_lower
+
+    old_value_normalized = normalize_value(old_value)
+    new_value_normalized = normalize_value(request.value)
+
+    # Early exit if values are the same
+    if old_value_normalized == new_value_normalized:
+        return {
+            "config_path": manager.config_file,
+            "key": request.key,
+            "old_value": old_value,
+            "new_value": request.value,
+            "message": "No change needed - value is already set to the same value",
+            "unchanged": True,
+        }
+
+    result = manager.set_setting(request.key, request.value)
+
+    return {
+        "config_path": manager.config_file,
+        "key": request.key,
+        "old_value": old_value,
+        "new_value": request.value,
+        "message": result["message"],
+        "unchanged": False,
+    }
+
+
+def get_config_value(request: ConfigGetRequest) -> dict:
+    """Gets a specific configuration value."""
+    cfg_path = get_config_path(request.config_file)
+    manager = ConfigManager(cfg_path.parent) if request.config_file else _manager
+    if request.config_file:
+        manager.config_file = cfg_path
+    result = manager.get_setting(request.key)
+    value = result["data"]
+
+    return {
+        "key": request.key,
+        "value": value,
+        "value_type": str(type(value).__name__),
+    }
+
+
+def validate_config(request: ConfigValidateRequest) -> dict:
+    """Validates the configuration file."""
+    cfg_path = get_config_path(request.config_file)
+    manager = ConfigManager(cfg_path.parent) if request.config_file else _manager
+    if request.config_file:
+        manager.config_file = cfg_path
+    try:
+        config_result = manager.load_config()
+        manager._validate_config(config_result["data"])
+        return {
+            "config_path": manager.config_file,
+            "valid": True,
+            "message": "Configuration is valid.",
+        }
+    except Exception as e:
+        return {
+            "config_path": manager.config_file,
+            "valid": False,
+            "errors": [str(e)],
+            "message": "Configuration validation failed.",
+        }