hanzo 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

hanzo/commands/cluster.py

@@ -1,14 +1,12 @@
 """Cluster management commands."""
 
-import asyncio
 from typing import List, Optional
 
 import click
-import httpx
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.table import Table
+from rich.progress import Progress, TextColumn, SpinnerColumn
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.group(name="cluster")
@@ -21,14 +19,21 @@ def cluster_group():
 @click.option("--name", "-n", default="hanzo-local", help="Cluster name")
 @click.option("--port", "-p", default=8000, type=int, help="API port")
 @click.option("--models", "-m", multiple=True, help="Models to load")
-@click.option("--device", type=click.Choice(["cpu", "gpu", "auto"]), default="auto", help="Device to use")
+@click.option(
+    "--device",
+    type=click.Choice(["cpu", "gpu", "auto"]),
+    default="auto",
+    help="Device to use",
+)
 @click.pass_context
 async def start(ctx, name: str, port: int, models: tuple, device: str):
     """Start local AI cluster."""
     await start_cluster(ctx, name, port, list(models) if models else None, device)
 
 
-async def start_cluster(ctx, name: str, port: int, models: Optional[List[str]] = None, device: str = "auto"):
+async def start_cluster(
+    ctx, name: str, port: int, models: Optional[List[str]] = None, device: str = "auto"
+):
     """Start a local cluster via hanzo-cluster."""
     try:
         from hanzo_cluster import HanzoCluster
@@ -36,16 +41,16 @@ async def start_cluster(ctx, name: str, port: int, models: Optional[List[str]] =
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         console.print("Install with: pip install hanzo[cluster]")
         return
-    
+
     cluster = HanzoCluster(name=name, port=port, device=device)
-    
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
         console=console,
     ) as progress:
         task = progress.add_task("Starting cluster...", total=None)
-        
+
         try:
             await cluster.start(models=models)
             progress.update(task, completed=True)
