hippius 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

hippius_sdk/cli_rich.py

@@ -0,0 +1,247 @@
+"""Rich UI components for the Hippius SDK CLI."""
+
+import argparse
+import sys
+from typing import Any, Dict, List, Optional, Union
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (BarColumn, Progress, SpinnerColumn, TextColumn,
+                           TimeElapsedColumn, TimeRemainingColumn)
+from rich.table import Table
+from rich.text import Text
+
+# Create a global console instance
+console = Console()
+
+
+def log(message: str, style: Optional[str] = None) -> None:
+    """Log a message to the console with optional styling.
+
+    Args:
+        message: The message to log
+        style: Optional style to apply to the message
+    """
+    console.print(message, style=style)
+
+
+def info(message: str) -> None:
+    """Log an info message to the console.
+
+    Args:
+        message: The info message to log
+    """
+    console.print(f"[blue]INFO:[/blue] {message}")
+
+
+def success(message: str) -> None:
+    """Log a success message to the console.
+
+    Args:
+        message: The success message to log
+    """
+    console.print(f"[green]SUCCESS:[/green] {message}")
+
+
+def warning(message: str) -> None:
+    """Log a warning message to the console.
+
+    Args:
+        message: The warning message to log
+    """
+    console.print(f"[yellow]WARNING:[/yellow] {message}")
+
+
+def error(message: str) -> None:
+    """Log an error message to the console.
+
+    Args:
+        message: The error message to log
+    """
+    console.print(f"[bold red]ERROR:[/bold red] {message}")
+
+
+def print_table(
+    title: str,
+    data: List[Dict[str, Any]],
+    columns: List[str],
+    style: Optional[str] = None,
+) -> None:
+    """Print a table of data.
+
+    Args:
+        title: The title of the table
+        data: List of dictionaries containing the data
+        columns: List of column names to include
+        style: Optional style to apply to the table
+    """
+    # Create table with optional style and expanded width
+    table = Table(title=title, style=style, expand=True, show_edge=True)
+
+    # Add columns
+    for column in columns:
+        table.add_column(column)
+
+    # Add rows, applying style to each cell if provided
+    for row in data:
+        values = [str(row.get(column, "")) for column in columns]
+        if style:
+            # Apply style to each cell value if a style is provided
+            styled_values = [f"[{style}]{value}[/{style}]" for value in values]
+            table.add_row(*styled_values)
+        else:
+            table.add_row(*values)
+
+    # Print the table
+    console.print(table)
+
+
+def print_panel(content: str, title: Optional[str] = None) -> None:
+    """Print content in a panel.
+
+    Args:
+        content: The content to display in the panel
+        title: Optional title for the panel
+    """
+    console.print(Panel(content, title=title))
+
+
+def create_progress() -> Progress:
+    """Create a Rich progress bar for tracking operations.
+
+    Returns:
+        A Rich Progress instance configured for the Hippius CLI
+    """
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    )
+
+
+def print_help_text(parser: "argparse.ArgumentParser"):
+    """Print help text with Rich formatting.
+
+    Args:
+        parser: The argparse parser to display help for
+    """
+    # Get the help text from the parser
+    import io
+
+    buffer = io.StringIO()
+    parser.print_help(buffer)
+    help_text = buffer.getvalue()
+
+    # Split the help text into sections
+    sections = help_text.split("\n\n")
+
+    # Process and print each section with appropriate styling
+    for i, section in enumerate(sections):
+        if i == 0:  # Usage section
+            lines = section.split("\n")
+            title = lines[0]
+            usage = "\n".join(lines[1:]) if len(lines) > 1 else ""
+            console.print(f"[bold cyan]{title}[/bold cyan]")
+            if usage:
+                console.print(f"[yellow]{usage}[/yellow]")
+        elif "positional arguments:" in section:
+            lines = section.split("\n")
+            title = lines[0]
+            args = "\n".join(lines[1:])
+            console.print(f"\n[bold green]{title}[/bold green]")
+            console.print(args)
+        elif "options:" in section:
+            lines = section.split("\n")
+            title = lines[0]
+            opts = "\n".join(lines[1:])
+            console.print(f"\n[bold green]{title}[/bold green]")
+            console.print(opts)
+        elif "examples:" in section:
+            lines = section.split("\n")
+            title = lines[0]
+            examples = "\n".join(lines[1:])
+            console.print(f"\n[bold magenta]{title}[/bold magenta]")
+            console.print(f"[cyan]{examples}[/cyan]")
+        else:
+            console.print(f"\n{section}")
+
+
+class RichHelpAction(argparse.Action):
+    """Custom help action that displays the Hippius logo and uses Rich formatting."""
+
+    def __init__(
+        self,
+        option_strings,
+        dest=argparse.SUPPRESS,
+        default=argparse.SUPPRESS,
+        help=None,
+    ):
+        super().__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help,
+        )
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        # Display the Hippius logo banner when help is requested
+        from hippius_sdk.cli_assets import HERO_TITLE
+
+        console.print(HERO_TITLE, style="bold cyan")
+
+        # Use our print_help_text function instead of the default formatter
+        print_help_text(parser)
+        parser.exit()
+
+
+class ProgressTracker:
+    """Helper class for tracking progress in async operations with Rich progress bars."""
+
+    def __init__(self, description: str, total: int):
+        """Initialize a progress tracker.
+
+        Args:
+            description: Description for the progress bar
+            total: Total number of items to process
+        """
+        self.progress = create_progress()
+        self.task_id = None
+        self.description = description
+        self.total = total
+        self.completed = 0
+
+    def __enter__(self):
+        """Context manager entry that initializes the progress bar."""
+        self.progress.__enter__()
+        self.task_id = self.progress.add_task(self.description, total=self.total)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit that properly closes the progress bar."""
+        self.progress.__exit__(exc_type, exc_val, exc_tb)
+
+    def update(self, advance: int = 1):
+        """Update the progress bar.
+
+        Args:
+            advance: Number of steps to advance by (default: 1)
+        """
+        self.completed += advance
+        self.progress.update(self.task_id, completed=self.completed)
+
+    def set_description(self, description: str):
+        """Update the progress bar description.
+
+        Args:
+            description: New description text
+        """
+        self.progress.update(self.task_id, description=description)
+
+    def finish(self):
+        """Mark the progress as complete."""
+        self.progress.update(self.task_id, completed=self.total)

hippius_sdk/client.py

@@ -3,7 +3,7 @@ Main client for the Hippius SDK.
 """
 
 import base64
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import nacl.secret
 import nacl.utils
