ixt-cli 0.8.0__py3-none-any.whl

ixt/backends/python.py

@@ -0,0 +1,234 @@
+"""Python backend — isolated venvs via uv."""
+
+from __future__ import annotations
+
+import configparser
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ixt.config.settings import Settings, get_settings
+from ixt.core.backend import BackendType
+from ixt.libs.shell import shell_run
+from ixt.platform import get_binary_extension, is_windows
+
+
+class BinaryNotFoundError(FileNotFoundError):
+    """Raised when a binary is missing from the tool environment."""
+
+    def __init__(self, binary_name: str, env_dir: Path, available: list[str]):
+        self.binary_name = binary_name
+        self.env_dir = env_dir
+        self.available = available
+        avail = ", ".join(available) or "<none>"
+        super().__init__(f"Binary '{binary_name}' not found in {env_dir}. Available: {avail}")
+
+
+# ---------------------------------------------------------------------------
+# Filesystem helpers
+# ---------------------------------------------------------------------------
+
+
+def _iter_executables(directory: Path) -> list[Path]:
+    """List executable files in *directory*."""
+    if not directory.exists():
+        return []
+    if is_windows():
+        allowed = {".exe", ".bat", ".cmd", ".ps1"}
+        return sorted(p for p in directory.iterdir() if p.is_file() and p.suffix.lower() in allowed)
+    return sorted(p for p in directory.iterdir() if p.is_file() and os.access(p, os.X_OK))
+
+
+# ---------------------------------------------------------------------------
+# Console-scripts extraction (Python-specific metadata)
+# ---------------------------------------------------------------------------
+
+
+def _find_site_packages(venv_dir: Path) -> Path | None:
+    """Locate site-packages inside a ``.venv``."""
+    candidates = [venv_dir / "Lib" / "site-packages"]
+    candidates.extend(sorted((venv_dir / "lib").glob("python*/site-packages")))
+    for c in candidates:
+        if c.exists():
+            return c
+    return None
+
+
+def _dist_info_package_name(dist_info_dir: Path) -> str:
+    metadata = dist_info_dir / "METADATA"
+    if not metadata.exists():
+        return ""
+    with metadata.open(encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("Name:"):
+                return line.split(":", 1)[1].strip()
+    return ""
+
+
+def _find_console_scripts(
+    site_packages: Path,
+) -> dict[str, dict[str, str]]:
+    """Map package names to their console_scripts entry points."""
+    scripts: dict[str, dict[str, str]] = {}
+    for dist in sorted(site_packages.glob("*.dist-info")):
+        pkg = _dist_info_package_name(dist)
+        if not pkg:
+            continue
+        ep = dist / "entry_points.txt"
+        if not ep.exists():
+            continue
+        parser = configparser.ConfigParser()
+        parser.read(ep, encoding="utf-8")
+        if not parser.has_section("console_scripts"):
+            continue
+        scripts[pkg] = dict(parser.items("console_scripts"))
+    return scripts
+
+
+def _build_pip_metadata(
+    venv_dir: Path,
+) -> dict[str, dict[str, dict[str, str]]]:
+    site = _find_site_packages(venv_dir)
+    if site is None:
+        return {"console_scripts": {}}
+    return {"console_scripts": _find_console_scripts(site)}
+
+
+def _write_pip_metadata(env_dir: Path, venv_dir: Path) -> Path:
+    path = env_dir / "pip_metadata.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(_build_pip_metadata(venv_dir), f, indent=2)
+        f.write("\n")
+    return path
+
+
+# ---------------------------------------------------------------------------
+# PythonBackend
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class PythonBackend:
+    """Install Python CLI tools in isolated venvs via ``uv``."""
+
+    settings: Settings = field(default_factory=get_settings)
+    backend_type: BackendType = field(default=BackendType.PYTHON, init=False)
+
+    # -- path helpers -------------------------------------------------------
+
+    def _venv_dir(self, env_dir: Path) -> Path:
+        return env_dir / ".venv"
+
+    def _bin_dir(self, env_dir: Path) -> Path:
+        return self._venv_dir(env_dir) / ("Scripts" if is_windows() else "bin")
+
+    def _python(self, env_dir: Path) -> Path:
+        name = "python.exe" if is_windows() else "python"
+        return self._bin_dir(env_dir) / name
+
+    def _uv(self) -> str:
+        from ixt.core.bootstrap import ensure_uv
+
+        return ensure_uv(self.settings)
+
+    def _run_uv_pip(self, env_dir: Path, command: str, *args: str) -> str:
+        result = shell_run(
+            [
+                self._uv(),
+                "pip",
+                command,
+                "--python",
+                str(self._python(env_dir)),
+                *args,
+            ],
+            capture_output=True,
+            check=True,
+        )
+        return result.stdout.strip() if result.stdout else ""
+
+    # -- Backend protocol ---------------------------------------------------
+
+    def env_exists(self, env_dir: Path) -> bool:
+        return self._venv_dir(env_dir).exists()
+
+    def create_env(self, env_dir: Path) -> bool:
+        env_dir.mkdir(parents=True, exist_ok=True)
+        if self.env_exists(env_dir):
+            return False
+        shell_run(
+            [self._uv(), "venv", str(self._venv_dir(env_dir))],
+            capture_output=True,
+            check=True,
+        )
+        return True
+
+    def install_packages(
+        self,
+        env_dir: Path,
+        specs: list[str],
+        *,
+        upgrade: bool = False,
+    ) -> None:
+        args: list[str] = []
+        if upgrade:
+            args.append("--upgrade")
+        args.extend(specs)
+        self._run_uv_pip(env_dir, "install", *args)
+        _write_pip_metadata(env_dir, self._venv_dir(env_dir))
+
+    def uninstall_package(self, env_dir: Path, package: str) -> None:
+        self._run_uv_pip(env_dir, "uninstall", package)
+
+    def find_binaries(self, env_dir: Path) -> list[Path]:
+        return _iter_executables(self._bin_dir(env_dir))
+
+    def get_package_binaries(self, env_dir: Path, package_name: str) -> dict[str, str]:
+        meta_file = env_dir / "pip_metadata.json"
+        if meta_file.exists():
+            with meta_file.open(encoding="utf-8") as f:
+                data = json.load(f)
+            return data.get("console_scripts", {}).get(package_name, {})
+        # Fallback: live scan when no cached metadata exists.
+        site = _find_site_packages(self._venv_dir(env_dir))
+        if site is None:
+            return {}
+        return _find_console_scripts(site).get(package_name, {})
+
+    def installed_version(self, env_dir: Path, package_name: str) -> str | None:
+        # Try reading version from dist-info METADATA (avoids subprocess).
+        site = _find_site_packages(self._venv_dir(env_dir))
+        if site is not None:
+            normalized = package_name.replace("-", "_").lower()
+            for dist in site.glob("*.dist-info"):
+                if not dist.name.lower().startswith(normalized + "-"):
+                    continue
+                metadata = dist / "METADATA"
+                if not metadata.exists():
+                    continue
+                with metadata.open(encoding="utf-8") as f:
+                    for line in f:
+                        if line.startswith("Version:"):
+                            return line.split(":", 1)[1].strip()
+        # Fallback: parse `uv pip freeze` output.
+        for line in self.export(env_dir):
+            if "==" in line:
+                name, version = line.split("==", 1)
+                if name.strip().lower() == package_name.lower():
+                    return version.strip()
+        return None
+
+    def export(self, env_dir: Path) -> list[str]:
+        output = self._run_uv_pip(env_dir, "freeze")
+        return [line for line in output.splitlines() if line]
+
+    # -- extra helpers (Python-specific) ------------------------------------
+
+    def venv_bin(self, env_dir: Path, name: str, *, fail_if_missing: bool = True) -> Path:
+        """Get a specific binary by name from the venv."""
+        path = self._bin_dir(env_dir) / f"{name}{get_binary_extension()}"
+        if fail_if_missing and not path.exists():
+            available = [p.stem for p in self.find_binaries(env_dir)]
+            raise BinaryNotFoundError(name, env_dir, available)
+        return path

ixt/cli/__init__.py

@@ -0,0 +1,31 @@
+"""CLI module — entry point for the ixt command."""
+
+from __future__ import annotations
+
+__all__ = ["main"]
+
+
+def main() -> int:
+    """Entry point for ixt CLI."""
+    from ixt.cli.commands import COMMANDS
+    from ixt.cli.parser import build_parser, normalize_verbosity
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    vlevel = normalize_verbosity(args)
+    if vlevel:
+        from ixt.libs.logger import Level, set_global_level
+
+        set_global_level(Level.DEBUG, verbosity=vlevel)
+
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 0
+
+    handler = COMMANDS.get(args.command)
+    if handler is None:
+        parser.print_help()
+        return 1
+
+    return handler(args)