@@ -53,10 +58,10 @@ async def start_cluster(ctx, name: str, port: int, models: Optional[List[str]] =
             progress.stop()
             console.print(f"[red]Failed to start cluster: {e}[/red]")
             return
-    
+
     console.print(f"[green]✓[/green] Cluster started at http://localhost:{port}")
     console.print("Press Ctrl+C to stop\n")
-    
+
     # Show cluster info
     info = await cluster.info()
     console.print("[cyan]Cluster Information:[/cyan]")
@@ -64,11 +69,11 @@ async def start_cluster(ctx, name: str, port: int, models: Optional[List[str]] =
     console.print(f"  Port: {info.get('port', port)}")
     console.print(f"  Device: {info.get('device', device)}")
     console.print(f"  Nodes: {info.get('nodes', 1)}")
-    if models := info.get('models', models):
+    if models := info.get("models", models):
         console.print(f"  Models: {', '.join(models)}")
-    
+
     console.print("\n[dim]Logs:[/dim]")
-    
+
     try:
         # Stream logs
         async for log in cluster.stream_logs():
@@ -89,9 +94,9 @@ async def stop(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     cluster = HanzoCluster(name=name)
-    
+
     console.print("[yellow]Stopping cluster...[/yellow]")
     try:
         await cluster.stop()
@@ -110,38 +115,40 @@ async def status(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     cluster = HanzoCluster(name=name)
-    
+
     try:
         status = await cluster.status()
-        
-        if status.get('running'):
+
+        if status.get("running"):
             console.print("[green]✓[/green] Cluster is running")
-            
+
             # Show cluster info
             console.print("\n[cyan]Cluster Information:[/cyan]")
             console.print(f"  Name: {status.get('name', name)}")
             console.print(f"  Nodes: {status.get('nodes', 0)}")
             console.print(f"  Status: {status.get('state', 'unknown')}")
-            
+
             # Show models
-            if models := status.get('models', []):
+            if models := status.get("models", []):
                 console.print("\n[cyan]Available Models:[/cyan]")
                 for model in models:
                     console.print(f"  • {model}")
-            
+
             # Show nodes
-            if nodes := status.get('node_details', []):
+            if nodes := status.get("node_details", []):
                 console.print("\n[cyan]Nodes:[/cyan]")
                 for node in nodes:
-                    console.print(f"  • {node.get('name', 'unknown')} ({node.get('state', 'unknown')})")
-                    if device := node.get('device'):
+                    console.print(
+                        f"  • {node.get('name', 'unknown')} ({node.get('state', 'unknown')})"
+                    )
+                    if device := node.get("device"):
                         console.print(f"    Device: {device}")
         else:
             console.print("[yellow]![/yellow] Cluster is not running")
             console.print("Start with: hanzo cluster start")
-            
+
     except Exception as e:
         console.print(f"[red]Error checking status: {e}[/red]")
 
@@ -156,32 +163,32 @@ async def models(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     cluster = HanzoCluster(name=name)
-    
+
     try:
         models = await cluster.list_models()
-        
+
         if models:
             table = Table(title="Available Models")
             table.add_column("Model ID", style="cyan")
             table.add_column("Type", style="green")
             table.add_column("Status", style="yellow")
             table.add_column("Node", style="blue")
-            
+
             for model in models:
                 table.add_row(
                     model.get("id", "unknown"),
                     model.get("type", "model"),
                     model.get("status", "unknown"),
-                    model.get("node", "local")
+                    model.get("node", "local"),
                 )
-            
+
             console.print(table)
         else:
             console.print("[yellow]No models loaded[/yellow]")
             console.print("Load models with: hanzo cluster load <model>")
-            
+
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
 
@@ -198,21 +205,21 @@ async def load(ctx, model: str, name: str, node: str = None):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     cluster = HanzoCluster(name=name)
-    
+
     with console.status(f"Loading model '{model}'..."):
         try:
             result = await cluster.load_model(model, node=node)
             console.print(f"[green]✓[/green] Loaded model: {model}")
-            if node_name := result.get('node'):
+            if node_name := result.get("node"):
                 console.print(f"  Node: {node_name}")
         except Exception as e:
             console.print(f"[red]Failed to load model: {e}[/red]")
 
 
 @cluster_group.command()
-@click.argument("model") 
+@click.argument("model")
 @click.option("--name", "-n", default="hanzo-local", help="Cluster name")
 @click.pass_context
 async def unload(ctx, model: str, name: str):
@@ -222,9 +229,9 @@ async def unload(ctx, model: str, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     cluster = HanzoCluster(name=name)
-    
+
     if click.confirm(f"Unload model '{model}'?"):
         with console.status(f"Unloading model '{model}'..."):
             try:
@@ -243,35 +250,51 @@ def node_group():
 @node_group.command(name="start")
 @click.option("--name", "-n", default="node-1", help="Node name")
 @click.option("--cluster", "-c", default="hanzo-local", help="Cluster to join")
-@click.option("--device", type=click.Choice(["cpu", "gpu", "auto"]), default="auto", help="Device to use")
-@click.option("--port", "-p", type=int, help="Node port (auto-assigned if not specified)")
+@click.option(
+    "--device",
+    type=click.Choice(["cpu", "gpu", "auto"]),
+    default="auto",
+    help="Device to use",
+)
+@click.option(
+    "--port", "-p", type=int, help="Node port (auto-assigned if not specified)"
+)
 @click.option("--blockchain", is_flag=True, help="Enable blockchain features")
 @click.option("--network", is_flag=True, help="Enable network discovery")
 @click.pass_context
-async def node_start(ctx, name: str, cluster: str, device: str, port: int, blockchain: bool, network: bool):
+async def node_start(
+    ctx,
+    name: str,
+    cluster: str,
+    device: str,
+    port: int,
+    blockchain: bool,
+    network: bool,
+):
     """Start this machine as a node in the cluster."""
     try:
         from hanzo_cluster import HanzoNode
+
         if blockchain or network:
             from hanzo_network import HanzoNetwork
     except ImportError:
         console.print("[red]Error:[/red] Required packages not installed")
         console.print("Install with: pip install hanzo[cluster,network]")
         return
-    
+
     node = HanzoNode(name=name, device=device, port=port)
-    
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
         console=console,
     ) as progress:
         task = progress.add_task(f"Starting node '{name}'...", total=None)
-        
+
         try:
             # Start the node
             await node.start(cluster=cluster)
-            
+
             # Enable blockchain/network features if requested
             if blockchain or network:
                 network_mgr = HanzoNetwork(node=node)
@@ -279,13 +302,13 @@ async def node_start(ctx, name: str, cluster: str, device: str, port: int, block
                     await network_mgr.enable_blockchain()
                 if network:
                     await network_mgr.enable_discovery()
-            
+
             progress.update(task, completed=True)
         except Exception as e:
             progress.stop()
             console.print(f"[red]Failed to start node: {e}[/red]")
             return
-    
+
     console.print(f"[green]✓[/green] Node '{name}' started")
     console.print(f"  Cluster: {cluster}")
     console.print(f"  Device: {device}")
@@ -295,10 +318,10 @@ async def node_start(ctx, name: str, cluster: str, device: str, port: int, block
         console.print("  [cyan]Blockchain enabled[/cyan]")
     if network:
         console.print("  [cyan]Network discovery enabled[/cyan]")
-    
+
     console.print("\nPress Ctrl+C to stop\n")
     console.print("[dim]Logs:[/dim]")
-    
+
     try:
         # Stream logs
         async for log in node.stream_logs():
@@ -320,7 +343,7 @@ async def node_stop(ctx, name: str, all: bool):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     if all:
         if click.confirm("Stop all nodes?"):
             console.print("[yellow]Stopping all nodes...[/yellow]")
@@ -351,10 +374,10 @@ async def node_list(ctx, cluster: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     try:
         nodes = await HanzoNode.list_nodes(cluster=cluster)
-        
+
         if nodes:
             table = Table(title="Cluster Nodes")
             table.add_column("Name", style="cyan")
@@ -362,21 +385,21 @@ async def node_list(ctx, cluster: str):
             table.add_column("Device", style="yellow")
             table.add_column("Status", style="blue")
             table.add_column("Models", style="magenta")
-            
+
             for node in nodes:
                 table.add_row(
                     node.get("name", "unknown"),
                     node.get("cluster", "unknown"),
                     node.get("device", "unknown"),
                     node.get("status", "unknown"),
-                    str(len(node.get("models", [])))
+                    str(len(node.get("models", []))),
                 )
-            
+
             console.print(table)
         else:
             console.print("[yellow]No nodes found[/yellow]")
             console.print("Start a node with: hanzo cluster node start")
-            
+
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
 
@@ -391,38 +414,46 @@ async def node_info(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-cluster not installed")
         return
-    
+
     node = HanzoNode(name=name)
-    
+
     try:
         info = await node.info()
-        
+
         console.print(f"[cyan]Node: {name}[/cyan]")
         console.print(f"  Cluster: {info.get('cluster', 'unknown')}")
         console.print(f"  Status: {info.get('status', 'unknown')}")
         console.print(f"  Device: {info.get('device', 'unknown')}")
-        
-        if uptime := info.get('uptime'):
+
+        if uptime := info.get("uptime"):
             console.print(f"  Uptime: {uptime}")
-        
-        if resources := info.get('resources'):
+
+        if resources := info.get("resources"):
             console.print("\n[cyan]Resources:[/cyan]")
             console.print(f"  CPU: {resources.get('cpu_percent', 'N/A')}%")
-            console.print(f"  Memory: {resources.get('memory_used', 'N/A')} / {resources.get('memory_total', 'N/A')}")
-            if gpu := resources.get('gpu'):
-                console.print(f"  GPU: {gpu.get('name', 'N/A')} ({gpu.get('memory_used', 'N/A')} / {gpu.get('memory_total', 'N/A')})")
-        
-        if models := info.get('models'):
+            console.print(
+                f"  Memory: {resources.get('memory_used', 'N/A')} / {resources.get('memory_total', 'N/A')}"
+            )
+            if gpu := resources.get("gpu"):
+                console.print(
+                    f"  GPU: {gpu.get('name', 'N/A')} ({gpu.get('memory_used', 'N/A')} / {gpu.get('memory_total', 'N/A')})"
+                )
+
+        if models := info.get("models"):
             console.print("\n[cyan]Loaded Models:[/cyan]")
             for model in models:
                 console.print(f"  • {model}")
-        
-        if network := info.get('network'):
+
+        if network := info.get("network"):
             console.print("\n[cyan]Network:[/cyan]")
-            console.print(f"  Blockchain: {'enabled' if network.get('blockchain') else 'disabled'}")
-            console.print(f"  Discovery: {'enabled' if network.get('discovery') else 'disabled'}")
-            if peers := network.get('peers'):
+            console.print(
+                f"  Blockchain: {'enabled' if network.get('blockchain') else 'disabled'}"
+            )
+            console.print(
+                f"  Discovery: {'enabled' if network.get('discovery') else 'disabled'}"
+            )
+            if peers := network.get("peers"):
                 console.print(f"  Peers: {len(peers)}")
-        
+
     except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
+        console.print(f"[red]Error: {e}[/red]")

hanzo/commands/config.py

@@ -1,14 +1,12 @@
 """Configuration management commands."""
 
 import json
-from pathlib import Path
-from typing import Any, Optional
 
-import click
 import yaml
+import click
 from rich.syntax import Syntax
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.group(name="config")
@@ -25,37 +23,37 @@ def config_group():
 def show(ctx, is_global: bool, is_local: bool, system: bool):
     """Show configuration."""
     from ..utils.config import load_config, get_config_paths
-    
+
     # Determine which configs to show
     show_all = not (is_global or is_local or system)
-    
+
     configs = {}
     paths = get_config_paths()
-    
+
     if show_all or system:
         if paths["system"].exists():
             configs["System"] = (paths["system"], load_config(paths["system"]))
-    
+
     if show_all or is_global:
         if paths["global"].exists():
             configs["Global"] = (paths["global"], load_config(paths["global"]))
-    
+
     if show_all or is_local:
         if paths["local"].exists():
             configs["Local"] = (paths["local"], load_config(paths["local"]))
-    
+
     # Merge and show
     if configs:
         for name, (path, config) in configs.items():
             console.print(f"[cyan]{name} Config:[/cyan] {path}")
-            
+
             # Pretty print config
             if config:
                 syntax = Syntax(
                     yaml.dump(config, default_flow_style=False),
                     "yaml",
                     theme="monokai",
-                    line_numbers=False
+                    line_numbers=False,
                 )
                 console.print(syntax)
             else:
@@ -75,20 +73,20 @@ def show(ctx, is_global: bool, is_local: bool, system: bool):
 def set(ctx, key: str, value: str, is_global: bool, is_local: bool):
     """Set configuration value."""
     from ..utils.config import load_config, save_config, get_config_paths
-    
+
     # Determine target config
     paths = get_config_paths()
-    
+
     if is_local:
         config_path = paths["local"]
         config_name = "local"
     else:  # Default to global
         config_path = paths["global"]
         config_name = "global"
-    
+
     # Load existing config
     config = load_config(config_path) if config_path.exists() else {}
-    
+
     # Parse value
     try:
         # Try to parse as JSON first
@@ -102,22 +100,24 @@ def set(ctx, key: str, value: str, is_global: bool, is_local: bool):
         else:
             # Keep as string
             parsed_value = value
-    
+
     # Set value (support nested keys with dot notation)
     keys = key.split(".")
     current = config
-    
+
     for k in keys[:-1]:
         if k not in current:
             current[k] = {}
         current = current[k]
-    
+
     current[keys[-1]] = parsed_value
-    
+
     # Save config
     save_config(config_path, config)
-    
-    console.print(f"[green]✓[/green] Set {key} = {parsed_value} in {config_name} config")
+
+    console.print(
+        f"[green]✓[/green] Set {key} = {parsed_value} in {config_name} config"
+    )
 
 
 @config_group.command()
@@ -128,10 +128,10 @@ def set(ctx, key: str, value: str, is_global: bool, is_local: bool):
 def get(ctx, key: str, is_global: bool, is_local: bool):
     """Get configuration value."""
     from ..utils.config import get_config_value
-    
+
     scope = "local" if is_local else ("global" if is_global else None)
     value = get_config_value(key, scope=scope)
-    
+
     if value is not None:
         if isinstance(value, (dict, list)):
             console.print_json(data=value)
@@ -149,32 +149,32 @@ def get(ctx, key: str, is_global: bool, is_local: bool):
 def unset(ctx, key: str, is_global: bool, is_local: bool):
     """Unset configuration value."""
     from ..utils.config import load_config, save_config, get_config_paths
-    
+
     # Determine target config
     paths = get_config_paths()
-    
+
     if is_local:
         config_path = paths["local"]
         config_name = "local"
     else:  # Default to global
         config_path = paths["global"]
         config_name = "global"
-    
+
     if not config_path.exists():
         console.print(f"[yellow]No {config_name} config found[/yellow]")
         return
-    
+
     # Load config
     config = load_config(config_path)
-    
+
     # Remove value (support nested keys)
     keys = key.split(".")
     current = config
-    
+
     try:
         for k in keys[:-1]:
             current = current[k]
-        
+
         if keys[-1] in current:
             del current[keys[-1]]
             save_config(config_path, config)
@@ -194,26 +194,27 @@ def edit(ctx, system: bool, is_global: bool, is_local: bool):
     """Edit configuration file in editor."""
     import os
     import subprocess
+
     from ..utils.config import get_config_paths
-    
+
     # Determine which config to edit
     paths = get_config_paths()
-    
+
     if system:
         config_path = paths["system"]
     elif is_local:
         config_path = paths["local"]
     else:  # Default to global
         config_path = paths["global"]
-    
+
     # Ensure file exists
     if not config_path.exists():
         config_path.parent.mkdir(parents=True, exist_ok=True)
         config_path.write_text("# Hanzo configuration\n")
-    
+
     # Get editor
     editor = os.environ.get("EDITOR", "vi")
-    
+
     # Open in editor
     try:
         subprocess.run([editor, str(config_path)], check=True)
@@ -230,11 +231,11 @@ def edit(ctx, system: bool, is_global: bool, is_local: bool):
 def init(ctx):
     """Initialize configuration."""
     from ..utils.config import init_config
-    
+
     try:
         paths = init_config()
         console.print("[green]✓[/green] Initialized configuration")
         console.print(f"  Global: {paths['global']}")
         console.print(f"  Local: {paths.get('local', 'Not in project')}")
     except Exception as e:
-        console.print(f"[red]Failed to initialize config: {e}[/red]")
+        console.print(f"[red]Failed to initialize config: {e}[/red]")