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

hanzo/repl.py

@@ -1,6 +1,7 @@
 """REPL and AI chat entry points for Hanzo."""
 
 import sys
+
 import click
 
 
@@ -9,11 +10,15 @@ def ai_chat():
     try:
         # Use hanzo-router instead of litellm for AI routing
         from hanzo_repl.cli import main as repl_main
+
         # Pass AI chat mode
         sys.argv = [sys.argv[0], "--mode", "ai"]
         repl_main()
     except ImportError:
-        click.echo("Error: hanzo-repl or hanzo-router is not installed. Please run: pip install hanzo[ai] or pip install hanzo[all]", err=True)
+        click.echo(
+            "Error: hanzo-repl or hanzo-router is not installed. Please run: pip install hanzo[ai] or pip install hanzo[all]",
+            err=True,
+        )
         sys.exit(1)
 
 
@@ -21,15 +26,20 @@ def repl_main():
     """Start the Hanzo REPL interface (hanzo/repl)."""
     try:
         from hanzo_repl.cli import main as repl_cli_main
+
         repl_cli_main()
     except ImportError:
-        click.echo("Error: hanzo-repl is not installed. Please run: pip install hanzo[all]", err=True)
+        click.echo(
+            "Error: hanzo-repl is not installed. Please run: pip install hanzo[all]",
+            err=True,
+        )
         sys.exit(1)
 
 
 if __name__ == "__main__":
     import os
+
     if os.path.basename(sys.argv[0]) in ["ai", "chat"]:
         ai_chat()
     else:
-        repl_main()
+        repl_main()

hanzo/router/__init__.py

@@ -3,25 +3,37 @@
 try:
     # Import directly from the installed router package
     import router
-    from router import Router, completion, acompletion, embedding, aembedding
-    
+    from router import Router, embedding, aembedding, completion, acompletion
+
     # Re-export the entire router module
-    __all__ = ["router", "Router", "completion", "acompletion", "embedding", "aembedding"]
-    
+    __all__ = [
+        "router",
+        "Router",
+        "completion",
+        "acompletion",
+        "embedding",
+        "aembedding",
+    ]
+
     # Make router available as a submodule
     import sys
-    sys.modules['hanzo.router'] = router
-    
+
+    sys.modules["hanzo.router"] = router
+
 except ImportError as e:
     # If router is not installed, provide helpful error
     import sys
+
     print(f"Error importing router: {e}", file=sys.stderr)
-    print("Please install router from the main repository: pip install -e /Users/z/work/hanzo/router", file=sys.stderr)
-    
+    print(
+        "Please install router from the main repository: pip install -e /Users/z/work/hanzo/router",
+        file=sys.stderr,
+    )
+
     # Define placeholders to avoid complete failure
     router = None
     Router = None
     completion = None
     acompletion = None
     embedding = None
-    aembedding = None
+    aembedding = None

hanzo/utils/__init__.py

@@ -1,3 +1,3 @@
 """Utility modules for Hanzo CLI."""
 
-__all__ = ["config", "output"]
+__all__ = ["config", "output"]

hanzo/utils/config.py

@@ -1,9 +1,9 @@
 """Configuration utilities for Hanzo CLI."""
 
-import json
 import os
-from pathlib import Path
+import json
 from typing import Any, Dict, Optional
+from pathlib import Path
 
 import yaml
 
@@ -11,17 +11,21 @@ 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"
+        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):
@@ -32,7 +36,7 @@ def get_config_paths() -> Dict[str, Path]:
     else:
         # Default local path even if it doesn't exist
         paths["local"] = cwd / ".hanzo" / "config.yaml"
-    
+
     return paths
 
 
@@ -40,7 +44,7 @@ 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":
@@ -54,7 +58,7 @@ def load_config(path: Path) -> Dict[str, Any]:
 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)
@@ -65,31 +69,31 @@ def save_config(path: Path, config: Dict[str, Any]):
 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]
@@ -102,49 +106,45 @@ 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
-            }
+            "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")
+    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]:
@@ -156,15 +156,17 @@ def get_api_key(provider: str) -> Optional[str]:
         "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)
+    return os.environ.get("HANZO_USE_LOCAL", "").lower() == "true" or get_config_value(
+        "prefer_local", False
+    )

hanzo/utils/net_check.py

@@ -1,33 +1,33 @@
 """Utilities for checking hanzo/net availability and dependencies."""
 
-import os
-import subprocess
 import sys
