hanzo 0.2.3__py3-none-any.whl → 0.2.6__py3-none-any.whl

hanzo/utils/config.py

@@ -0,0 +1,170 @@
+"""Configuration utilities for Hanzo CLI."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+def get_config_paths() -> Dict[str, Path]:
+    """Get configuration file paths."""
+    paths = {}
+    
+    # System config
+    if os.name == "nt":  # Windows
+        paths["system"] = Path(os.environ.get("PROGRAMDATA", "C:\\ProgramData")) / "hanzo" / "config.yaml"
+    else:  # Unix-like
+        paths["system"] = Path("/etc/hanzo/config.yaml")
+    
+    # Global config (user)
+    config_home = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    paths["global"] = config_home / "hanzo" / "config.yaml"
+    
+    # Local config (project)
+    cwd = Path.cwd()
+    for parent in [cwd] + list(cwd.parents):
+        config_file = parent / ".hanzo" / "config.yaml"
+        if config_file.exists():
+            paths["local"] = config_file
+            break
+    else:
+        # Default local path even if it doesn't exist
+        paths["local"] = cwd / ".hanzo" / "config.yaml"
+    
+    return paths
+
+
+def load_config(path: Path) -> Dict[str, Any]:
+    """Load configuration from file."""
+    if not path.exists():
+        return {}
+    
+    try:
+        with open(path, "r") as f:
+            if path.suffix == ".json":
+                return json.load(f)
+            else:
+                return yaml.safe_load(f) or {}
+    except Exception:
+        return {}
+
+
+def save_config(path: Path, config: Dict[str, Any]):
+    """Save configuration to file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(path, "w") as f:
+        if path.suffix == ".json":
+            json.dump(config, f, indent=2)
+        else:
+            yaml.dump(config, f, default_flow_style=False)
+
+
+def get_config_value(key: str, default: Any = None, scope: Optional[str] = None) -> Any:
+    """Get configuration value from merged configs."""
+    paths = get_config_paths()
+    
+    # Load configs in priority order (local > global > system)
+    configs = []
+    
+    if scope == "system" or scope is None:
+        if paths["system"].exists():
+            configs.append(load_config(paths["system"]))
+    
+    if scope == "global" or scope is None:
+        if paths["global"].exists():
+            configs.append(load_config(paths["global"]))
+    
+    if scope == "local" or scope is None:
+        if paths.get("local") and paths["local"].exists():
+            configs.append(load_config(paths["local"]))
+    
+    # Merge configs (later ones override earlier)
+    merged = {}
+    for config in configs:
+        merged.update(config)
+    
+    # Get nested key
+    keys = key.split(".")
+    current = merged
+    
+    try:
+        for k in keys:
+            current = current[k]
+        return current
+    except (KeyError, TypeError):
+        return default
+
+
+def set_config_value(key: str, value: Any, scope: str = "global"):
+    """Set configuration value."""
+    paths = get_config_paths()
+    path = paths.get(scope, paths["global"])
+    
+    config = load_config(path) if path.exists() else {}
+    
+    # Set nested key
+    keys = key.split(".")
+    current = config
+    
+    for k in keys[:-1]:
+        if k not in current:
+            current[k] = {}
+        current = current[k]
+    
+    current[keys[-1]] = value
+    
+    save_config(path, config)
+
+
+def init_config() -> Dict[str, Path]:
+    """Initialize configuration structure."""
+    paths = get_config_paths()
+    
+    # Create global config if it doesn't exist
+    if not paths["global"].exists():
+        default_config = {
+            "default_model": "llama-3.2-3b",
+            "default_provider": "local",
+            "mcp": {
+                "allowed_paths": [str(Path.home())],
+                "enable_all_tools": True
+            },
+            "cluster": {
+                "default_name": "hanzo-local",
+                "default_port": 8000
+            }
+        }
+        save_config(paths["global"], default_config)
+    
+    return paths
+
+
+def get_default_model() -> str:
+    """Get default model from config or environment."""
+    return os.environ.get("HANZO_DEFAULT_MODEL") or get_config_value("default_model", "llama-3.2-3b")
+
+
+def get_api_key(provider: str) -> Optional[str]:
+    """Get API key for provider."""
+    # Check environment first
+    env_map = {
+        "openai": "OPENAI_API_KEY",
+        "anthropic": "ANTHROPIC_API_KEY",
+        "hanzo": "HANZO_API_KEY",
+        "groq": "GROQ_API_KEY",
+    }
+    
+    if env_key := env_map.get(provider.lower()):
+        if key := os.environ.get(env_key):
+            return key
+    
+    # Check config
+    return get_config_value(f"api_keys.{provider}")
+
+
+def is_local_preferred() -> bool:
+    """Check if local execution is preferred."""
+    return os.environ.get("HANZO_USE_LOCAL", "").lower() == "true" or get_config_value("prefer_local", False)

