htcli 1.1.0__py3-none-any.whl

src/htcli/ui/prompts.py

@@ -0,0 +1,870 @@
+"""
+HTCLI interactive prompts and user input handling.
+Provides consistent prompt styles and validation.
+"""
+
+import getpass
+from typing import Any, Callable, Optional, Union
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, FloatPrompt, IntPrompt, Prompt
+from rich.text import Text
+
+from .display import get_console, print_error
+
+
+class HTCLIPrompt:
+    """Enhanced prompt system for HTCLI."""
+
+    def __init__(self, console: Console = None):
+        self.console = console or get_console()
+
+    def text(
+        self,
+        message: str,
+        default: str = None,
+        placeholder: str = None,
+        validator: Callable[[str], bool] = None,
+        error_message: str = "Invalid input. Please try again.",
+        style: str = "htcli.prompt",
+        required: bool = True,
+    ) -> str:
+        """Prompt for text input with validation."""
+        if placeholder and not default:
+            message = f"{message} [{placeholder}]"
+
+        while True:
+            try:
+                result = Prompt.ask(
+                    Text(message, style=style),
+                    default=default,
+                    console=self.console.console,
+                )
+                # Normalize None -> empty string for easier handling
+                value = "" if result is None else str(result)
+
+                # If required, enforce non-empty input
+                if required and not value.strip():
+                    print_error("Input is required.")
+                    continue
+
+                # If optional and empty, return empty string to signal 'keep current'
+                if not required and not value.strip():
+                    return ""
+
+                # Only run validator when user entered a non-empty value
+                if validator and value.strip() and not validator(value):
+                    print_error(error_message)
+                    continue
+
+                return value.strip()
+
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+            except Exception as e:
+                # Don't continue on EOF errors - they should be handled above
+                error_msg = str(e).lower()
+                if "eof" in error_msg or "end of file" in error_msg:
+                    self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                    raise typer.Abort()
+                # Don't loop indefinitely on errors - abort
+                print_error(f"Input error: {str(e)}" if str(e) else "Unknown error")
+                raise typer.Abort()
+
+    def password(
+        self,
+        message: str = "Password",
+        confirm: bool = False,
+        min_length: int = 0,
+        style: str = "htcli.prompt",
+    ) -> str:
+        """Prompt for password input."""
+        while True:
+            try:
+                password = getpass.getpass(prompt=f"{message}: ")
+
+                if min_length > 0 and len(password) < min_length:
+                    print_error(f"Password must be at least {min_length} characters.")
+                    continue
+
+                if confirm:
+                    confirm_password = getpass.getpass(prompt="Confirm password: ")
+                    if password != confirm_password:
+                        print_error("Passwords do not match. Please try again.")
+                        continue
+
+                return password
+
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+
+    def confirm(
+        self,
+        message: str,
+        default: bool = False,
+        style: str = "htcli.prompt",
+    ) -> bool:
+        """Prompt for yes/no confirmation."""
+        try:
+            return Confirm.ask(
+                Text(message, style=style),
+                default=default,
+                console=self.console.console,
+            )
+        except (KeyboardInterrupt, EOFError):
+            self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+            raise
+
+    def select(
+        self,
+        message: str,
+        choices: list[Union[str, tuple]],
+        default: Any = None,
+        style: str = "htcli.prompt",
+        show_choices: bool = True,
+    ) -> str:
+        """Prompt for selection from a list of choices."""
+        # Convert choices to a consistent format
+        choice_map = {}
+        display_choices = []
+
+        for i, choice in enumerate(choices):
+            if isinstance(choice, tuple):
+                key, display, value = (
+                    choice if len(choice) == 3 else (*choice, choice[0])
+                )
+            else:
+                key = display = value = choice
+
+            choice_map[str(i + 1)] = value
+            choice_map[key.lower()] = value
+            display_choices.append(
+                f"[htcli.value]{i + 1}[/]. [htcli.highlight]{display}[/]"
+            )
+
+        if show_choices:
+            self.console.print("\n[htcli.subtitle]Available options:[/]")
+            for choice in display_choices:
+                self.console.print(f"  {choice}")
+            self.console.print()
+
+        while True:
+            try:
+                result = self.text(
+                    message,
+                    default=str(default) if default else None,
+                    required=True,
+                    style=style,
+                )
+
+                # Try to match the input
+                if result in choice_map:
+                    return choice_map[result]
+                elif result.lower() in choice_map:
+                    return choice_map[result.lower()]
+                else:
+                    print_error(
+                        "Invalid selection. Please choose from the available options."
+                    )
+                    continue
+
+            except typer.Abort:
+                # Re-raise typer.Abort to let it propagate
+                raise
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+            except Exception as e:
+                # Don't continue on EOF errors - they should be handled above
+                error_msg = str(e).lower()
+                if "eof" in error_msg or "end of file" in error_msg:
+                    self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                    raise typer.Abort()
+                # Check if it's a cancellation error from typer
+                if isinstance(e, typer.Abort):
+                    raise
+                print_error(f"Selection error: {str(e)}")
+                continue
+
+    def integer(
+        self,
+        message: str,
+        default: int = None,
+        min_value: int = None,
+        max_value: int = None,
+        style: str = "htcli.prompt",
+        allow_none: bool = False,
+    ) -> Optional[int]:
+        """Prompt for integer input with validation.
+        
+        Args:
+            message: Prompt message
+            default: Default value
+            min_value: Minimum allowed value
+            max_value: Maximum allowed value
+            style: Prompt style
+            allow_none: If True, allow empty input and return None
+            
+        Returns:
+            int if input provided, Optional[int] (None) if allow_none=True and input is empty
+        """
+        while True:
+            try:
+                result = IntPrompt.ask(
+                    Text(message, style=style),
+                    default=default,
+                    console=self.console.console,
+                )
+
+                # Handle None result (empty input)
+                if result is None:
+                    if allow_none:
+                        return None
+                    print_error("Input is required. Please enter a valid integer.")
+                    continue
+
+                if min_value is not None and result < min_value:
+                    print_error(f"Value must be at least {min_value}.")
+                    continue
+
+                if max_value is not None and result > max_value:
+                    print_error(f"Value must be at most {max_value}.")
+                    continue
+
+                return result
+
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+            except Exception as e:
+                print_error(f"Input error: {str(e)}" if str(e) else "Unknown error")
+                raise typer.Abort()
+
+    # Backwards-compatibility helpers (legacy code still calls these)
+    def integer_prompt(
+        self,
+        message: str,
+        default: int = None,
+        min_value: int = None,
+        max_value: int = None,
+        style: str = "htcli.prompt",
+        allow_none: bool = False,
+    ) -> Optional[int]:
+        """Alias for `integer` to support existing prompt usage."""
+        return self.integer(
+            message,
+            default=default,
+            min_value=min_value,
+            max_value=max_value,
+            style=style,
+            allow_none=allow_none,
+        )
+
+    def text_prompt(
+        self,
+        message: str,
+        default: str = None,
+        placeholder: str = None,
+        validator: Callable[[str], bool] = None,
+        error_message: str = "Invalid input. Please try again.",
+        style: str = "htcli.prompt",
+        required: bool = True,
+    ) -> str:
+        """Alias for `text` to support existing prompt usage."""
+        return self.text(
+            message,
+            default=default,
+            placeholder=placeholder,
+            validator=validator,
+            error_message=error_message,
+            style=style,
+            required=required,
+        )
+
+    def float(
+        self,
+        message: str,
+        default: float = None,
+        min_value: float = None,
+        max_value: float = None,
+        style: str = "htcli.prompt",
+    ) -> float:
+        """Prompt for float input with validation."""
+        while True:
+            try:
+                result = FloatPrompt.ask(
+                    Text(message, style=style),
+                    default=default,
+                    console=self.console.console,
+                )
+
+                if result is None:
+                    if default is not None:
+                        result = default
+                    else:
+                        print_error("Value is required.")
+                        continue
+
+                if min_value is not None and result < min_value:
+                    print_error(f"Value must be at least {min_value}.")
+                    continue
+
+                if max_value is not None and result > max_value:
+                    print_error(f"Value must be at most {max_value}.")
+                    continue
+
+                return result
+
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+            except Exception as e:
+                print_error(f"Input error: {str(e)}" if str(e) else "Unknown error")
+                raise typer.Abort()
+
+    def address(
+        self,
+        message: str = "Enter blockchain address",
+        default: str = None,
+        allow_empty: bool = False,
+        style: str = "htcli.prompt",
+    ) -> str:
+        """Prompt for blockchain address with validation."""
+
+        def validate_address(addr: str) -> bool:
+            if not addr and allow_empty:
+                return True
+            # Basic validation - can be enhanced
+            if len(addr) < 20:
+                return False
+            if addr.startswith("0x") and len(addr) == 42:
+                return True  # EVM address
+            if len(addr) in [47, 48] and addr.startswith("5"):
+                return True  # Substrate address
+            return False
+
+        return self.text(
+            message,
+            default=default,
+            validator=validate_address,
+            error_message="Invalid blockchain address format.",
+            style=style,
+            required=not allow_empty,
+        )
+
+    def amount(
+        self,
+        message: str = "Enter amount",
+        currency: str = "TENSOR",
+        min_amount: float = 0.0,
+        max_amount: float = None,
+        default: float = None,
+        decimals: int = 6,
+        style: str = "htcli.prompt",
+    ) -> float:
+        """Prompt for token amount with validation."""
+        full_message = f"{message} ({currency})"
+
+        return self.float(
+            full_message,
+            default=default,
+            min_value=min_amount,
+            max_value=max_amount,
+            style=style,
+        )
+
+    def wallet_selection(
+        self,
+        wallets: list[dict[str, Any]],
+        message: str = "Select wallet",
+        style: str = "htcli.prompt",
+    ) -> dict[str, Any]:
+        """Prompt for wallet selection from available wallets."""
+        if not wallets:
+            raise ValueError("No wallets available for selection.")
+
+        choices = []
+        for i, wallet in enumerate(wallets):
+            name = wallet.get("name", f"Wallet {i + 1}")
+            address = wallet.get("address", "Unknown")
+            display_addr = (
+                f"{address[:8]}...{address[-8:]}" if len(address) > 16 else address
+            )
+            choices.append((str(i + 1), f"{name} ({display_addr})", wallet))
+
+        self.console.print("\n[htcli.subtitle]Available wallets:[/]")
+        for i, wallet in enumerate(wallets):
+            name = wallet.get("name", f"Wallet {i + 1}")
+            address = wallet.get("address", "Unknown")
+            balance = wallet.get("balance", "Unknown")
+            self.console.print(
+                f"  [htcli.value]{i + 1}[/]. [htcli.highlight]{name}[/] "
+                f"([htcli.address]{address[:8]}...{address[-8:]}[/]) "
+                f"- [htcli.amount]{balance} TENSOR[/]"
+            )
+        self.console.print()
+
+        while True:
+            try:
+                selection = self.integer(
+                    message,
+                    min_value=1,
+                    max_value=len(wallets),
+                    style=style,
+                )
+                return wallets[selection - 1]
+
+            except (KeyboardInterrupt, EOFError):
+                self.console.print("\n[htcli.warning]Operation cancelled.[/]")
+                raise typer.Abort()
+
+    def confirmation_panel(
+        self,
+        title: str,
+        details: dict[str, Any],
+        warning: str = None,
+        require_confirmation: bool = True,
+    ) -> bool:
+        """Show a confirmation panel with transaction details."""
+        # Create content for the panel
+        content = []
+        for key, value in details.items():
+            if key.lower() in ["amount", "balance", "stake"]:
+                formatted_value = f"[htcli.amount]{value}[/]"
+            elif key.lower() in ["address", "to", "from", "account"]:
+                formatted_value = f"[htcli.address]{value}[/]"
+            elif key.lower() in ["fee", "gas"]:
+                formatted_value = f"[htcli.fee]{value}[/]"
+            else:
+                formatted_value = f"[htcli.value]{value}[/]"
+
+            content.append(f"[htcli.subtitle]{key}:[/] {formatted_value}")
+
+        panel_content = "\n".join(content)
+
+        if warning:
+            panel_content += f"\n\n[htcli.warning]⚠️ {warning}[/]"
+
+        # Display the confirmation panel
+        panel = Panel(
+            panel_content,
+            title=f"[htcli.title]{title}[/]",
+            border_style="htcli.primary",
+            padding=(1, 2),
+        )
+        self.console.console.print(panel)
+
+        if not require_confirmation:
+            return True
+
+        return self.confirm(
+            "\nProceed with this transaction?",
+            default=False,
+        )
+
+
+# Global prompt instance
+_prompt = HTCLIPrompt()
+
+
+# Convenience functions
+def text_prompt(
+    message: str, default: str = None, validator: Callable[[str], bool] = None, **kwargs
+) -> str:
+    """Quick text prompt."""
+    return _prompt.text(message, default=default, validator=validator, **kwargs)
+
+
+def password_prompt(
+    message: str = "Password",
+    confirm: bool = False,
+    min_length: int = 8,
+) -> str:
+    """Quick password prompt."""
+    return _prompt.password(message, confirm=confirm, min_length=min_length)
+
+
+def confirm_prompt(message: str, default: bool = False) -> bool:
+    """Quick confirmation prompt."""
+    return _prompt.confirm(message, default=default)
+
+
+def integer_prompt(
+    message: str,
+    default: int = None,
+    min_value: int = None,
+    max_value: int = None,
+    allow_none: bool = False,
+) -> Optional[int]:
+    """Quick integer prompt.
+    
+    Args:
+        message: Prompt message
+        default: Default value
+        min_value: Minimum allowed value
+        max_value: Maximum allowed value
+        allow_none: If True, allow empty input and return None
+    """
+    return _prompt.integer(
+        message,
+        default=default,
+        min_value=min_value,
+        max_value=max_value,
+        allow_none=allow_none,
+    )
+
+
+def select_prompt(
+    message: str,
+    choices: list[Union[str, tuple]],
+    default: Any = None,
+) -> str:
+    """Quick selection prompt."""
+    return _prompt.select(message, choices, default=default)
+
+
+def amount_prompt(
+    message: str = "Enter amount",
+    currency: str = "TENSOR",
+    min_amount: float = 0.0,
+    max_amount: float = None,
+    default: float = None,
+) -> float:
+    """Quick amount prompt."""
+    return _prompt.amount(message, currency, min_amount, max_amount, default=default)
+
+
+def address_prompt(
+    message: str = "Enter blockchain address",
+    default: str = None,
+    allow_empty: bool = False,
+) -> str:
+    """Quick address prompt."""
+    return _prompt.address(message, default=default, allow_empty=allow_empty)
+
+
+def wallet_selection_prompt(
+    wallets: list[dict[str, Any]],
+    message: str = "Select wallet",
+) -> dict[str, Any]:
+    """Quick wallet selection prompt."""
+    return _prompt.wallet_selection(wallets, message)
+
+
+def confirmation_panel_prompt(
+    title: str,
+    details: dict[str, Any],
+    warning: str = None,
+    require_confirmation: bool = True,
+) -> bool:
+    """Quick confirmation panel prompt."""
+    return _prompt.confirmation_panel(title, details, warning, require_confirmation)
+
+
+# Additional utility functions for complex prompting scenarios
+def prompt_with_validation(
+    param_name: str,
+    provided_value: Optional[Any],
+    param_type: type,
+    validator: Optional[Callable[[Any], tuple[bool, Optional[str]]]] = None,
+    prompt_func: Optional[Callable] = None,
+    **prompt_kwargs
+) -> Any:
+    """
+    Helper function that validates provided value and prompts if invalid or None.
+    
+    Args:
+        param_name: Name of the parameter
+        provided_value: Value provided via CLI (may be None)
+        param_type: Expected type (str, int, float, bool)
+        validator: Optional validation function that returns (bool, Optional[str])
+        prompt_func: Function to call for prompting (defaults to prompt_for_required)
+        **prompt_kwargs: Additional arguments to pass to prompt function
+        
+    Returns:
+        Validated value from provided_value or from interactive prompt
+    """
+    # Validate provided value if it exists
+    if provided_value is not None and validator:
+        is_valid, error_msg = validator(provided_value)
+        if not is_valid:
+            print_error(f"Invalid {param_name}: {error_msg}")
+            provided_value = None  # Force interactive prompt
+    
+    # Prompt if None (either originally or after failed validation)
+    if provided_value is None:
+        if prompt_func:
+            return prompt_func(param_name, param_type=param_type, **prompt_kwargs)
+        else:
+            # Default to prompt_for_required
+            return prompt_for_required(
+                param_name, param_type=param_type, **prompt_kwargs
+            )
+    
+    return provided_value
+
+
+def prompt_for_required(
+    param_name: str,
+    param_type: type,
+    help_text: str = "",
+    validator: Optional[Callable] = None,
+    default: Optional[Any] = None,
+    allow_empty: bool = False,
+    provided_value: Optional[Any] = None,
+) -> Any:
+    """
+    Prompt user for a required parameter value.
+    
+    If provided_value is given and validator is provided, validates it first.
+    If validation fails, prompts interactively.
+
+    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 (returns bool or (bool, Optional[str]))
+        default: Default value to suggest
+        allow_empty: Whether empty values are allowed
+        provided_value: Value provided via CLI (validated if validator is provided)
+
+    Returns:
+        The user input converted to the specified type
+    """
+    # Validate provided value if it exists
+    if provided_value is not None and validator:
+        try:
+            result = validator(provided_value)
+            # Handle both bool and tuple return types
+            if isinstance(result, tuple):
+                is_valid, error_msg = result
+                if not is_valid:
+                    error_display = error_msg if error_msg else f"Invalid {param_name}: {provided_value}"
+                    print_error(f"Invalid {param_name}: {error_display}")
+                    provided_value = None  # Force interactive prompt
+            else:
+                # Boolean return type
+                if not result:
+                    print_error(f"Invalid {param_name}: {provided_value}")
+                    provided_value = None  # Force interactive prompt
+        except Exception as e:
+            print_error(f"Validation error for {param_name}: {str(e)}")
+            provided_value = None  # Force interactive prompt
+    
+    # If we have a valid provided value, return it
+    if provided_value is not None:
+        return provided_value
+    
+    while True:
+        # Build the prompt text
+        prompt_text = param_name
+        if help_text:
+            prompt_text += f" ({help_text})"
+
+        try:
+            if param_type == str:
+                result = _prompt.text(
+                    prompt_text,
+                    default=str(default) if default is not None else None,
+                    validator=validator,
+                    required=not allow_empty,
+                )
+                return result if result else (None if allow_empty else "")
+            elif param_type == int:
+                return _prompt.integer(
+                    prompt_text,
+                    default=default,
+                )
+            elif param_type == float:
+                return _prompt.float(
+                    prompt_text,
+                    default=default,
+                )
+            elif param_type == bool:
+                return _prompt.confirm(
+                    prompt_text,
+                    default=default if default is not None else False,
+                )
+            else:
+                result = _prompt.text(
+                    prompt_text,
+                    default=str(default) if default is not None else None,
+                    validator=validator,
+                    required=not allow_empty,
+                )
+                return result
+        except (KeyboardInterrupt, EOFError, typer.Abort):
+            # Re-raise cancellation exceptions to properly exit
+            raise
+        except Exception as e:
+            print_error(f"Input error: {str(e)}")
+            continue
+
+
+def prompt_for_optional(
+    param_name: str,
+    param_type: type,
+    help_text: str = "",
+    validator: Optional[Callable] = None,
+    default: Optional[Any] = None,
+    provided_value: Optional[Any] = None,
+) -> Optional[Any]:
+    """
+    Prompt user for an optional parameter value.
+    
+    If provided_value is given and validator is provided, validates it first.
+    If validation fails, prompts interactively.
+
+    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 (returns bool or (bool, Optional[str]))
+        default: Default value to suggest
+        provided_value: Value provided via CLI (validated if validator is provided)
+
+    Returns:
+        The user input converted to the specified type, or None if skipped
+    """
+    # Validate provided value if it exists
+    if provided_value is not None and validator:
+        try:
+            result = validator(provided_value)
+            # Handle both bool and tuple return types
+            if isinstance(result, tuple):
+                is_valid, error_msg = result
+                if not is_valid:
+                    error_display = error_msg if error_msg else f"Invalid {param_name}: {provided_value}"
+                    print_error(f"Invalid {param_name}: {error_display}")
+                    provided_value = None  # Force interactive prompt
+            else:
+                # Boolean return type
+                if not result:
+                    print_error(f"Invalid {param_name}: {provided_value}")
+                    provided_value = None  # Force interactive prompt
+        except Exception as e:
+            print_error(f"Validation error for {param_name}: {str(e)}")
+            provided_value = None  # Force interactive prompt
+    
+    # If we have a valid provided value, return it
+    if provided_value is not None:
+        return provided_value
+    
+    prompt_text = f"{param_name} (optional)"
+    if help_text:
+        prompt_text += f" ({help_text})"
+
+    try:
+        if param_type == str:
+            result = _prompt.text(
+                prompt_text,
+                default=str(default) if default is not None else None,
+                required=False,
+            )
+            return result if result and result.strip() else None
+        elif param_type == int:
+            return _prompt.integer(
+                prompt_text,
+                default=default,
+            )
+        elif param_type == float:
+            return _prompt.float(
+                prompt_text,
+                default=default,
+            )
+        elif param_type == bool:
+            return _prompt.confirm(
+                prompt_text,
+                default=default if default is not None else False,
+            )
+        else:
+            result = _prompt.text(
+                prompt_text,
+                default=str(default) if default is not None else None,
+                required=False,
+            )
+            return result if result.strip() else None
+    except (KeyboardInterrupt, EOFError, typer.Abort):
+        # Re-raise cancellation exceptions to properly exit
+        raise
+    except Exception:
+        return None
+
+
+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
+    """
+    prompt_text = param_name
+    if help_text:
+        prompt_text += f" ({help_text})"
+    prompt_text += f" (separate with '{separator}')"
+
+    while True:
+        try:
+            user_input = _prompt.text(
+                prompt_text,
+                default=default,
+                required=True,
+            )
+
+            # Split the input
+            items = [
+                item.strip() for item in user_input.split(separator) if item.strip()
+            ]
+
+            if not items:
+                print_error("No valid items found. Please provide at least one value.")
+                continue
+
+            # Validate individual items if validator provided
+            if validator:
+                invalid_items = [item for item in items if not validator(item)]
+                if invalid_items:
+                    print_error(f"Invalid items: {', '.join(invalid_items)}")
+                    continue
+
+            return items
+        except (KeyboardInterrupt, EOFError, typer.Abort):
+            # Re-raise cancellation exceptions to properly exit
+            raise
+        except Exception as e:
+            print_error(f"Input error: {str(e)}")
+            continue
+
+
+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 _prompt.confirm(message, default=default)