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

hanzo/commands/mcp.py

@@ -1,14 +1,11 @@
 """MCP (Model Context Protocol) commands."""
 
-import asyncio
 import json
-from typing import Dict, Any
 
 import click
 from rich.table import Table
-from rich.syntax import Syntax
 
-from ..utils.output import console, handle_errors
+from ..utils.output import console
 
 
 @click.group(name="mcp")
@@ -19,13 +16,27 @@ def mcp_group():
 
 @mcp_group.command()
 @click.option("--name", "-n", default="hanzo-mcp", help="Server name")
-@click.option("--transport", "-t", type=click.Choice(["stdio", "sse"]), default="stdio", help="Transport protocol")
+@click.option(
+    "--transport",
+    "-t",
+    type=click.Choice(["stdio", "sse"]),
+    default="stdio",
+    help="Transport protocol",
+)
 @click.option("--allow-path", "-p", multiple=True, help="Allowed paths")
 @click.option("--enable-agent", is_flag=True, help="Enable agent tools")
 @click.option("--host", default="127.0.0.1", help="Host for SSE transport")
 @click.option("--port", default=3000, type=int, help="Port for SSE transport")
 @click.pass_context
-def serve(ctx, name: str, transport: str, allow_path: tuple, enable_agent: bool, host: str, port: int):
+def serve(
+    ctx,
+    name: str,
+    transport: str,
+    allow_path: tuple,
+    enable_agent: bool,
+    host: str,
+    port: int,
+):
     """Start MCP server."""
     try:
         from hanzoai.mcp import run_mcp_server
