htcli 1.1.0__py3-none-any.whl

src/htcli/utils/legacy/interactive.py

@@ -0,0 +1,306 @@
+"""
+Interactive prompting utilities for CLI commands.
+"""
+
+import re
+from typing import Any, Callable, Optional
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+console = Console()
+
+
+def prompt_for_required(
+    param_name: str,
+    param_type: type,
+    help_text: str,
+    validator: Optional[Callable[[Any], bool]] = None,
+    default: Optional[Any] = None,
+    allow_empty: bool = False,
+) -> Any:
+    """
+    Prompt user for a required parameter value.
+
+    Args:
+        param_name: Name of the parameter
+        param_type: Expected type (str, int, float, bool)
+        help_text: Help text to display
+        validator: Optional validation function
+        default: Default value to suggest
+        allow_empty: Whether empty values are allowed
+
+    Returns:
+        The user input converted to the specified type
+    """
+    while True:
+        # Build the prompt text
+        prompt_text = f"{param_name}"
+        if help_text:
+            prompt_text += f" ({help_text})"
+        if default is not None:
+            prompt_text += f" (default: {default})"
+        prompt_text += ": "
+
+        # Get user input
+        # Convert default to string for Prompt.ask
+        default_str = str(default) if default is not None else ""
+        user_input = Prompt.ask(prompt_text, default=default_str)
+
+        # Handle empty input
+        if not user_input.strip() and not allow_empty:
+            console.print(
+                "[red]❌ This field is required. Please provide a value.[/red]"
+            )
+            continue
+
+        if not user_input.strip() and allow_empty:
+            return None if param_type != str else ""
+
+        # Convert to the correct type
+        try:
+            if param_type == str:
+                converted_value = user_input.strip()
+            elif param_type == int:
+                converted_value = int(user_input.strip())
+            elif param_type == float:
+                converted_value = float(user_input.strip())
+            elif param_type == bool:
+                converted_value = user_input.strip().lower() in (
+                    "true",
+                    "yes",
+                    "y",
+                    "1",
+                )
+            else:
+                converted_value = user_input.strip()
+        except ValueError:
+            console.print(
+                f"[red]❌ Invalid {param_type.__name__} value. Please try again.[/red]"
+            )
+            continue
+
+        # Run validation if provided
+        if validator and not validator(converted_value):
+            continue
+
+        return converted_value
+
+
+def prompt_for_optional(
+    param_name: str,
+    param_type: type,
+    help_text: str,
+    validator: Optional[Callable[[Any], bool]] = None,
+    default: Optional[Any] = None,
+) -> Optional[Any]:
+    """
+    Prompt user for an optional parameter value.
+
+    Args:
+        param_name: Name of the parameter
+        param_type: Expected type (str, int, float, bool)
+        help_text: Help text to display
+        validator: Optional validation function
+        default: Default value to suggest
+
+    Returns:
+        The user input converted to the specified type, or None if skipped
+    """
+    # Build the prompt text
+    prompt_text = f"{param_name} (optional)"
+    if help_text:
+        prompt_text += f" ({help_text})"
+    if default is not None:
+        prompt_text += f" (default: {default})"
+    prompt_text += ": "
+
+    # Get user input
+    # Convert default to string for Prompt.ask
+    default_str = str(default) if default is not None else ""
+    user_input = Prompt.ask(prompt_text, default=default_str)
+
+    # Handle empty input (skip optional parameter)
+    if not user_input.strip():
+        return None
+
+    # Convert to the correct type
+    try:
+        if param_type == str:
+            converted_value = user_input.strip()
+        elif param_type == int:
+            converted_value = int(user_input.strip())
+        elif param_type == float:
+            converted_value = float(user_input.strip())
+        elif param_type == bool:
+            converted_value = user_input.strip().lower() in ("true", "yes", "y", "1")
+        else:
+            converted_value = user_input.strip()
+    except ValueError:
+        console.print(
+            f"[red]❌ Invalid {param_type.__name__} value. Please try again.[/red]"
+        )
+        return prompt_for_optional(
+            param_name, param_type, help_text, validator, default
+        )
+
+    # Run validation if provided
+    if validator and not validator(converted_value):
+        return prompt_for_optional(
+            param_name, param_type, help_text, validator, default
+        )
+
+    return converted_value
+
+
+def prompt_for_list(
+    param_name: str,
+    help_text: str,
+    separator: str = ",",
+    validator: Optional[Callable[[Any], bool]] = None,
+    default: Optional[str] = None,
+) -> list[str]:
+    """
+    Prompt user for a list of values.
+
+    Args:
+        param_name: Name of the parameter
+        help_text: Help text to display
+        separator: Character to separate list items
+        validator: Optional validation function for individual items
+        default: Default value to suggest
+
+    Returns:
+        List of user input values
+    """
+    while True:
+        # Build the prompt text
+        prompt_text = f"{param_name}"
+        if help_text:
+            prompt_text += f" ({help_text})"
+        if default is not None:
+            prompt_text += f" (default: {default})"
+        prompt_text += ": "
+
+        # Get user input
+        user_input = Prompt.ask(
+            prompt_text, default=default if default is not None else ""
+        )
+
+        # Handle empty input
+        if not user_input.strip():
+            console.print(
+                "[red]❌ This field is required. Please provide at least one value.[/red]"
+            )
+            continue
+
+        # Split the input
+        items = [item.strip() for item in user_input.split(separator) if item.strip()]
+
+        if not items:
+            console.print(
+                "[red]❌ No valid items found. Please provide at least one value.[/red]"
+            )
+            continue
+
+        # Validate individual items if validator provided
+        if validator:
+            invalid_items = [item for item in items if not validator(item)]
+            if invalid_items:
+                console.print(
+                    f"[red]❌ Invalid items: {', '.join(invalid_items)}[/red]"
+                )
+                continue
+
+        return items
+
+
+def prompt_for_confirmation(
+    message: str,
+    default: bool = False,
+) -> bool:
+    """
+    Prompt user for confirmation.
+
+    Args:
+        message: Message to display
+        default: Default value
+
+    Returns:
+        True if user confirms, False otherwise
+    """
+    return Confirm.ask(message, default=default)
+
+
+def validate_url(url: str) -> bool:
+    """Validate URL format."""
+    url_pattern = re.compile(
+        r"^https?://"  # http:// or https://
+        r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|"  # domain...
+        r"localhost|"  # localhost...
+        r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"  # ...or ip
+        r"(?::\d+)?"  # optional port
+        r"(?:/?|[/?]\S+)$",
+        re.IGNORECASE,
+    )
+    return bool(url_pattern.match(url))
+
+
+def validate_positive_int(value: int) -> bool:
+    """Validate that value is a positive integer."""
+    return isinstance(value, int) and value > 0
+
+
+def validate_percentage(value: int) -> bool:
+    """Validate that value is a percentage (0-100)."""
+    return isinstance(value, int) and 0 <= value <= 100
+
+
+def validate_stake_amount(value: int) -> bool:
+    """Validate stake amount."""
+    return isinstance(value, int) and value > 0
+
+
+def validate_epoch_value(value: int) -> bool:
+    """Validate epoch value."""
+    return isinstance(value, int) and 0 <= value <= 1_000_000
+
+
+def validate_churn_limit(value: int) -> bool:
+    """Validate churn limit."""
+    return isinstance(value, int) and 1 <= value <= 1000
+
+
+def validate_max_penalties(value: int) -> bool:
+    """Validate max penalties."""
+    return isinstance(value, int) and 1 <= value <= 100
+
+
+def validate_max_nodes(value: int) -> bool:
+    """Validate max nodes."""
+    return isinstance(value, int) and 1 <= value <= 10_000
+
+
+def validate_subnet_name(name: str) -> bool:
+    """Validate subnet name."""
+    if not name or len(name) > 50:
+        return False
+    # Allow alphanumeric, hyphens, underscores, and spaces
+    return bool(re.match(r"^[a-zA-Z0-9\-\_\s]+$", name))
+
+
+def validate_subnet_description(description: str) -> bool:
+    """Validate subnet description."""
+    return 10 <= len(description) <= 1000
+
+
+def validate_key_types(key_types: list[str]) -> bool:
+    """Validate key types."""
+    valid_types = {"RSA", "Ed25519", "Secp256k1", "ECDSA"}
+    return all(kt.strip() in valid_types for kt in key_types)
+
+
+def validate_coldkey_address(address: str) -> bool:
+    """Validate coldkey address format."""
+    # Basic SS58 format validation
+    return bool(re.match(r"^[1-9A-HJ-NP-Za-km-z]{32,}$", address))

