htcli 1.1.0__py3-none-any.whl

src/htcli/ui/components/panels.py

@@ -0,0 +1,174 @@
+"""
+HTCLI panel components.
+Provides enhanced panels for content display.
+"""
+
+from typing import Any, Optional
+
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+
+from ..colors import HTCLIColors
+from ..display import get_console
+
+
+class HTCLIPanel:
+    """Enhanced panel for HTCLI operations."""
+
+    def __init__(
+        self,
+        content: Any,
+        title: str = None,
+        border_style: str = "htcli.panel.border",
+        padding: tuple = (1, 2),
+        expand: bool = True,
+        highlight: bool = False,
+    ):
+        self.panel = Panel(
+            content,
+            title=title,
+            border_style=border_style,
+            padding=padding,
+            expand=expand,
+            highlight=highlight,
+        )
+
+    @classmethod
+    def info_panel(cls, content: Any, title: str = "ℹ️ Information"):
+        """Create an info panel."""
+        return cls(
+            content,
+            title=title,
+            border_style="blue",
+            padding=(1, 2),
+        )
+
+    @classmethod
+    def success_panel(cls, content: Any, title: str = "✅ Success"):
+        """Create a success panel."""
+        return cls(
+            content,
+            title=title,
+            border_style="green",
+            padding=(1, 2),
+        )
+
+    @classmethod
+    def warning_panel(cls, content: Any, title: str = "⚠️ Warning"):
+        """Create a warning panel."""
+        return cls(
+            content,
+            title=title,
+            border_style="yellow",
+            padding=(1, 2),
+        )
+
+    @classmethod
+    def error_panel(cls, content: Any, title: str = "❌ Error"):
+        """Create an error panel."""
+        return cls(
+            content,
+            title=title,
+            border_style="red",
+            padding=(1, 2),
+        )
+
+    def render(self, console=None):
+        """Render the panel."""
+        if console is None:
+            console_instance = get_console()
+            # HTCLIConsole exposes `print`
+            console_instance.print(self.panel)
+            return
+
+        # Support both HTCLIConsole and raw Rich Console objects
+        if hasattr(console, "print"):
+            console.print(self.panel)
+        elif hasattr(console, "console") and hasattr(console.console, "print"):
+            console.console.print(self.panel)
+        else:
+            # Fallback to global console if provided object is unexpected
+            get_console().print(self.panel)
+
+    def __rich__(self):
+        """Rich renderable."""
+        return self.panel
+
+
+class HTCLIStatus:
+    """Real-time status display for HTCLI operations."""
+
+    def __init__(self, title: str = "Status"):
+        self.title = title
+        self.layout = Layout()
+        self.layout.split_column(
+            Layout(name="header", size=3),
+            Layout(name="main", size=10),
+            Layout(name="footer", size=3),
+        )
+        self.layout["header"].update(Panel(title, style="bold cyan"))
+        self.layout["footer"].update(Panel("", style="dim"))
+
+    def update_main(self, content: Any):
+        """Update the main content area."""
+        self.layout["main"].update(content)
+
+    def update_footer(self, content: Any):
+        """Update the footer area."""
+        self.layout["footer"].update(content)
+
+    def render(self):
+        """Render the status display."""
+        console = get_console()
+        console.print(self.layout)
+
+    def __rich__(self):
+        """Rich renderable."""
+        return self.layout
+
+
+# Specialized panel factory functions
+def create_welcome_panel() -> HTCLIPanel:
+    """Create a welcome panel."""
+    welcome_text = """
+Welcome to HTCLI - Your Gateway to the Hypertensor Blockchain
+
+🌐 Manage subnets and nodes
+💰 Handle wallets and transactions  
+📊 Monitor network statistics
+⚡ Execute blockchain operations
+
+Use 'htcli --help' to see all available commands.
+    """
+    return HTCLIPanel.info_panel(welcome_text, "🚀 HTCLI Welcome")
+
+
+def create_help_panel() -> HTCLIPanel:
+    """Create a help panel."""
+    help_text = """
+Available Commands:
+
+📊 subnet    - Subnet management operations
+💰 wallet    - Wallet and key management
+📡 node      - Node registration and management
+⚡ stake     - Staking operations
+🔗 chain     - Chain information and statistics
+⚙️  config    - Configuration management
+
+For detailed help on any command, use:
+htcli <command> --help
+    """
+    return HTCLIPanel.info_panel(help_text, "📚 HTCLI Help")
+
+
+def create_error_summary_panel(errors: list[str]) -> HTCLIPanel:
+    """Create an error summary panel."""
+    error_text = "\n".join([f"• {error}" for error in errors])
+    return HTCLIPanel.error_panel(error_text, "❌ Errors Found")
+
+
+def create_success_summary_panel(successes: list[str]) -> HTCLIPanel:
+    """Create a success summary panel."""
+    success_text = "\n".join([f"✅ {success}" for success in successes])
+    return HTCLIPanel.success_panel(success_text, "🎉 Operations Completed")

