coone-ailab-cli 0.0.5__py3-none-any.whl

ailab_eval/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.0.1"

ailab_eval/__main__.py

@@ -0,0 +1,4 @@
+from .launcher import main
+
+if __name__ == "__main__":
+    main()

ailab_eval/launcher.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+DEFAULT_REPO = "coone-ai/heimdal"
+API_TIMEOUT_SECONDS = 20
+DOWNLOAD_TIMEOUT_SECONDS = 120
+
+
+def _normalize_os() -> str:
+    raw = platform.system().lower()
+    if raw == "darwin":
+        return "darwin"
+    if raw == "linux":
+        return "linux"
+    if raw == "windows":
+        return "windows"
+    raise RuntimeError(f"Unsupported operating system: {raw}")
+
+
+def _normalize_arch() -> str:
+    raw = platform.machine().lower()
+    if raw in {"x86_64", "amd64"}:
+        return "amd64"
+    if raw in {"arm64", "aarch64"}:
+        return "arm64"
+    raise RuntimeError(f"Unsupported architecture: {raw}")
+
+
+def _default_cache_dir() -> Path:
+    custom = os.environ.get("HEIMDAL_INSTALL_CACHE_DIR", "").strip()
+    if custom:
+        return Path(custom).expanduser()
+
+    if os.name == "nt":
+        base = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
+        return Path(base) / "coone-ailab-cli" / "cache"
+
+    xdg = os.environ.get("XDG_CACHE_HOME")
+    if xdg:
+        return Path(xdg) / "coone-ailab-cli"
+    return Path.home() / ".cache" / "coone-ailab-cli"
+
+
+def _ensure_tag_prefix(version: str) -> str:
+    version = version.strip()
+    if not version:
+        raise RuntimeError("Empty version value")
+    if version.startswith("v"):
+        return version
+    return f"v{version}"
+
+
+def _fetch_latest_tag(repo: str) -> str:
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    req = urllib.request.Request(
+        url,
+        headers={
+            "Accept": "application/vnd.github+json",
+            "User-Agent": "coone-ailab-cli-bootstrap",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=API_TIMEOUT_SECONDS) as resp:
+        payload = json.loads(resp.read().decode("utf-8"))
+    tag = str(payload.get("tag_name", "")).strip()
+    if not tag:
+        raise RuntimeError("GitHub latest release payload does not contain tag_name")
+    return _ensure_tag_prefix(tag)
+
+
+def _resolve_tag(repo: str) -> str:
+    env_version = os.environ.get("HEIMDAL_VERSION", "").strip()
+    if env_version:
+        return _ensure_tag_prefix(env_version)
+    return _fetch_latest_tag(repo)
+
+
+def _archive_name(tag: str, os_name: str, arch: str) -> str:
+    ext = "zip" if os_name == "windows" else "tar.gz"
+    return f"heimdal_{tag}_{os_name}_{arch}.{ext}"
+
+
+def _download(url: str, dest: Path, timeout: int) -> None:
+    req = urllib.request.Request(url, headers={"User-Agent": "coone-ailab-cli-bootstrap"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp, dest.open("wb") as out:
+        shutil.copyfileobj(resp, out)
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _parse_checksum_file(checksum_file: Path, archive_name: str) -> Optional[str]:
+    for line in checksum_file.read_text(encoding="utf-8", errors="replace").splitlines():
+        line = line.strip()
+        if not line or "  " not in line:
+            continue
+        checksum, filename = line.split("  ", 1)
+        if Path(filename.strip()).name == archive_name:
+            return checksum.strip().lower()
+    return None
+
+
+def _verify_checksum_if_available(repo: str, tag: str, archive_name: str, archive_path: Path) -> None:
+    checksum_name = f"heimdal_{tag}_checksums.txt"
+    checksum_url = f"https://github.com/{repo}/releases/download/{tag}/{checksum_name}"
+    with tempfile.TemporaryDirectory(prefix="coone-ailab-cli-checksum-") as td:
+        checksum_path = Path(td) / checksum_name
+        try:
+            _download(checksum_url, checksum_path, timeout=API_TIMEOUT_SECONDS)
+        except Exception:
+            return
+
+        expected = _parse_checksum_file(checksum_path, archive_name)
+        if not expected:
+            return
+
+        actual = _sha256_file(archive_path).lower()
+        if actual != expected:
+            raise RuntimeError(
+                f"Checksum verification failed for {archive_name}: expected {expected}, got {actual}"
+            )
+
+
+def _extract_binary(archive_path: Path, target_path: Path, os_name: str) -> None:
+    binary_name = "heimdal.exe" if os_name == "windows" else "heimdal"
+    with tempfile.TemporaryDirectory(prefix="coone-ailab-cli-extract-") as td:
+        temp_dir = Path(td)
+        if archive_path.suffix == ".zip":
+            with zipfile.ZipFile(archive_path, "r") as zf:
+                zf.extractall(temp_dir)
+        else:
+            with tarfile.open(archive_path, "r:gz") as tf:
+                tf.extractall(temp_dir)
+
+        candidates = list(temp_dir.rglob(binary_name))
+        if not candidates:
+            raise RuntimeError(f"Could not find {binary_name} in downloaded archive")
+
+        source = candidates[0]
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(source), str(target_path))
+
+    if os_name != "windows":
+        current_mode = target_path.stat().st_mode
+        target_path.chmod(current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def _ensure_binary(cache_dir: Path, repo: str, tag: str, os_name: str, arch: str) -> Path:
+    binary_name = "heimdal.exe" if os_name == "windows" else "heimdal"
+    bin_dir = cache_dir / "binaries" / tag / f"{os_name}-{arch}"
+    binary_path = bin_dir / binary_name
+    if binary_path.exists():
+        return binary_path
+
+    archive = _archive_name(tag, os_name, arch)
+    download_url = f"https://github.com/{repo}/releases/download/{tag}/{archive}"
+    bin_dir.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory(prefix="coone-ailab-cli-download-") as td:
+        archive_path = Path(td) / archive
+        try:
+            _download(download_url, archive_path, timeout=DOWNLOAD_TIMEOUT_SECONDS)
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(
+                f"Failed to download release asset ({exc.code}): {download_url}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise RuntimeError(f"Failed to connect while downloading: {download_url}") from exc
+
+        _verify_checksum_if_available(repo, tag, archive, archive_path)
+        _extract_binary(archive_path, binary_path, os_name)
+
+    return binary_path
+
+
+def _run_binary(binary_path: Path, argv: list[str]) -> int:
+    cmd = [str(binary_path), *argv]
+    proc = subprocess.run(cmd)
+    return int(proc.returncode)
+
+
+def main() -> None:
+    repo = os.environ.get("HEIMDAL_REPO", DEFAULT_REPO).strip() or DEFAULT_REPO
+    cache_dir = _default_cache_dir()
+    try:
+        os_name = _normalize_os()
+        arch = _normalize_arch()
+        tag = _resolve_tag(repo)
+        binary = _ensure_binary(cache_dir, repo, tag, os_name, arch)
+        rc = _run_binary(binary, sys.argv[1:])
+    except Exception as exc:
+        print(f"heimdal bootstrap error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    sys.exit(rc)

coone_ailab_cli-0.0.5.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: coone-ailab-cli
+Version: 0.0.5
+Summary: Python bootstrap launcher for Heimdal CLI
+Author: Co-one
+License: MIT
+Project-URL: Homepage, https://github.com/coone-ai/heimdal
+Project-URL: Source, https://github.com/coone-ai/heimdal
+Project-URL: Issues, https://github.com/coone-ai/heimdal/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# coone-ailab-cli
+
+`coone-ailab-cli` is a lightweight Python bootstrap package for Heimdal CLI.
+
+After installation, running `heimdal` downloads the matching Heimdal binary from
+GitHub Releases (if needed), stores it in a local cache, and forwards all
+arguments to the binary.
+
+## Install
+
+```bash
+pip install coone-ailab-cli
+```
+
+## Recommended
+
+```bash
+pipx install coone-ailab-cli
+```
+
+## Environment Variables
+
+- `HEIMDAL_REPO`: GitHub repository in `owner/name` format.  
+  Default: `coone-ai/heimdal`
+- `HEIMDAL_VERSION`: Release tag to pin (for example `v0.0.1`).  
+  Default: latest release
+- `HEIMDAL_INSTALL_CACHE_DIR`: Cache directory for downloaded binaries
+
+## Publish
+
+Quick release (version bump + commit + tag + push):
+
+```bash
+./scripts/release.sh 0.0.2
+```
+
+Local only (no push):
+
+```bash
+./scripts/release.sh 0.0.2 --no-push
+```
+
+Manual publish:
+
+```bash
+./scripts/publish.sh
+```
+
+CI publishing is also configured at:
+
+- `.github/workflows/release.yml`
+
+Tag format:
+
+```bash
+git tag v0.0.1
+git push origin v0.0.1
+```

coone_ailab_cli-0.0.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+ailab_eval/__init__.py,sha256=8VOm8ou-5WyjwJ8ypdRd5yC_Y02tb-dXMJ1Jtwg8hv8,49
+ailab_eval/__main__.py,sha256=YCgbcXzdcyqg0_oLgtLG-AorilbdQfnpndSqKjlVyPY,66
+ailab_eval/launcher.py,sha256=sGFSvp3VpWge3AKcJTh3KA4aNAb3Hw6f1Rt3y3PnpnM,7240
+coone_ailab_cli-0.0.5.dist-info/METADATA,sha256=WM75zmYZHNQ2Y2eOs937y11ZPSPIrkd_coZlDyR7XIY,1655
+coone_ailab_cli-0.0.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coone_ailab_cli-0.0.5.dist-info/entry_points.txt,sha256=incn-mZBHHEHACpQzaaXpb8expwq71APwaZ3UaJb8o4,86
+coone_ailab_cli-0.0.5.dist-info/top_level.txt,sha256=QRi4OG64_4yH00u4o9W7SRzOOFSM295VF0-iE2um-Sw,11
+coone_ailab_cli-0.0.5.dist-info/RECORD,,

coone_ailab_cli-0.0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

coone_ailab_cli-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+coval = ailab_eval.launcher:main
+heimdal = ailab_eval.launcher:main

coone_ailab_cli-0.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+ailab_eval