@@ -33,17 +44,17 @@ def serve(ctx, name: str, transport: str, allow_path: tuple, enable_agent: bool,
         console.print("[red]Error:[/red] hanzo-mcp not installed")
         console.print("Install with: pip install hanzo[mcp]")
         return
-    
+
     allowed_paths = list(allow_path) if allow_path else ["."]
-    
+
     console.print(f"[cyan]Starting MCP server[/cyan]")
     console.print(f"  Name: {name}")
     console.print(f"  Transport: {transport}")
     console.print(f"  Allowed paths: {', '.join(allowed_paths)}")
-    
+
     if transport == "sse":
         console.print(f"  Endpoint: http://{host}:{port}")
-    
+
     try:
         run_mcp_server(
             name=name,
@@ -51,7 +62,7 @@ def serve(ctx, name: str, transport: str, allow_path: tuple, enable_agent: bool,
             allowed_paths=allowed_paths,
             enable_agent_tool=enable_agent,
             host=host,
-            port=port
+            port=port,
         )
     except KeyboardInterrupt:
         console.print("\n[yellow]Server stopped[/yellow]")
@@ -68,30 +79,32 @@ async def tools(ctx, category: str):
         console.print("[red]Error:[/red] hanzo-mcp not installed")
         console.print("Install with: pip install hanzo[mcp]")
         return
-    
+
     with console.status("Loading tools..."):
         server = create_server(enable_all_tools=True)
         tools_list = await server.mcp.list_tools()
-    
+
     # Group by category if available
     categories = {}
     for tool in tools_list:
-        cat = getattr(tool, 'category', 'general')
+        cat = getattr(tool, "category", "general")
         if category and cat != category:
             continue
         if cat not in categories:
             categories[cat] = []
         categories[cat].append(tool)
-    
+
     # Display tools
     for cat, tools in sorted(categories.items()):
-        table = Table(title=f"{cat.title()} Tools" if len(categories) > 1 else "MCP Tools")
+        table = Table(
+            title=f"{cat.title()} Tools" if len(categories) > 1 else "MCP Tools"
+        )
         table.add_column("Name", style="cyan", no_wrap=True)
         table.add_column("Description")
-        
+
         for tool in sorted(tools, key=lambda t: t.name):
             table.add_row(tool.name, tool.description)
-        
+
         console.print(table)
         if len(categories) > 1:
             console.print()
@@ -110,10 +123,10 @@ async def run(ctx, tool: str, arg: tuple, json_args: str):
         console.print("[red]Error:[/red] hanzo-mcp not installed")
         console.print("Install with: pip install hanzo[mcp]")
         return
-    
+
     # Parse arguments
     args = {}
-    
+
     if json_args:
         try:
             args = json.loads(json_args)
@@ -127,17 +140,17 @@ async def run(ctx, tool: str, arg: tuple, json_args: str):
                 console.print("Use: --arg key=value")
                 return
             key, value = a.split("=", 1)
-            
+
             # Try to parse value as JSON first
             try:
                 args[key] = json.loads(value)
             except:
                 args[key] = value
-    
+
     # Create server and run tool
     with console.status(f"Running tool '{tool}'..."):
         server = create_server(enable_all_tools=True)
-        
+
         # Find tool
         tools_list = await server.mcp.list_tools()
         tool_obj = None
@@ -145,18 +158,19 @@ async def run(ctx, tool: str, arg: tuple, json_args: str):
             if t.name == tool:
                 tool_obj = t
                 break
-        
+
         if not tool_obj:
             console.print(f"[red]Tool not found: {tool}[/red]")
             console.print("Use 'hanzo mcp tools' to list available tools")
             return
-        
+
         # Run tool
         try:
             # Mock context for now
             from mcp.server.fastmcp import Context
+
             context = Context()
-            
+
             # Get tool function
             tool_func = server.mcp._tool_map.get(tool)
             if tool_func:
@@ -164,11 +178,11 @@ async def run(ctx, tool: str, arg: tuple, json_args: str):
             else:
                 console.print(f"[red]Tool function not found: {tool}[/red]")
                 return
-                
+
         except Exception as e:
             console.print(f"[red]Tool error: {e}[/red]")
             return
-    
+
     # Display result
     if isinstance(result, str):
         try:
@@ -183,53 +197,60 @@ async def run(ctx, tool: str, arg: tuple, json_args: str):
 
 
 @mcp_group.command()
-@click.option("--path", "-p", default="~/.config/claude/claude_desktop_config.json", help="Config file path")
+@click.option(
+    "--path",
+    "-p",
+    default="~/.config/claude/claude_desktop_config.json",
+    help="Config file path",
+)
 @click.pass_context
 def install(ctx, path: str):
     """Install MCP server in Claude Desktop."""
     try:
         from hanzoai.mcp import create_server
     except ImportError:
-        console.print("[red]Error:[/red] hanzo-mcp not installed") 
+        console.print("[red]Error:[/red] hanzo-mcp not installed")
         console.print("Install with: pip install hanzo[mcp]")
         return
-    
+
     import os
     import json
     from pathlib import Path
-    
+
     config_path = Path(os.path.expanduser(path))
-    
+
     # Create config
     config = {
         "mcpServers": {
             "hanzo-mcp": {
                 "command": "hanzo",
-                "args": ["mcp", "serve", "--transport", "stdio"]
+                "args": ["mcp", "serve", "--transport", "stdio"],
             }
         }
     }
-    
+
     # Check if file exists
     if config_path.exists():
         try:
             with open(config_path, "r") as f:
                 existing = json.load(f)
-            
+
             if "mcpServers" not in existing:
                 existing["mcpServers"] = {}
-            
+
             existing["mcpServers"]["hanzo-mcp"] = config["mcpServers"]["hanzo-mcp"]
             config = existing
         except Exception as e:
-            console.print(f"[yellow]Warning: Could not read existing config: {e}[/yellow]")
-    
+            console.print(
+                f"[yellow]Warning: Could not read existing config: {e}[/yellow]"
+            )
+
     # Write config
     config_path.parent.mkdir(parents=True, exist_ok=True)
-    
+
     with open(config_path, "w") as f:
         json.dump(config, f, indent=2)
-    
+
     console.print(f"[green]✓[/green] Installed hanzo-mcp in Claude Desktop")
     console.print(f"  Config: {config_path}")
-    console.print("\nRestart Claude Desktop for changes to take effect")
+    console.print("\nRestart Claude Desktop for changes to take effect")

hanzo/commands/miner.py

@@ -1,13 +1,10 @@
 """Mining commands for distributed AI compute."""
 
-import asyncio
-from typing import Optional, List
-
 import click
-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="miner")
@@ -20,11 +17,24 @@ def miner_group():
 @click.option("--name", "-n", help="Miner name (auto-generated if not provided)")
 @click.option("--wallet", "-w", help="Wallet address for rewards")
 @click.option("--models", "-m", multiple=True, help="Models to support")
-@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.option("--network", default="mainnet", help="Network to join")
 @click.option("--min-stake", type=float, help="Minimum stake requirement")
 @click.pass_context
-async def start(ctx, name: str, wallet: str, models: tuple, device: str, network: str, min_stake: float):
+async def start(
+    ctx,
+    name: str,
+    wallet: str,
+    models: tuple,
+    device: str,
+    network: str,
+    min_stake: float,
+):
     """Start mining (contribute compute to network)."""
     try:
         from hanzo_miner import HanzoMiner
@@ -32,29 +42,25 @@ async def start(ctx, name: str, wallet: str, models: tuple, device: str, network
         console.print("[red]Error:[/red] hanzo-miner not installed")
         console.print("Install with: pip install hanzo[miner]")
         return
-    
+
     # Check wallet
     if not wallet:
         console.print("[yellow]Warning:[/yellow] No wallet address provided")
         console.print("You won't earn rewards without a wallet")
         if not click.confirm("Continue without wallet?"):
             return
-    
+
     miner = HanzoMiner(
-        name=name,
-        wallet=wallet,
-        device=device,
-        network=network,
-        min_stake=min_stake
+        name=name, wallet=wallet, device=device, network=network, min_stake=min_stake
     )
-    
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
         console=console,
     ) as progress:
         task = progress.add_task("Starting miner...", total=None)
-        
+
         try:
             # Start miner
             await miner.start(models=list(models) if models else None)
@@ -63,14 +69,14 @@ async def start(ctx, name: str, wallet: str, models: tuple, device: str, network
             progress.stop()
             console.print(f"[red]Failed to start miner: {e}[/red]")
             return
-    
+
     console.print(f"[green]✓[/green] Miner started")
     console.print(f"  Name: {miner.name}")
     console.print(f"  Network: {network}")
     console.print(f"  Device: {device}")
     if wallet:
         console.print(f"  Wallet: {wallet[:8]}...{wallet[-4:]}")
-    
+
     # Show initial stats
     stats = await miner.get_stats()
     if stats:
@@ -78,31 +84,35 @@ async def start(ctx, name: str, wallet: str, models: tuple, device: str, network
         console.print(f"  Jobs completed: {stats.get('jobs_completed', 0)}")
         console.print(f"  Tokens earned: {stats.get('tokens_earned', 0)}")
         console.print(f"  Uptime: {stats.get('uptime', '0s')}")
-    
+
     console.print("\nPress Ctrl+C to stop mining\n")
     console.print("[dim]Logs:[/dim]")
-    
+
     try:
         # Stream logs and stats
         async for event in miner.stream_events():
             if event["type"] == "log":
                 console.print(event["message"], end="")
             elif event["type"] == "job":
-                console.print(f"[green]Job completed:[/green] {event['job_id']} (+{event['tokens']} tokens)")
+                console.print(
+                    f"[green]Job completed:[/green] {event['job_id']} (+{event['tokens']} tokens)"
+                )
             elif event["type"] == "error":
                 console.print(f"[red]Error:[/red] {event['message']}")
     except KeyboardInterrupt:
         console.print("\n[yellow]Stopping miner...[/yellow]")
         await miner.stop()
-        
+
         # Show final stats
         final_stats = await miner.get_stats()
         if final_stats:
             console.print("\n[cyan]Session Summary:[/cyan]")
             console.print(f"  Jobs completed: {final_stats.get('jobs_completed', 0)}")
             console.print(f"  Tokens earned: {final_stats.get('tokens_earned', 0)}")
-            console.print(f"  Average job time: {final_stats.get('avg_job_time', 'N/A')}")
-        
+            console.print(
+                f"  Average job time: {final_stats.get('avg_job_time', 'N/A')}"
+            )
+
         console.print("[green]✓[/green] Miner stopped")
 
 
@@ -116,7 +126,7 @@ async def stop(ctx, name: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-miner not installed")
         return
-    
+
     if name:
         miner = HanzoMiner.get_by_name(name)
         if miner:
@@ -148,24 +158,24 @@ async def status(ctx, name: str, detailed: bool):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-miner not installed")
         return
-    
+
     if name:
         # Show specific miner
         miner = HanzoMiner.get_by_name(name)
         if not miner:
             console.print(f"[red]Miner not found: {name}[/red]")
             return
-        
+
         miners = [miner]
     else:
         # Show all miners
         miners = HanzoMiner.get_all()
-    
+
     if not miners:
         console.print("[yellow]No miners running[/yellow]")
         console.print("Start mining with: hanzo miner start")
         return
-    
+
     # Create table
     table = Table(title="Active Miners")
     table.add_column("Name", style="cyan")
@@ -174,7 +184,7 @@ async def status(ctx, name: str, detailed: bool):
     table.add_column("Jobs", style="blue")
     table.add_column("Tokens", style="magenta")
     table.add_column("Uptime", style="white")
-    
+
     for miner in miners:
         stats = await miner.get_stats()
         table.add_row(
@@ -183,26 +193,30 @@ async def status(ctx, name: str, detailed: bool):
             stats.get("device", "unknown"),
             str(stats.get("jobs_completed", 0)),
             f"{stats.get('tokens_earned', 0):.2f}",
-            stats.get("uptime", "0s")
+            stats.get("uptime", "0s"),
         )
-    
+
     console.print(table)
-    
+
     if detailed and len(miners) == 1:
         # Show detailed stats for single miner
         miner = miners[0]
         stats = await miner.get_stats()
-        
+
         console.print("\n[cyan]Detailed Statistics:[/cyan]")
         console.print(f"  Network: {stats.get('network', 'unknown')}")
         console.print(f"  Wallet: {stats.get('wallet', 'Not set')}")
         console.print(f"  Models: {', '.join(stats.get('models', []))}")
-        console.print(f"  Memory: {stats.get('memory_used', 0)} / {stats.get('memory_total', 0)} MB")
+        console.print(
+            f"  Memory: {stats.get('memory_used', 0)} / {stats.get('memory_total', 0)} MB"
+        )
         console.print(f"  CPU: {stats.get('cpu_percent', 0)}%")
-        
+
         if gpu := stats.get("gpu"):
-            console.print(f"  GPU: {gpu['name']} ({gpu['memory_used']} / {gpu['memory_total']} MB)")
-        
+            console.print(
+                f"  GPU: {gpu['name']} ({gpu['memory_used']} / {gpu['memory_total']} MB)"
+            )
+
         console.print(f"\n[cyan]Performance:[/cyan]")
         console.print(f"  Average job time: {stats.get('avg_job_time', 'N/A')}")
         console.print(f"  Success rate: {stats.get('success_rate', 0)}%")
@@ -219,34 +233,34 @@ async def leaderboard(ctx, network: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-miner not installed")
         return
-    
+
     with console.status("Loading leaderboard..."):
         try:
             leaders = await get_leaderboard(network=network)
         except Exception as e:
             console.print(f"[red]Failed to load leaderboard: {e}[/red]")
             return
-    
+
     if not leaders:
         console.print("[yellow]No data available[/yellow]")
         return
-    
+
     table = Table(title=f"Mining Leaderboard - {network}")
     table.add_column("Rank", style="cyan")
     table.add_column("Miner", style="green")
     table.add_column("Jobs", style="yellow")
     table.add_column("Tokens", style="magenta")
     table.add_column("Success Rate", style="blue")
-    
+
     for i, leader in enumerate(leaders[:20], 1):
         table.add_row(
             str(i),
             leader["name"],
             str(leader["jobs"]),
             f"{leader['tokens']:.2f}",
-            f"{leader['success_rate']}%"
+            f"{leader['success_rate']}%",
         )
-    
+
     console.print(table)
 
 
@@ -261,24 +275,26 @@ async def earnings(ctx, wallet: str, network: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-miner not installed")
         return
-    
+
     with console.status("Checking earnings..."):
         try:
             data = await check_earnings(wallet=wallet, network=network)
         except Exception as e:
             console.print(f"[red]Failed to check earnings: {e}[/red]")
             return
-    
+
     console.print(f"[cyan]Earnings for {wallet[:8]}...{wallet[-4:]}[/cyan]")
     console.print(f"  Network: {network}")
     console.print(f"  Total earned: {data.get('total_earned', 0):.2f} tokens")
     console.print(f"  Available: {data.get('available', 0):.2f} tokens")
     console.print(f"  Pending: {data.get('pending', 0):.2f} tokens")
-    
+
     if history := data.get("recent_jobs"):
         console.print("\n[cyan]Recent Jobs:[/cyan]")
         for job in history[:5]:
-            console.print(f"  • {job['timestamp']}: +{job['tokens']} tokens ({job['model']})")
+            console.print(
+                f"  • {job['timestamp']}: +{job['tokens']} tokens ({job['model']})"
+            )
 
 
 @miner_group.command()
@@ -294,30 +310,27 @@ async def withdraw(ctx, amount: float, wallet: str, to: str, network: str):
     except ImportError:
         console.print("[red]Error:[/red] hanzo-miner not installed")
         return
-    
+
     # Confirm withdrawal
     console.print(f"[yellow]Withdrawal Request:[/yellow]")
     console.print(f"  Amount: {amount} tokens")
     console.print(f"  From: {wallet[:8]}...{wallet[-4:]}")
     console.print(f"  To: {to[:8]}...{to[-4:]}")
     console.print(f"  Network: {network}")
-    
+
     if not click.confirm("Proceed with withdrawal?"):
         return
-    
+
     with console.status("Processing withdrawal..."):
         try:
             result = await withdraw_earnings(
-                wallet=wallet,
-                amount=amount,
-                destination=to,
-                network=network
+                wallet=wallet, amount=amount, destination=to, network=network
             )
-            
+
             console.print(f"[green]✓[/green] Withdrawal successful")
             console.print(f"  Transaction: {result['tx_hash']}")
             console.print(f"  Amount: {result['amount']} tokens")
             console.print(f"  Fee: {result['fee']} tokens")
-            
+
         except Exception as e:
-            console.print(f"[red]Withdrawal failed: {e}[/red]")
+            console.print(f"[red]Withdrawal failed: {e}[/red]")