src/htcli/ui/components/progress.py

@@ -0,0 +1,166 @@
+"""
+HTCLI progress components.
+Provides enhanced progress bars for operations.
+"""
+
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TaskProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+
+from ..display import get_console
+
+
+class HTCLIProgress:
+    """Enhanced progress bar for HTCLI operations."""
+
+    def __init__(
+        self,
+        console: Console = None,
+        refresh_per_second: float = 10,
+        transient: bool = False,
+    ):
+        # Use the provided console or get the default one
+        # Rich Progress uses Live display internally which handles line updates automatically
+        # The SpinnerColumn will automatically animate while the progress bar updates
+        if console is None:
+            console = get_console().console
+
+        self.console = console
+        # SpinnerColumn animates automatically - refresh_per_second controls animation speed
+        # Higher refresh rate = smoother spinner animation
+        self.progress = Progress(
+            SpinnerColumn(),  # Spinner animates automatically while progress updates
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(
+                bar_width=None,
+                style="htcli.progress.bar",
+                complete_style="htcli.status.success",
+                finished_style="htcli.status.success",
+            ),
+            TaskProgressColumn(),
+            TimeRemainingColumn(),
+            console=self.console,
+            transient=transient,  # Allow control over whether progress disappears after completion
+            refresh_per_second=refresh_per_second,  # Controls spinner animation speed
+            # Ensure progress is visible even for quick operations
+            auto_refresh=True,
+        )
+        self._tasks: dict[str, TaskID] = {}
+        self._running = False
+
+    def __enter__(self):
+        self._running = True
+        self.progress.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._running = False
+        # Stop the progress display - this cleans up the Live display
+        self.progress.stop()
+        # Print a newline to ensure clean separation from progress bar output
+        # This prevents the next output from appearing on the same line as the progress bar
+        self.console.print()
+
+    def add_task(
+        self, description: str, total: Optional[float] = None, task_id: str = None
+    ) -> TaskID:
+        """Add a new task to the progress bar."""
+        if task_id is None:
+            task_id = description
+        task = self.progress.add_task(description, total=total)
+        self._tasks[task_id] = task
+        return task
+
+    def update(
+        self,
+        task_id: Union[TaskID, str],
+        advance: float = 1,
+        description: str = None,
+        total: float = None,
+    ):
+        """Update a task's progress."""
+        if isinstance(task_id, str):
+            task_id = self._tasks.get(task_id)
+        if task_id is not None:
+            self.progress.update(
+                task_id, advance=advance, description=description, total=total
+            )
+
+    def set_description(self, task_id: Union[TaskID, str], description: str):
+        """Set task description."""
+        if isinstance(task_id, str):
+            task_id = self._tasks.get(task_id)
+        if task_id is not None:
+            self.progress.update(task_id, description=description)
+
+    def complete_task(self, task_id: Union[TaskID, str]):
+        """Mark a task as completed."""
+        if isinstance(task_id, str):
+            task_id = self._tasks.get(task_id)
+        if task_id is not None:
+            self.progress.update(task_id, completed=True)
+
+    @contextmanager
+    def task(
+        self, description: str, total: Optional[float] = None, task_id: str = None
+    ):
+        """Context manager for individual tasks."""
+        task = self.add_task(description, total, task_id)
+        try:
+            yield task
+        finally:
+            self.complete_task(task)
+
+
+class HTCLILoadingContext:
+    """Context manager for loading operations with spinner indication.
+
+    Uses HTCLISpinner for indeterminate loading operations (no known completion).
+    This ensures the spinner updates in place on the same line rather than
+    printing multiple lines.
+    """
+
+    def __init__(
+        self,
+        message: str = "Loading...",
+        show_progress: bool = True,
+        transient: bool = True,
+    ):
+        self.message = message
+        self.show_progress = show_progress
+        self.transient = transient
+        self.spinner = None
+
+    def __enter__(self):
+        if self.show_progress:
+            # Use HTCLISpinner for simple loading operations
+            # This properly uses Rich's Live display to update in place
+            from .spinners import HTCLISpinner
+
+            self.spinner = HTCLISpinner(
+                text=self.message,
+                spinner="dots",
+                transient=self.transient,
+                refresh_per_second=12,
+            )
+            self.spinner.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.spinner:
+            self.spinner.__exit__(exc_type, exc_val, exc_tb)
+
+    def update_message(self, message: str):
+        """Update the loading message."""
+        if self.spinner:
+            self.spinner.update(message)

