hf2ollama-python-cli-tool 1.0.0__py3-none-any.whl

hf2ollama/__init__.py

@@ -0,0 +1,3 @@
+"""hf2ollama - Search, download, and import HuggingFace GGUF models into Ollama."""
+
+__version__ = "1.0.0"

hf2ollama/cli.py

@@ -0,0 +1,329 @@
+"""Click-based CLI for hf2ollama."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from hf2ollama import __version__
+
+console = Console()
+
+
+@click.group()
+@click.version_option(__version__, prog_name="hf2ollama")
+def main() -> None:
+    """Search, download, and import HuggingFace GGUF models into Ollama."""
+
+
+@main.command()
+@click.argument("repo")
+@click.option(
+    "--quant", "-q", default=None, help="Quantization (Q2_K, Q3_K_M, Q4_K_M, Q5_K_M, Q6_K, Q8_0)."
+)
+@click.option(
+    "--name", "-n", default=None, help="Ollama model name. Auto-generated if not specified."
+)
+@click.option("--keep-gguf", is_flag=True, help="Keep the GGUF file after import.")
+@click.option(
+    "--alt-download", is_flag=True, help="Use alternative PowerShell download (Windows only)."
+)
+@click.option("--ssl-fix", is_flag=True, help="Use OS certificate store for SSL verification.")
+def pull(
+    repo: str,
+    quant: str | None,
+    name: str | None,
+    keep_gguf: bool,
+    alt_download: bool,
+    ssl_fix: bool,
+) -> None:
+    """Download a GGUF model and import into Ollama.
+
+    REPO is a HuggingFace repo ID (e.g., bartowski/Qwen2.5-Coder-7B-Instruct-GGUF).
+    """
+    from hf2ollama.core.config import ensure_download_dir, load_config
+    from hf2ollama.core.ollama import create_model, find_ollama
+    from hf2ollama.hf.api import find_gguf_by_quant, get_download_url, list_gguf_files
+    from hf2ollama.hf.download import download_file, validate_file_size
+    from hf2ollama.modelfile.generator import (
+        detect_family,
+        generate_modelfile,
+        sanitize_model_name,
+    )
+    from hf2ollama.network.ssl_fix import apply_ssl_fix
+
+    config = load_config()
+    resolved_quant = quant or config.default_quant
+
+    if ssl_fix:
+        console.print("[dim]Configuring SSL certificates...[/dim]")
+        apply_ssl_fix(proxy=config.proxy)
+
+    try:
+        find_ollama()
+    except FileNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    console.print(f"[bold]Searching for {resolved_quant} in {repo}...[/bold]")
+
+    import httpx
+
+    try:
+        client = httpx.Client(timeout=15.0)
+        gguf = find_gguf_by_quant(repo, resolved_quant, client=client)
+
+        if gguf is None:
+            console.print(f"[yellow]No {resolved_quant} file found. Available files:[/yellow]")
+            files = list_gguf_files(repo, client=client)
+            for f in files:
+                console.print(f"  {f.filename} ({f.size_display})")
+            client.close()
+            raise SystemExit(1)
+
+        console.print(f"[green]Found:[/green] {gguf.filename} ({gguf.size_display})")
+
+        dl_dir = ensure_download_dir(config)
+        dest = dl_dir / gguf.filename
+        url = get_download_url(repo, gguf.filename)
+
+        if alt_download:
+            from hf2ollama.hf.alt_download import alt_download as _alt_dl
+
+            console.print("[bold yellow]Using alternative download method...[/bold yellow]")
+            dest = _alt_dl(repo, gguf.filename, str(dl_dir))
+        else:
+            console.print("[dim]Downloading...[/dim]")
+            dest = download_file(url, str(dest), client=client)
+
+        client.close()
+
+        if not validate_file_size(str(dest), gguf.size_bytes):
+            console.print("[red]File size mismatch - download may be incomplete.[/red]")
+            raise SystemExit(1)
+
+    except httpx.ConnectError as e:
+        err = str(e).lower()
+        if "ssl" in err or "certificate" in err:
+            console.print("[red]SSL certificate error.[/red]")
+            console.print("Try: [bold]hf2ollama pull --ssl-fix <repo>[/bold]")
+        else:
+            console.print(f"[red]Connection error: {e}[/red]")
+        raise SystemExit(1)
+
+    model_name = name or sanitize_model_name(gguf.filename)
+    family = detect_family(gguf.filename)
+    console.print(f"[dim]Detected family: {family}[/dim]")
+
+    modelfile_content = generate_modelfile(str(dest), family=family)
+    modelfile_path = dest.parent / "Modelfile"
+    modelfile_path.write_text(modelfile_content, encoding="utf-8")
+
+    console.print(f"[bold]Creating Ollama model: {model_name}[/bold]")
+    try:
+        output = create_model(model_name, str(modelfile_path))
+        console.print(f"[green]{output}[/green]")
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    modelfile_path.unlink(missing_ok=True)
+    if not keep_gguf:
+        dest.unlink(missing_ok=True)
+        console.print("[dim]Cleaned up GGUF file.[/dim]")
+
+    console.print(f"\n[bold green]Done![/bold green] Run: [bold]ollama run {model_name}[/bold]")
+
+
+@main.command()
+@click.argument("query")
+@click.option("--limit", "-l", default=15, help="Max results.")
+@click.option(
+    "--sort", "-s", default="downloads", type=click.Choice(["downloads", "likes", "lastModified"])
+)
+@click.option("--ssl-fix", is_flag=True, help="Use OS certificate store.")
+def search(query: str, limit: int, sort: str, ssl_fix: bool) -> None:
+    """Search HuggingFace for GGUF model repos."""
+    from hf2ollama.hf.api import search_gguf_repos
+    from hf2ollama.network.ssl_fix import apply_ssl_fix
+
+    if ssl_fix:
+        apply_ssl_fix()
+
+    results = search_gguf_repos(query, limit=limit, sort=sort)
+
+    if not results:
+        console.print("[yellow]No GGUF repos found.[/yellow]")
+        return
+
+    table = Table(title=f"GGUF repos matching '{query}'")
+    table.add_column("Repository", style="bold")
+    table.add_column("Downloads", justify="right")
+    table.add_column("Likes", justify="right")
+
+    for r in results:
+        table.add_row(r.repo_id, f"{r.downloads:,}", str(r.likes))
+
+    console.print(table)
+
+
+@main.command("list-files")
+@click.argument("repo")
+@click.option("--ssl-fix", is_flag=True, help="Use OS certificate store.")
+def list_files(repo: str, ssl_fix: bool) -> None:
+    """List GGUF files in a HuggingFace repo."""
+    from hf2ollama.hf.api import list_gguf_files
+    from hf2ollama.network.ssl_fix import apply_ssl_fix
+
+    if ssl_fix:
+        apply_ssl_fix()
+
+    files = list_gguf_files(repo)
+
+    if not files:
+        console.print(f"[yellow]No GGUF files found in {repo}.[/yellow]")
+        return
+
+    table = Table(title=f"GGUF files in {repo}")
+    table.add_column("File", style="bold")
+    table.add_column("Size", justify="right")
+
+    for f in files:
+        table.add_row(f.filename, f.size_display)
+
+    console.print(table)
+
+
+@main.command("list")
+def list_models() -> None:
+    """List locally installed Ollama models."""
+    from hf2ollama.core.ollama import list_models as _list
+
+    try:
+        models = _list()
+    except FileNotFoundError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    if not models:
+        console.print("[yellow]No Ollama models installed.[/yellow]")
+        return
+
+    table = Table(title="Ollama Models")
+    table.add_column("Name", style="bold")
+    table.add_column("Size", justify="right")
+    table.add_column("Modified")
+
+    for m in models:
+        table.add_row(m.name, m.size, m.modified)
+
+    console.print(table)
+
+
+@main.command()
+@click.argument("model_name")
+def remove(model_name: str) -> None:
+    """Remove an Ollama model."""
+    from hf2ollama.core.ollama import remove_model
+
+    try:
+        remove_model(model_name)
+        console.print(f"[green]Removed: {model_name}[/green]")
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+
+@main.command()
+@click.argument("model_name")
+def info(model_name: str) -> None:
+    """Show details about an Ollama model."""
+    from hf2ollama.core.ollama import show_model
+
+    try:
+        output = show_model(model_name)
+        console.print(output)
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+
+@main.command()
+@click.option(
+    "--vram", type=float, default=None, help="Available VRAM in GB. Auto-detected if not specified."
+)
+@click.option(
+    "--params", "-p", type=float, required=True,
+    help="Model parameter count in billions (e.g., 7 for 7B).",
+)
+def recommend(vram: float | None, params: float) -> None:
+    """Recommend quantization based on VRAM and model size."""
+    from hf2ollama.utils.vram import detect_vram, recommend_quant
+
+    if vram is None:
+        vram_info = detect_vram()
+        if vram_info:
+            vram = vram_info.available_gb
+            console.print(f"[dim]Detected: {vram_info.gpu_name} ({vram:.1f} GB)[/dim]")
+        else:
+            console.print("[yellow]Could not detect GPU. Specify --vram manually.[/yellow]")
+            raise SystemExit(1)
+
+    fits = recommend_quant(params, vram)
+
+    if not fits:
+        console.print(
+            f"[red]No quantization of a {params}B model fits in {vram:.1f} GB VRAM.[/red]"
+        )
+        console.print(f"[dim]Smallest (Q2_K) needs ~{params * 0.31 * 1.1:.1f} GB.[/dim]")
+        return
+
+    table = Table(title=f"Quantizations for {params}B model ({vram:.1f} GB VRAM)")
+    table.add_column("Quantization")
+    table.add_column("Est. Size", justify="right")
+    table.add_column("Fits?", justify="center")
+
+    from hf2ollama.utils.vram import QUANT_MULTIPLIERS
+
+    for quant, mult in sorted(QUANT_MULTIPLIERS.items(), key=lambda x: x[1]):
+        est = params * mult * 1.1
+        fits_str = "[green]Yes[/green]" if est <= vram else "[red]No[/red]"
+        table.add_row(quant, f"{est:.1f} GB", fits_str)
+
+    console.print(table)
+    console.print(f"\n[bold]Recommended:[/bold] {fits[-1]} (largest that fits)")
+
+
+@main.command("network-check")
+def network_check() -> None:
+    """Check HuggingFace reachability and SSL certificate status."""
+    from hf2ollama.network.detect import check_network
+
+    console.print("[bold]Checking network...[/bold]\n")
+    status = check_network()
+
+    table = Table(title="Network Diagnostics")
+    table.add_column("Check", style="bold")
+    table.add_column("Status")
+    table.add_column("Details")
+
+    hf_status = "[green]OK[/green]" if status.hf_reachable else "[red]UNREACHABLE[/red]"
+    table.add_row("HuggingFace reachable", hf_status, status.hf_error or "Connected")
+
+    ssl_status = "[green]OK[/green]" if status.hf_ssl_ok else "[red]FAIL[/red]"
+    table.add_row(
+        "SSL certificates",
+        ssl_status,
+        f"{status.cert_count} system certs" if status.system_certs_available else "Limited certs",
+    )
+
+    proxy_status = "[green]Set[/green]" if status.proxy_configured else "[dim]None[/dim]"
+    table.add_row("Proxy configured", proxy_status, status.proxy_url or "No proxy")
+
+    console.print(table)
+
+    if not status.hf_reachable:
+        console.print("\n[bold yellow]Suggestions:[/bold yellow]")
+        if not status.hf_ssl_ok:
+            console.print("  Try: [bold]hf2ollama pull --ssl-fix <repo>[/bold]")

hf2ollama/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules - Ollama binary integration and persistent configuration."""