-from typing import Optional, Tuple
+import subprocess
+from typing import Tuple, Optional
 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)
     """
     # First try to import as PyPI package (hanzo-net)
     try:
         import net
+
         return True, None, sys.executable
     except ImportError:
         pass
-    
+
     # For development: 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():
         return False, None, None
-    
+
     # Check for venv
     venv_python = net_path / ".venv" / "bin" / "python"
     if venv_python.exists():
@@ -35,21 +35,19 @@ def check_net_installation() -> Tuple[bool, Optional[str], Optional[str]]:
         result = subprocess.run(
             [str(venv_python), "-c", "import net, scapy, mlx, transformers"],
             capture_output=True,
-            text=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
+        [sys.executable, "-c", "import scapy"], capture_output=True, text=True
     )
-    
+
     if result.returncode == 0:
         return True, str(net_path), sys.executable
     else:
@@ -58,52 +56,58 @@ def check_net_installation() -> Tuple[bool, Optional[str], Optional[str]]:
 
 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
+        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"
+        "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
+            [python_exe, "-c", f"import {package}"], capture_output=True, text=True
         )
         if result.returncode != 0:
             missing.append(package)
-    
-    return missing
+
+    return missing

hanzo/utils/output.py

@@ -1,20 +1,22 @@
 """Output utilities for Hanzo CLI."""
 
-from functools import wraps
 from typing import Any, Callable
+from functools import wraps
 
-from rich.console import Console
 from rich.theme import Theme
+from rich.console import Console
 
 # Custom theme
-hanzo_theme = Theme({
-    "info": "cyan",
-    "warning": "yellow",
-    "error": "red",
-    "success": "green",
-    "dim": "dim white",
-    "highlight": "bold cyan",
-})
+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)
@@ -22,6 +24,7 @@ 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:
@@ -32,7 +35,7 @@ def handle_errors(func: Callable) -> Callable:
             console.print(f"[error]Error: {e}[/error]")
             if console.is_debug:
                 console.print_exception()
-    
+
     @wraps(func)
     def sync_wrapper(*args, **kwargs):
         try:
@@ -43,7 +46,7 @@ def handle_errors(func: Callable) -> Callable:
             console.print(f"[error]Error: {e}[/error]")
             if console.is_debug:
                 console.print_exception()
-    
+
     if asyncio.iscoroutinefunction(func):
         return async_wrapper
     return sync_wrapper
@@ -59,31 +62,33 @@ def print_table(data: list[dict], title: str = None):
     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)
 
 
@@ -100,4 +105,4 @@ clear = console.clear
 
 
 # Import asyncio for the decorator
-import asyncio
+import asyncio

hanzo-0.3.7.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: hanzo
+Version: 0.3.7
+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
+Project-URL: Documentation, https://docs.hanzo.ai/cli
+Project-URL: Bug Tracker, https://github.com/hanzoai/python-sdk/issues
+Author-email: Hanzo AI <dev@hanzo.ai>
+Keywords: agents,ai,cli,hanzo,llm,local-ai,mcp,private-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.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-net>=0.1.12
+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.2; extra == 'agents'
+Provides-Extra: ai
+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>=0.7.0; extra == 'all'
+Requires-Dist: hanzo-memory>=1.0.0; extra == 'all'
+Requires-Dist: hanzo-network>=0.1.2; extra == 'all'
+Requires-Dist: hanzo-repl>=0.1.0; extra == 'all'
+Requires-Dist: hanzoai>=1.0.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: hanzo-aci>=0.2.8; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: hanzo-mcp>=0.7.0; extra == 'mcp'
+Provides-Extra: repl
+Requires-Dist: hanzo-repl>=0.1.0; extra == 'repl'
+Provides-Extra: router
+Description-Content-Type: text/markdown
+
+# Hanzo AI - Complete AI Infrastructure Platform
+
+The main SDK for the Hanzo AI ecosystem, providing unified access to all Hanzo tools and services.
+
+## Installation
+
+```bash
+# Install base package with CLI
+pip install hanzo
+
+# Install with all components
+pip install hanzo[all]
+
+# Install specific components
+pip install hanzo[ai]      # AI SDK (same as standalone hanzoai package)
+pip install hanzo[router]  # LLM gateway router (replaces litellm)
+pip install hanzo[mcp]     # Model Context Protocol server
+pip install hanzo[agents]  # Agent runtime and orchestration
+pip install hanzo[repl]    # Interactive REPL with AI chat
+```
+
+## Features
+
+- **Unified LLM Gateway**: Use `hanzo.router` instead of litellm for 100+ LLM providers
+- **MCP Integration**: Full Model Context Protocol support for AI tools
+- **Agent Runtime**: Build and deploy AI agents with the agent framework
+- **Interactive REPL**: Chat with AI models directly from the command line
+- **Complete SDK**: Import all Hanzo components from a single package
+
+## Quick Start
+
+### Command Line
+```bash
+# Main CLI
+hanzo --help
+
+# Start MCP server
+hanzo-mcp
+
+# Interactive AI chat
+hanzo-ai
+hanzo-chat
+
+# REPL interface
+hanzo-repl
+```
+
+### Python SDK
+```python
+import hanzo
+
+# Use router for LLM calls (replaces litellm)
+from hanzo import router
+response = router.completion(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+
+# Use agents
+from hanzo import Agent, Network
+agent = Agent(name="assistant")
+
+# Use MCP tools
+from hanzo import Tool, MCPServer
+
+# Access AI SDK
+from hanzo import Client
+client = Client(api_key="...")
+```
+
+## Components
+
+- **hanzo.router**: Unified LLM gateway (replaces litellm)
+- **hanzo.mcp**: Model Context Protocol server and tools
+- **hanzo.agents**: Agent runtime and orchestration
+- **hanzo.memory**: Memory systems for agents
+- **hanzo.Client**: Main AI SDK client
+
+## Documentation
+
+- [Hanzo AI Docs](https://docs.hanzo.ai)
+- [Router Documentation](https://docs.hanzo.ai/router)
+- [MCP Documentation](https://docs.hanzo.ai/mcp)
+- [Agent Documentation](https://docs.hanzo.ai/agents)