hanzo/utils/net_check.py

@@ -0,0 +1,107 @@
+"""Utilities for checking hanzo/net availability and dependencies."""
+
+import os
+import subprocess
+import sys
+from typing import Optional, Tuple
+from pathlib import Path
+
+
+def check_net_installation() -> Tuple[bool, Optional[str], Optional[str]]:
+    """Check if hanzo/net is available and properly configured.
+    
+    Returns:
+        Tuple of (is_available, net_path, python_exe)
+    """
+    # Check for hanzo/net in standard location
+    net_path = Path.home() / "work" / "hanzo" / "net"
+    if not net_path.exists():
+        net_path = Path("/Users/z/work/hanzo/net")
+    
+    if not net_path.exists():
+        # Try to import as package
+        try:
+            import net
+            return True, None, sys.executable
+        except ImportError:
+            return False, None, None
+    
+    # Check for venv
+    venv_python = net_path / ".venv" / "bin" / "python"
+    if venv_python.exists():
+        # Check if venv has required packages
+        result = subprocess.run(
+            [str(venv_python), "-c", "import net, scapy, mlx, transformers"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            return True, str(net_path), str(venv_python)
+        else:
+            # Venv exists but missing dependencies
+            return False, str(net_path), str(venv_python)
+    
+    # No venv, check system Python
+    result = subprocess.run(
+        [sys.executable, "-c", "import scapy"],
+        capture_output=True,
+        text=True
+    )
+    
+    if result.returncode == 0:
+        return True, str(net_path), sys.executable
+    else:
+        return False, str(net_path), None
+
+
+def install_net_dependencies(net_path: str, python_exe: str = None) -> bool:
+    """Install hanzo/net dependencies.
+    
+    Args:
+        net_path: Path to hanzo/net directory
+        python_exe: Python executable to use (optional)
+        
+    Returns:
+        True if installation successful
+    """
+    if python_exe is None:
+        python_exe = sys.executable
+    
+    # Install dependencies
+    result = subprocess.run(
+        [python_exe, "-m", "pip", "install", "-e", net_path],
+        capture_output=True,
+        text=True
+    )
+    
+    return result.returncode == 0
+
+
+def get_missing_dependencies(python_exe: str = None) -> list:
+    """Check which dependencies are missing for hanzo/net.
+    
+    Args:
+        python_exe: Python executable to check (default: sys.executable)
+        
+    Returns:
+        List of missing package names
+    """
+    if python_exe is None:
+        python_exe = sys.executable
+    
+    required_packages = [
+        "scapy", "mlx", "mlx_lm", "transformers", "tinygrad",
+        "aiohttp", "grpcio", "pydantic", "rich", "tqdm"
+    ]
+    
+    missing = []
+    for package in required_packages:
+        result = subprocess.run(
+            [python_exe, "-c", f"import {package}"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode != 0:
+            missing.append(package)
+    
+    return missing

hanzo/utils/output.py

@@ -0,0 +1,103 @@
+"""Output utilities for Hanzo CLI."""
+
+from functools import wraps
+from typing import Any, Callable
+
+from rich.console import Console
+from rich.theme import Theme
+
+# Custom theme
+hanzo_theme = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "red",
+    "success": "green",
+    "dim": "dim white",
+    "highlight": "bold cyan",
+})
+
+# Global console instance
+console = Console(theme=hanzo_theme)
+
+
+def handle_errors(func: Callable) -> Callable:
+    """Decorator to handle errors in CLI commands."""
+    @wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Interrupted[/yellow]")
+        except Exception as e:
+            console.print(f"[error]Error: {e}[/error]")
+            if console.is_debug:
+                console.print_exception()
+    
+    @wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Interrupted[/yellow]")
+        except Exception as e:
+            console.print(f"[error]Error: {e}[/error]")
+            if console.is_debug:
+                console.print_exception()
+    
+    if asyncio.iscoroutinefunction(func):
+        return async_wrapper
+    return sync_wrapper
+
+
+def print_json(data: Any, indent: int = 2):
+    """Print JSON data with syntax highlighting."""
+    console.print_json(data=data, indent=indent)
+
+
+def print_table(data: list[dict], title: str = None):
+    """Print data as a table."""
+    if not data:
+        console.print("[dim]No data[/dim]")
+        return
+    
+    from rich.table import Table
+    
+    table = Table(title=title)
+    
+    # Add columns from first row
+    for key in data[0].keys():
+        table.add_column(key.replace("_", " ").title())
+    
+    # Add rows
+    for row in data:
+        table.add_row(*[str(v) for v in row.values()])
+    
+    console.print(table)
+
+
+def confirm(message: str, default: bool = False) -> bool:
+    """Ask for confirmation."""
+    from rich.prompt import Confirm
+    return Confirm.ask(message, default=default)
+
+
+def prompt(message: str, default: str = None, password: bool = False) -> str:
+    """Prompt for input."""
+    from rich.prompt import Prompt
+    return Prompt.ask(message, default=default, password=password)
+
+
+def progress(description: str):
+    """Context manager for progress indicator."""
+    return console.status(description)
+
+
+# Export common methods
+print = console.print
+print_exception = console.print_exception
+rule = console.rule
+clear = console.clear
+
+
+# Import asyncio for the decorator
+import asyncio

{hanzo-0.2.3.dist-info → hanzo-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo
-Version: 0.2.3
+Version: 0.2.6
 Summary: Hanzo AI - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime
 Project-URL: Homepage, https://hanzo.ai
 Project-URL: Repository, https://github.com/hanzoai/python-sdk
@@ -23,8 +23,12 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Requires-Dist: click>=8.1.0
-Requires-Dist: hanzo-cli>=0.1.0
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
 Provides-Extra: agents
 Requires-Dist: hanzo-agents>=0.1.0; extra == 'agents'
 Requires-Dist: hanzo-network>=0.1.0; extra == 'agents'
@@ -33,7 +37,6 @@ Requires-Dist: hanzoai>=1.0.0; extra == 'ai'
 Provides-Extra: all
 Requires-Dist: hanzo-aci>=0.2.8; extra == 'all'
 Requires-Dist: hanzo-agents>=0.1.0; extra == 'all'
-Requires-Dist: hanzo-mcp-client>=0.1.0; extra == 'all'
 Requires-Dist: hanzo-mcp>=0.7.0; extra == 'all'
 Requires-Dist: hanzo-memory>=1.0.0; extra == 'all'
 Requires-Dist: hanzo-network>=0.1.0; extra == 'all'

hanzo-0.2.6.dist-info/RECORD

@@ -0,0 +1,28 @@
+hanzo/__init__.py,sha256=O8RZSC5Ib4DEBkXnYSP82LXK7VlKN08JKWtgFrrEVmU,168
+hanzo/__main__.py,sha256=qRjwG8-7MHPOy3czoyDP9VK1GhEaJJsVeZcz2AG9NV0,104
+hanzo/cli.py,sha256=jcoEVVPpa1vKlYh4PkJ8zbWBgQoH-vDUSabrXMYcQyw,9187
+hanzo/mcp_server.py,sha256=FBqcXhaJgV8_9O83H3fUy_pv4cV1707XCYm7FXaJeWY,422
+hanzo/repl.py,sha256=sC7EXbIBn7Oxnmzqey6neAg5-116gfpmrF0YFDYrhAQ,1014
+hanzo/commands/__init__.py,sha256=vXfIgioA6eakIYEN5ff5k_5BqOYQCJggD_MW40gb56w,138
+hanzo/commands/agent.py,sha256=YNemAPH-s1UqtkbZAvAHxCnxVF98iKOeC8PDFifDc74,3561
+hanzo/commands/auth.py,sha256=-2WTKAaOXEzFhyCWdFJv07SNqgBDl3CQvNUsOCD4bkY,11550
+hanzo/commands/chat.py,sha256=tegi0mU8UT3USrSso_bDroHF3GO5xajFkaAlS9mZDUY,6876
+hanzo/commands/cluster.py,sha256=GD0SrhdLe8u3kcYxsOImyFafPpe_CnyjNCf7uxesLJY,15603
+hanzo/commands/config.py,sha256=Nz_W8c6-tSGwh7B2TJ31E0Ge8XHS0LJj7ayehrk8HC0,7682
+hanzo/commands/mcp.py,sha256=jomUJdUj5guPLzBbRmEQ9KOo38RZhsDtLVRe3EcGicw,7555
+hanzo/commands/miner.py,sha256=KzJfGkoBrVsy0FwFefRgg-SyQ1diO_NENrhf5btyoko,11799
+hanzo/commands/network.py,sha256=qnb6mgbRM_3xjscZvr-wWPiW1biGFJ25zTglnWNrRPg,11671
+hanzo/commands/repl.py,sha256=JakB2yQVCRdthIundDGsvhVbFwQwKUqzcKLmgMlUzoY,6135
+hanzo/commands/tools.py,sha256=HD2CHcjrBE-Sqxt6B7mmM9J-9w9NgV2_CmXFeZW_Y7M,10929
+hanzo/interactive/__init__.py,sha256=izefD45Ztws902J5ZLjrbbJX4ONqfxleJylzEau60hY,73
+hanzo/interactive/dashboard.py,sha256=5JkJz9PX7KlT-54rACncHY80x_aWxV85atjuGJbaTD4,4066
+hanzo/interactive/repl.py,sha256=-SwCSxwIHLiZBJOEShvqa4tgg2c7YYMf00zYRHazyIY,5781
+hanzo/router/__init__.py,sha256=7Ulou75xQF8KKVzxOd4xXrmn3_Ti52M0NsAf6jXgGhk,913
+hanzo/utils/__init__.py,sha256=zmCH4YxefrpWmR-netV99UeECqrXjkKbi3ZjbcD79dw,68
+hanzo/utils/config.py,sha256=RU27eiSxGWAT9fI5-CjRdEJZEeT_xjMxjlMVeKC1gMg,4830
+hanzo/utils/net_check.py,sha256=tuIMpy44p5nkSTEco52y-Bhp58FVFMvx1S4oQn9BsKI,3032
+hanzo/utils/output.py,sha256=lROF8RDOkck7ySt1kiTlVlHZqx1E0B-PqcJc78ZHYOs,2694
+hanzo-0.2.6.dist-info/METADATA,sha256=vPZKal3vrQDQYr8LoNnBymZJOqz_UvUPyGD2TRWMO78,4315
+hanzo-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hanzo-0.2.6.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
+hanzo-0.2.6.dist-info/RECORD,,

hanzo-0.2.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-hanzo/__init__.py,sha256=1IEB7hlct652dQuQBka-Ric-R8sOBeCBHPKjuyqSALc,1951
-hanzo/cli.py,sha256=uLfrVV5FqW7D75N9rlYtHS5JwlXPiW6Wax9TVku6FRI,486
-hanzo/mcp_server.py,sha256=FBqcXhaJgV8_9O83H3fUy_pv4cV1707XCYm7FXaJeWY,422
-hanzo/repl.py,sha256=sC7EXbIBn7Oxnmzqey6neAg5-116gfpmrF0YFDYrhAQ,1014
-hanzo/router/__init__.py,sha256=OkhSdzExF0KBEfkDiGpGp6_schsPDG0mSw-arq98OHc,822
-hanzo-0.2.3.dist-info/METADATA,sha256=tBqDC48iL6Bcg1wsjMi9MA4b0VKXt4WCgEAMWuYZITw,4250
-hanzo-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hanzo-0.2.3.dist-info/entry_points.txt,sha256=pQLPMdqOXU_2BfTcMDhkqTCDNk_H6ApvYuSaWcuQOOw,171
-hanzo-0.2.3.dist-info/RECORD,,