hf2ollama/core/config.py

@@ -0,0 +1,73 @@
+"""Configuration management - persistent settings in ~/.hf2ollama/config.toml."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+CONFIG_DIR = Path.home() / ".hf2ollama"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+DEFAULT_DOWNLOAD_DIR = CONFIG_DIR / "downloads"
+
+
+@dataclass
+class Config:
+    """Persistent user configuration for hf2ollama."""
+
+    download_dir: str = str(DEFAULT_DOWNLOAD_DIR)
+    proxy: str | None = None
+    no_proxy: str | None = None
+    hf_token: str | None = None
+    hf_endpoint: str | None = None
+    default_quant: str = "Q4_K_M"
+
+
+def load_config() -> Config:
+    """Load config from file, falling back to defaults."""
+    if not CONFIG_FILE.exists():
+        return Config()
+
+    with open(CONFIG_FILE, "rb") as f:
+        data = tomllib.load(f)
+
+    return Config(
+        download_dir=data.get("download_dir", str(DEFAULT_DOWNLOAD_DIR)),
+        proxy=data.get("proxy"),
+        no_proxy=data.get("no_proxy"),
+        hf_token=data.get("hf_token") or os.environ.get("HF_TOKEN"),
+        hf_endpoint=data.get("hf_endpoint"),
+        default_quant=data.get("default_quant", "Q4_K_M"),
+    )
+
+
+def save_config(config: Config) -> None:
+    """Save config to TOML file."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    lines = []
+    lines.append(f'download_dir = "{config.download_dir}"')
+    lines.append(f'default_quant = "{config.default_quant}"')
+    if config.proxy:
+        lines.append(f'proxy = "{config.proxy}"')
+    if config.no_proxy:
+        lines.append(f'no_proxy = "{config.no_proxy}"')
+    if config.hf_token:
+        lines.append(f'hf_token = "{config.hf_token}"')
+    if config.hf_endpoint:
+        lines.append(f'hf_endpoint = "{config.hf_endpoint}"')
+
+    CONFIG_FILE.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def ensure_download_dir(config: Config) -> Path:
+    """Create and return the download directory."""
+    dl_dir = Path(config.download_dir)
+    dl_dir.mkdir(parents=True, exist_ok=True)
+    return dl_dir