src/htcli/utils/legacy/subnet_manifest.py

@@ -0,0 +1,265 @@
+"""
+Subnet manifest management for tracking locally registered subnets.
+"""
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SubnetManifestEntry(BaseModel):
+    """Model for a subnet entry in the manifest."""
+
+    subnet_id: Optional[int] = Field(
+        None, description="Subnet ID from blockchain (set after confirmation)"
+    )
+    name: str = Field(..., description="Subnet name")
+    repo: str = Field(..., description="Repository URL")
+    description: str = Field(..., description="Subnet description")
+    owner_wallet: str = Field(..., description="Wallet used to register the subnet")
+    owner_address: str = Field(..., description="Owner's blockchain address")
+    transaction_hash: str = Field(..., description="Registration transaction hash")
+    block_number: Optional[int] = Field(
+        None, description="Block number of registration"
+    )
+    registration_time: str = Field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+
+    # Subnet parameters
+    min_stake: int = Field(..., description="Minimum stake amount")
+    max_stake: int = Field(..., description="Maximum stake amount")
+    delegate_percentage: int = Field(..., description="Delegate stake percentage")
+    churn_limit: int = Field(..., description="Churn limit")
+    queue_epochs: int = Field(..., description="Registration queue epochs")
+    grace_epochs: int = Field(..., description="Activation grace epochs")
+    queue_classification_epochs: int = Field(
+        ..., description="Queue classification epochs"
+    )
+    included_classification_epochs: int = Field(
+        ..., description="Included classification epochs"
+    )
+    max_penalties: int = Field(..., description="Maximum node penalties")
+    max_nodes: int = Field(..., description="Maximum registered nodes")
+    hotkey: str = Field(..., description="Hotkey address")
+    initial_coldkeys: Optional[str] = Field(
+        None, description="Comma-separated initial coldkeys"
+    )
+    misc: Optional[str] = Field("", description="Miscellaneous information")
+
+    # Status tracking
+    status: str = Field(
+        "pending", description="Status: pending, registered, activated, paused, removed"
+    )
+    confirmed: bool = Field(
+        False, description="Whether registration is confirmed on chain"
+    )
+    last_updated: str = Field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+
+
+class SubnetManifest(BaseModel):
+    """Model for the complete subnet manifest."""
+
+    version: str = Field("1.0", description="Manifest format version")
+    created: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    last_updated: str = Field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    subnets: dict[str, SubnetManifestEntry] = Field(
+        default_factory=dict, description="Subnets by registration tx hash"
+    )
+
+
+def get_subnet_registry_path() -> Path:
+    """Get the path to the subnet registry file."""
+    subnet_dir = Path.home() / ".hypertensor" / "subnets"
+    subnet_dir.mkdir(parents=True, exist_ok=True)
+    return subnet_dir / "subnets.json"
+
+
+def load_subnet_registry() -> SubnetManifest:
+    """Load the subnet registry from disk."""
+    registry_path = get_subnet_registry_path()
+
+    if registry_path.exists():
+        try:
+            with open(registry_path, encoding="utf-8") as f:
+                data = json.load(f)
+            return SubnetManifest(**data)
+        except Exception as e:
+            print(f"⚠️ Warning: Failed to load subnet registry: {e}")
+            print("Creating new registry...")
+
+    return SubnetManifest()
+
+
+def save_subnet_registry(registry: SubnetManifest) -> bool:
+    """Save the subnet registry to disk."""
+    try:
+        registry_path = get_subnet_registry_path()
+        registry.last_updated = datetime.now(timezone.utc).isoformat()
+
+        with open(registry_path, "w", encoding="utf-8") as f:
+            json.dump(registry.dict(), f, indent=2, ensure_ascii=False)
+
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save subnet registry: {e}")
+        return False
+
+
+def add_subnet_to_registry(
+    name: str,
+    repo: str,
+    description: str,
+    owner_wallet: str,
+    owner_address: str,
+    transaction_hash: str,
+    block_number: Optional[int],
+    subnet_params: dict,
+) -> bool:
+    """Add a new subnet registration to the registry."""
+    try:
+        registry = load_subnet_registry()
+
+        # Create subnet entry
+        entry = SubnetManifestEntry(
+            name=name,
+            repo=repo,
+            description=description,
+            owner_wallet=owner_wallet,
+            owner_address=owner_address,
+            transaction_hash=transaction_hash,
+            block_number=block_number,
+            **subnet_params,
+        )
+
+        # Add to registry using transaction hash as key
+        registry.subnets[transaction_hash] = entry
+
+        return save_subnet_registry(registry)
+    except Exception as e:
+        print(f"❌ Failed to add subnet to registry: {e}")
+        return False
+
+
+def update_subnet_status(
+    transaction_hash: str, status: str, subnet_id: Optional[int] = None
+) -> bool:
+    """Update the status of a subnet in the registry."""
+    try:
+        registry = load_subnet_registry()
+
+        if transaction_hash in registry.subnets:
+            registry.subnets[transaction_hash].status = status
+            registry.subnets[transaction_hash].last_updated = datetime.now(
+                timezone.utc
+            ).isoformat()
+
+            if subnet_id is not None:
+                registry.subnets[transaction_hash].subnet_id = subnet_id
+                registry.subnets[transaction_hash].confirmed = True
+
+            return save_subnet_registry(registry)
+        else:
+            print(
+                f"⚠️ Subnet with transaction hash {transaction_hash} not found in registry"
+            )
+            return False
+    except Exception as e:
+        print(f"❌ Failed to update subnet status: {e}")
+        return False
+
+
+def get_user_subnets(owner_address: Optional[str] = None) -> list[SubnetManifestEntry]:
+    """Get subnets owned by a specific address or all subnets."""
+    try:
+        registry = load_subnet_registry()
+        subnets = list(registry.subnets.values())
+
+        if owner_address:
+            subnets = [s for s in subnets if s.owner_address == owner_address]
+
+        # Sort by registration time (newest first)
+        subnets.sort(key=lambda x: x.registration_time, reverse=True)
+        return subnets
+    except Exception as e:
+        print(f"❌ Failed to get user subnets: {e}")
+        return []
+
+
+def find_subnet_by_name(name: str) -> Optional[SubnetManifestEntry]:
+    """Find a subnet by name."""
+    try:
+        registry = load_subnet_registry()
+        for subnet in registry.subnets.values():
+            if subnet.name == name:
+                return subnet
+        return None
+    except Exception as e:
+        print(f"❌ Failed to find subnet by name: {e}")
+        return None
+
+
+def find_subnet_by_id(subnet_id: int) -> Optional[SubnetManifestEntry]:
+    """Find a subnet by its blockchain ID."""
+    try:
+        registry = load_subnet_registry()
+        for subnet in registry.subnets.values():
+            if subnet.subnet_id == subnet_id:
+                return subnet
+        return None
+    except Exception as e:
+        print(f"❌ Failed to find subnet by ID: {e}")
+        return None
+
+
+def remove_subnet_from_registry(transaction_hash: str) -> bool:
+    """Remove a subnet from the registry."""
+    try:
+        registry = load_subnet_registry()
+
+        if transaction_hash in registry.subnets:
+            del registry.subnets[transaction_hash]
+            return save_subnet_registry(registry)
+        else:
+            print(
+                f"⚠️ Subnet with transaction hash {transaction_hash} not found in registry"
+            )
+            return False
+    except Exception as e:
+        print(f"❌ Failed to remove subnet from registry: {e}")
+        return False
+
+
+def get_registry_stats() -> dict:
+    """Get statistics about the subnets in the registry."""
+    try:
+        registry = load_subnet_registry()
+        subnets = list(registry.subnets.values())
+
+        total = len(subnets)
+        pending = len([s for s in subnets if s.status == "pending"])
+        registered = len([s for s in subnets if s.status == "registered"])
+        activated = len([s for s in subnets if s.status == "activated"])
+        paused = len([s for s in subnets if s.status == "paused"])
+        removed = len([s for s in subnets if s.status == "removed"])
+
+        return {
+            "total": total,
+            "pending": pending,
+            "registered": registered,
+            "activated": activated,
+            "paused": paused,
+            "removed": removed,
+            "confirmed": len([s for s in subnets if s.confirmed]),
+            "unconfirmed": len([s for s in subnets if not s.confirmed]),
+        }
+    except Exception as e:
+        print(f"❌ Failed to get registry stats: {e}")
+        return {}