@@ -46,7 +46,9 @@ class HippiusClient:
         """
         # Load configuration values if not explicitly provided
         if ipfs_gateway is None:
-            ipfs_gateway = get_config_value("ipfs", "gateway", "https://ipfs.io")
+            ipfs_gateway = get_config_value(
+                "ipfs", "gateway", "https://get.hippius.network"
+            )
 
         if ipfs_api_url is None:
             ipfs_api_url = get_config_value(
@@ -62,8 +64,8 @@ class HippiusClient:
                 "substrate", "url", "wss://rpc.hippius.network"
             )
 
-        if substrate_seed_phrase is None:
-            substrate_seed_phrase = get_config_value("substrate", "seed_phrase")
+        # Don't try to get a seed phrase from the legacy location
+        # The substrate_client will handle getting it from the active account
 
         if encrypt_by_default is None:
             encrypt_by_default = get_config_value(
@@ -80,18 +82,13 @@ class HippiusClient:
             encrypt_by_default=encrypt_by_default,
             encryption_key=encryption_key,
         )
-
         # Initialize Substrate client
-        try:
-            self.substrate_client = SubstrateClient(
-                url=substrate_url,
-                seed_phrase=substrate_seed_phrase,
-                password=seed_phrase_password,
-                account_name=account_name,
-            )
-        except Exception as e:
-            print(f"Warning: Could not initialize Substrate client: {e}")
-            self.substrate_client = None
+        self.substrate_client = SubstrateClient(
+            url=substrate_url,
+            seed_phrase=substrate_seed_phrase,
+            password=seed_phrase_password,
+            account_name=account_name,
+        )
 
     async def upload_file(
         self, file_path: str, encrypt: Optional[bool] = None
@@ -201,7 +198,7 @@ class HippiusClient:
             cid, max_display_bytes, format_output, decrypt=decrypt
         )
 
-    def exists(self, cid: str) -> Dict[str, Any]:
+    async def exists(self, cid: str) -> Dict[str, Any]:
         """
         Check if a CID exists on IPFS.
 