hf2ollama/core/ollama.py

@@ -0,0 +1,137 @@
+"""Ollama binary interaction - find, create, list, remove models."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OllamaModel:
+    """Metadata for a locally installed Ollama model."""
+
+    name: str
+    size: str
+    modified: str
+    model_id: str = ""
+
+
+def find_ollama() -> str:
+    """Find the ollama executable."""
+    if os.name == "nt":
+        local_path = (
+            Path(os.environ.get("USERPROFILE", "")) / "AppData/Local/Programs/Ollama/ollama.exe"
+        )
+        if local_path.exists():
+            return str(local_path)
+
+    found = shutil.which("ollama")
+    if found:
+        return found
+
+    raise FileNotFoundError("Ollama not found. Install from https://ollama.com/download")
+
+
+def create_model(
+    name: str,
+    modelfile_path: str,
+    working_dir: str | None = None,
+) -> str:
+    """Run `ollama create` with a Modelfile."""
+    ollama = find_ollama()
+    cwd = working_dir or str(Path(modelfile_path).parent)
+
+    result = subprocess.run(
+        [ollama, "create", name, "-f", "Modelfile"],
+        capture_output=True,
+        text=True,
+        cwd=cwd,
+        timeout=600,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"ollama create failed: {result.stderr or result.stdout}")
+
+    return result.stdout.strip()
+
+
+def list_models() -> list[OllamaModel]:
+    """List locally installed Ollama models."""
+    ollama = find_ollama()
+
+    result = subprocess.run(
+        [ollama, "list"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"ollama list failed: {result.stderr}")
+
+    models = []
+    lines = result.stdout.strip().splitlines()
+    for line in lines[1:]:
+        parts = line.split()
+        if len(parts) >= 3:
+            models.append(
+                OllamaModel(
+                    name=parts[0],
+                    model_id=parts[1] if len(parts) > 1 else "",
+                    size=parts[2]
+                    + (" " + parts[3] if len(parts) > 3 and parts[3] in ("MB", "GB", "KB") else ""),
+                    modified=" ".join(parts[4:]) if len(parts) > 4 else "",
+                )
+            )
+    return models
+
+
+def remove_model(name: str) -> str:
+    """Remove an Ollama model."""
+    ollama = find_ollama()
+
+    result = subprocess.run(
+        [ollama, "rm", name],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"ollama rm failed: {result.stderr}")
+
+    return result.stdout.strip()
+
+
+def show_model(name: str) -> str:
+    """Show model details."""
+    ollama = find_ollama()
+
+    result = subprocess.run(
+        [ollama, "show", name],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"ollama show failed: {result.stderr}")
+
+    return result.stdout.strip()
+
+
+def model_exists(name: str) -> bool:
+    """Check if a model is already installed."""
+    try:
+        models = list_models()
+        base_name = name.split(":")[0]
+        return any(base_name in m.name for m in models)
+    except (RuntimeError, FileNotFoundError, subprocess.SubprocessError) as e:
+        logger.debug("model_exists check failed: %s", e)
+        return False

hf2ollama/hf/__init__.py

@@ -0,0 +1 @@
+"""HuggingFace integration - API client and file downloads."""

hf2ollama/hf/alt_download.py

@@ -0,0 +1,78 @@
+"""Alternative download method using embedded PowerShell script (Windows only)."""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def is_alt_download_available() -> bool:
+    """Check if the PowerShell-based download method is available."""
+    if sys.platform != "win32":
+        return False
+
+    pwsh = shutil.which("pwsh")
+    return pwsh is not None
+
+
+def get_script_path() -> Path:
+    """Get path to the embedded HfDownload.ps1 script."""
+    script_dir = Path(__file__).parent.parent / "scripts"
+    return script_dir / "HfDownload.ps1"
+
+
+def alt_download(
+    repo: str,
+    filename: str,
+    out_dir: str,
+) -> Path:
+    """Download a file using the PowerShell-based download method.
+
+    Requires Windows and PowerShell 7 (pwsh).
+
+    Raises RuntimeError if the download fails or prerequisites are not met.
+    """
+    if not is_alt_download_available():
+        raise RuntimeError(
+            "Alternative download requires Windows + PowerShell 7 (pwsh)."
+        )
+
+    script = get_script_path()
+    if not script.exists():
+        raise RuntimeError(f"HfDownload.ps1 not found at {script}")
+
+    cmd = [
+        "pwsh",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        str(script),
+        "-Repo",
+        repo,
+        "-File",
+        filename,
+        "-OutDir",
+        out_dir,
+    ]
+
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        timeout=3600,
+    )
+
+    if result.returncode != 0:
+        stderr = result.stderr.strip()
+        raise RuntimeError(f"Alternative download failed: {stderr or result.stdout}")
+
+    dest = Path(out_dir) / filename
+    if not dest.exists():
+        raise RuntimeError(f"Download completed but file not found at {dest}")
+
+    return dest