src/htcli/ui/components/spinners.py

@@ -0,0 +1,92 @@
+"""
+HTCLI spinner components.
+Provides enhanced spinners for loading operations.
+"""
+
+from contextlib import contextmanager
+
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
+
+from ..display import get_console
+
+
+class HTCLISpinner:
+    """Enhanced spinner for HTCLI operations using Rich's Spinner with Live display."""
+
+    def __init__(
+        self,
+        text: str = "Loading...",
+        spinner: str = "dots",
+        style: str = "htcli.spinner",
+        refresh_per_second: float = 12,
+        transient: bool = True,
+    ):
+        # Get console and ensure it's configured for terminal output
+        base_console = get_console().console
+        # Create a console instance specifically for the Live display
+        # This ensures proper terminal detection and in-place updates
+        self.console = base_console
+        self.text = text
+        self.spinner_name = spinner
+        self.style = style
+        self.refresh_per_second = refresh_per_second
+        self.transient = transient
+        self._spinner = None
+        self._live = None
+        self._running = False
+
+    def __enter__(self):
+        # Create Rich Spinner with text
+        self._spinner = Spinner(
+            name=self.spinner_name,
+            text=Text(self.text, style=self.style),
+            speed=1.0,
+        )
+        # Create Live display with the spinner
+        # For in-place updates (spinning on the same line), we need:
+        # - screen=False: Update on the same line using carriage return
+        # - auto_refresh=True: Automatically refresh the display
+        # - console must be a terminal (not a file/pipe)
+        # If the console is not a terminal, Live will print new lines instead of updating in place
+        import sys
+        # Only use in-place updates if stdout is a terminal
+        # Otherwise, fall back to simple printing (though this shouldn't happen in normal CLI usage)
+        is_terminal = sys.stdout.isatty() and self.console.is_terminal
+        
+        self._live = Live(
+            self._spinner,
+            console=self.console,
+            refresh_per_second=self.refresh_per_second,
+            transient=self.transient,
+            screen=False,  # Update in place on same line (uses \r carriage return)
+            auto_refresh=True,
+            vertical_overflow="visible",
+        )
+        self._running = True
+        self._live.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._running = False
+        if self._live:
+            self._live.stop()
+            # Always add a newline after stopping spinner to avoid next output
+            # appearing on the same line as the spinner.
+            self.console.print()
+
+    def update(self, text: str):
+        """Update the spinner text and render it."""
+        if self._spinner and self._running:
+            self._spinner.update(text=Text(text, style=self.style))
+
+    @contextmanager
+    def step(self, step_text: str):
+        """Context manager for individual steps."""
+        original_text = self.text
+        self.update(f"{original_text} - {step_text}")
+        try:
+            yield
+        finally:
+            self.update(original_text)