@@ -215,9 +212,9 @@ class HippiusClient:
                 - formatted_cid: Formatted version of the CID
                 - gateway_url: URL to access the content if it exists
         """
-        return self.ipfs_client.exists(cid)
+        return await self.ipfs_client.exists(cid)
 
-    def pin(self, cid: str) -> Dict[str, Any]:
+    async def pin(self, cid: str) -> Dict[str, Any]:
         """
         Pin a CID to IPFS to keep it available.
 
@@ -231,7 +228,7 @@ class HippiusClient:
                 - formatted_cid: Formatted version of the CID
                 - message: Status message
         """
-        return self.ipfs_client.pin(cid)
+        return await self.ipfs_client.pin(cid)
 
     def format_cid(self, cid: str) -> str:
         """
@@ -336,7 +333,7 @@ class HippiusClient:
         temp_dir: str = None,
         max_retries: int = 3,
         verbose: bool = True,
-    ) -> str:
+    ) -> Dict:
         """
         Reconstruct a file from erasure-coded chunks using its metadata.
 
@@ -348,7 +345,7 @@ class HippiusClient:
             verbose: Whether to print progress information
 
         Returns:
-            str: Path to the reconstructed file
+            Dict: containing file reconstruction info.
 
         Raises:
             ValueError: If reconstruction fails
@@ -372,6 +369,8 @@ class HippiusClient:
         miner_ids: List[str] = None,
         max_retries: int = 3,
         verbose: bool = True,
+        progress_callback: Optional[Callable[[str, int, int], None]] = None,
+        publish: bool = True,
     ) -> Dict[str, Any]:
         """
         Erasure code a file, upload the chunks to IPFS, and store in the Hippius marketplace.
@@ -387,9 +386,14 @@ class HippiusClient:
             miner_ids: List of specific miner IDs to use for storage
             max_retries: Maximum number of retry attempts
             verbose: Whether to print progress information
+            progress_callback: Optional callback function for progress updates
+                            Function receives (stage_name, current, total)
+            publish: Whether to publish to the blockchain (True) or just perform local
+                    erasure coding without publishing (False). When False, no password
+                    is needed for seed phrase access.
 
         Returns:
-            dict: Result including metadata CID and transaction hash
+            dict: Result including metadata CID and transaction hash (if published)
 
         Raises:
             ValueError: If parameters are invalid
@@ -405,4 +409,48 @@ class HippiusClient:
             substrate_client=self.substrate_client,
             max_retries=max_retries,
             verbose=verbose,
+            progress_callback=progress_callback,
+            publish=publish,
+        )
+
+    async def delete_file(
+        self, cid: str, cancel_from_blockchain: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Delete a file from IPFS and optionally cancel its storage on the blockchain.
+
+        Args:
+            cid: Content Identifier (CID) of the file to delete
+            cancel_from_blockchain: Whether to also cancel the storage request from the blockchain
+
+        Returns:
+            Dict containing the result of the operation
+
+        Raises:
+            RuntimeError: If deletion fails completely
+        """
+        return await self.ipfs_client.delete_file(cid, cancel_from_blockchain)
+
+    async def delete_ec_file(
+        self,
+        metadata_cid: str,
+        cancel_from_blockchain: bool = True,
+        parallel_limit: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        Delete an erasure-coded file, including all its chunks in parallel.
+
+        Args:
+            metadata_cid: CID of the metadata file for the erasure-coded file
+            cancel_from_blockchain: Whether to cancel storage from blockchain
+            parallel_limit: Maximum number of concurrent deletion operations
+
+        Returns:
+            Dict containing the result of the operation
+
+        Raises:
+            RuntimeError: If deletion fails completely
+        """
+        return await self.ipfs_client.delete_ec_file(
+            metadata_cid, cancel_from_blockchain, parallel_limit
         )