evok 0.1.0__py3-none-any.whl

evok/__init__.py

@@ -0,0 +1,19 @@
+"""Evok: Pure-Python high-performance package manager and virtualization runtime."""
+
+from evok.environment import Environment
+from evok.pep440 import BitPackedVersion, SpecifierSet, VersionSpecifier
+from evok.resolver import InMemoryProvider, Requirement, ResolutionGraph, Resolver
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BitPackedVersion",
+    "Environment",
+    "InMemoryProvider",
+    "Requirement",
+    "ResolutionGraph",
+    "Resolver",
+    "SpecifierSet",
+    "VersionSpecifier",
+    "__version__",
+]

evok/__main__.py

@@ -0,0 +1,6 @@
+from evok.cli import main
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

evok/ast_scanner.py

@@ -0,0 +1,217 @@
+"""AST-driven dependency inference and dead-dependency pruning.
+
+Inspects Python AST to discover third-party imports, maps module names to PyPI distributions,
+and compares against pyproject.toml to flag missing or unused dependencies.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import sys
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Known mapping of top-level import name to canonical PyPI package name
+KNOWN_IMPORT_MAP: dict[str, str] = {
+    "yaml": "pyyaml",
+    "cv2": "opencv-python",
+    "PIL": "pillow",
+    "bs4": "beautifulsoup4",
+    "sklearn": "scikit-learn",
+    "dateutil": "python-dateutil",
+    "dotenv": "python-dotenv",
+    "fitz": "pymupdf",
+    "magic": "python-magic",
+    "jwt": "pyjwt",
+    "serial": "pyserial",
+    "usb": "pyusb",
+    "gi": "pygobject",
+    "git": "gitpython",
+    "jose": "python-jose",
+    "multipart": "python-multipart",
+}
+
+_IGNORED_DIRS = {
+    ".venv",
+    "venv",
+    ".git",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+    "build",
+    "dist",
+    "site-packages",
+}
+
+
+def get_stdlib_modules() -> set[str]:
+    """Return set of standard library module names."""
+    if hasattr(sys, "stdlib_module_names"):
+        return set(sys.stdlib_module_names)
+    # Fallback list for older or custom runtimes
+    return {
+        "os",
+        "sys",
+        "io",
+        "math",
+        "json",
+        "re",
+        "time",
+        "datetime",
+        "pathlib",
+        "typing",
+        "ast",
+        "unittest",
+        "logging",
+        "collections",
+        "urllib",
+        "http",
+        "subprocess",
+        "threading",
+        "multiprocessing",
+        "asyncio",
+        "contextlib",
+        "functools",
+        "itertools",
+        "shutil",
+        "tempfile",
+        "glob",
+        "hashlib",
+        "random",
+        "socket",
+        "ssl",
+        "inspect",
+        "importlib",
+        "ctypes",
+        "struct",
+        "copy",
+        "enum",
+    }
+
+
+def normalize_package_name(name: str) -> str:
+    """Normalize package name according to PEP 503."""
+    return name.lower().replace("_", "-").replace(".", "-")
+
+
+class ImportVisitor(ast.NodeVisitor):
+    """AST visitor collecting imported module names."""
+
+    def __init__(self) -> None:
+        self.imports: set[str] = set()
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            root = alias.name.split(".")[0]
+            if root:
+                self.imports.add(root)
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.level == 0 and node.module:
+            root = node.module.split(".")[0]
+            if root:
+                self.imports.add(root)
+        self.generic_visit(node)
+
+
+def scan_file_imports(file_path: Path | str) -> set[str]:
+    """Parse a single Python file and return all root imported module names."""
+    p = Path(file_path)
+    try:
+        content = p.read_text(encoding="utf-8", errors="ignore")
+        tree = ast.parse(content, filename=str(p))
+    except (SyntaxError, UnicodeDecodeError):
+        return set()
+
+    visitor = ImportVisitor()
+    visitor.visit(tree)
+    return visitor.imports
+
+
+@dataclass
+class ScanResult:
+    """Results of AST dependency scanning across a codebase."""
+
+    all_imports: set[str] = field(default_factory=set)
+    inferred_packages: set[str] = field(default_factory=set)
+    declared_dependencies: set[str] = field(default_factory=set)
+    missing_dependencies: set[str] = field(default_factory=set)
+    unused_dependencies: set[str] = field(default_factory=set)
+
+
+def map_module_to_package(module_name: str) -> str:
+    """Map an imported module name to its likely PyPI distribution name."""
+    if module_name in KNOWN_IMPORT_MAP:
+        return KNOWN_IMPORT_MAP[module_name]
+    return normalize_package_name(module_name)
+
+
+def scan_project(root_dir: Path | str) -> ScanResult:
+    """Recursively scan Python files under root_dir and audit against pyproject.toml."""
+    root = Path(root_dir).resolve()
+    stdlib = get_stdlib_modules()
+
+    # Discover local project packages/modules to avoid false positives
+    local_modules: set[str] = set()
+    for item in root.iterdir():
+        if item.name.startswith("."):
+            continue
+        if item.is_file() and item.suffix == ".py":
+            local_modules.add(item.stem)
+        elif item.is_dir() and (item / "__init__.py").exists():
+            local_modules.add(item.name)
+
+    # Check for src-layout
+    src_dir = root / "src"
+    if src_dir.is_dir():
+        for item in src_dir.iterdir():
+            if item.is_file() and item.suffix == ".py":
+                local_modules.add(item.stem)
+            elif item.is_dir() and (item / "__init__.py").exists():
+                local_modules.add(item.name)
+
+    all_imports: set[str] = set()
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _IGNORED_DIRS and not d.startswith(".")]
+        for f in filenames:
+            if f.endswith(".py"):
+                file_p = Path(dirpath) / f
+                all_imports.update(scan_file_imports(file_p))
+
+    # Filter out stdlib and local modules
+    third_party_modules = {
+        m for m in all_imports if m not in stdlib and m not in local_modules and not m.startswith("_")
+    }
+
+    inferred_packages = {map_module_to_package(m) for m in third_party_modules}
+
+    # Read declared dependencies from pyproject.toml if present
+    declared: set[str] = set()
+    pyproject_file = root / "pyproject.toml"
+    if pyproject_file.exists():
+        try:
+            with open(pyproject_file, "rb") as f:
+                data = tomllib.load(f)
+            deps = data.get("project", {}).get("dependencies", [])
+            for dep in deps:
+                # Strip version specifiers like '>=1.0.0', '==2.0'
+                name = dep.split(";")[0].split(">")[0].split("<")[0].split("=")[0].split("~")[0]
+                name = name.strip()
+                if name:
+                    declared.add(normalize_package_name(name))
+        except (OSError, tomllib.TOMLDecodeError):
+            pass
+
+    missing = inferred_packages - declared
+    unused = declared - inferred_packages
+
+    return ScanResult(
+        all_imports=all_imports,
+        inferred_packages=inferred_packages,
+        declared_dependencies=declared,
+        missing_dependencies=missing,
+        unused_dependencies=unused,
+    )

evok/builder.py

@@ -0,0 +1,177 @@
+"""Pure-Python standard wheel/sdist builder and standalone zipapp bundler.
+
+Implements:
+- PEP 427 standard wheel packaging
+- PEP 625 / PEP 517 standard source distribution (sdist .tar.gz)
+- Single-file zero-binary zipapp (.pyz) executable creation
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import os
+import tarfile
+import tomllib
+import zipapp
+import zipfile
+from pathlib import Path
+
+
+def _sha256_b64(data: bytes) -> str:
+    """Return URL-safe base64 SHA256 digest without trailing '=' for RECORD."""
+    digest = hashlib.sha256(data).digest()
+    return base64.urlsafe_b64encode(digest).decode("ascii").rstrip("=")
+
+
+def load_project_metadata(project_dir: Path | str) -> dict[str, str | list[str]]:
+    """Parse pyproject.toml and return normalized project metadata."""
+    p_dir = Path(project_dir).resolve()
+    pyproject_file = p_dir / "pyproject.toml"
+    if not pyproject_file.exists():
+        raise FileNotFoundError(f"pyproject.toml not found in {project_dir}")
+
+    with open(pyproject_file, "rb") as f:
+        data = tomllib.load(f)
+
+    project = data.get("project", {})
+    name = project.get("name")
+    if not name:
+        raise ValueError("Missing 'project.name' in pyproject.toml")
+    version = project.get("version", "0.1.0")
+    description = project.get("description", "")
+    requires_python = project.get("requires-python", ">=3.12")
+    dependencies = project.get("dependencies", [])
+
+    return {
+        "name": name,
+        "version": str(version),
+        "description": description,
+        "requires_python": requires_python,
+        "dependencies": dependencies,
+    }
+
+
+def build_wheel(project_dir: Path | str, dist_dir: Path | str | None = None) -> Path:
+    """Build a PEP 427 pure-Python wheel (.whl) from project_dir."""
+    p_dir = Path(project_dir).resolve()
+    meta = load_project_metadata(p_dir)
+
+    name = str(meta["name"])
+    norm_name = name.lower().replace("-", "_")
+    version = str(meta["version"])
+    dist_path = Path(dist_dir).resolve() if dist_dir else p_dir / "dist"
+    dist_path.mkdir(parents=True, exist_ok=True)
+
+    wheel_filename = f"{norm_name}-{version}-py3-none-any.whl"
+    wheel_path = dist_path / wheel_filename
+
+    # Locate package files (src layout or flat)
+    source_root = p_dir / "src" if (p_dir / "src").is_dir() else p_dir
+    dist_info = f"{norm_name}-{version}.dist-info"
+
+    # Build METADATA content
+    metadata_lines = [
+        "Metadata-Version: 2.1",
+        f"Name: {name}",
+        f"Version: {version}",
+        f"Summary: {meta['description']}",
+        f"Requires-Python: {meta['requires_python']}",
+    ]
+    for dep in meta["dependencies"]:  # type: ignore[union-attr]
+        metadata_lines.append(f"Requires-Dist: {dep}")
+    metadata_bytes = ("\n".join(metadata_lines) + "\n").encode("utf-8")
+
+    wheel_bytes = (
+        b"Wheel-Version: 1.0\nGenerator: evok (0.1.0)\nRoot-Is-Purelib: true\nTag: py3-none-any\n"
+    )
+
+    record_rows: list[str] = []
+
+    with zipfile.ZipFile(wheel_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        # 1. Package source files
+        for root, _, files in os.walk(source_root):
+            for file in files:
+                if file.endswith(".py"):
+                    full_file = Path(root) / file
+                    rel_arc = full_file.relative_to(source_root)
+                    data = full_file.read_bytes()
+                    zf.writestr(str(rel_arc), data)
+                    record_rows.append(f"{rel_arc},sha256={_sha256_b64(data)},{len(data)}")
+
+        # 2. Add dist-info/METADATA
+        meta_arc = f"{dist_info}/METADATA"
+        zf.writestr(meta_arc, metadata_bytes)
+        record_rows.append(f"{meta_arc},sha256={_sha256_b64(metadata_bytes)},{len(metadata_bytes)}")
+
+        # 3. Add dist-info/WHEEL
+        wheel_arc = f"{dist_info}/WHEEL"
+        zf.writestr(wheel_arc, wheel_bytes)
+        record_rows.append(f"{wheel_arc},sha256={_sha256_b64(wheel_bytes)},{len(wheel_bytes)}")
+
+        # 4. Add dist-info/RECORD
+        record_arc = f"{dist_info}/RECORD"
+        record_rows.append(f"{record_arc},,")
+        record_bytes = ("\n".join(record_rows) + "\n").encode("utf-8")
+        zf.writestr(record_arc, record_bytes)
+
+    return wheel_path
+
+
+def build_sdist(project_dir: Path | str, dist_dir: Path | str | None = None) -> Path:
+    """Build a PEP 625 / PEP 517 standard source distribution (.tar.gz)."""
+    p_dir = Path(project_dir).resolve()
+    meta = load_project_metadata(p_dir)
+
+    name = str(meta["name"])
+    norm_name = name.lower().replace("-", "_")
+    version = str(meta["version"])
+    dist_path = Path(dist_dir).resolve() if dist_dir else p_dir / "dist"
+    dist_path.mkdir(parents=True, exist_ok=True)
+
+    sdist_filename = f"{norm_name}-{version}.tar.gz"
+    sdist_path = dist_path / sdist_filename
+
+    prefix = f"{norm_name}-{version}"
+
+    with tarfile.open(sdist_path, "w:gz") as tar:
+        # Add pyproject.toml
+        pyproject_file = p_dir / "pyproject.toml"
+        tar.add(pyproject_file, arcname=f"{prefix}/pyproject.toml")
+
+        # Add README.md if present
+        readme = p_dir / "README.md"
+        if readme.exists():
+            tar.add(readme, arcname=f"{prefix}/README.md")
+
+        # Add src/ or python files
+        src_dir = p_dir / "src"
+        if src_dir.is_dir():
+            tar.add(src_dir, arcname=f"{prefix}/src")
+
+    return sdist_path
+
+
+def build_zipapp(
+    source_dir: Path | str,
+    output_path: Path | str,
+    main_entrypoint: str = "evok.cli:main",
+) -> Path:
+    """Package a Python package source tree into an executable standalone .pyz zipapp."""
+    src = Path(source_dir).resolve()
+    out = Path(output_path).resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    has_main = (src / "__main__.py").is_file()
+    entry = None if has_main else main_entrypoint
+
+    zipapp.create_archive(
+        src,
+        target=out,
+        interpreter="/usr/bin/env python3",
+        main=entry,
+        compressed=True,
+    )
+    # Ensure executable permission
+    out.chmod(0o755)
+    return out

evok/cache.py

@@ -0,0 +1,172 @@
+"""Unpacked wheel cache with zero-copy filesystem reflinks and hardlinks.
+
+Supports:
+- macOS APFS clonefile via ctypes
+- Linux FICLONE ioctl
+- os.link hardlinks
+- Fast fallback to symlink/shutil.copy
+"""
+
+from __future__ import annotations
+
+import ctypes
+import fcntl
+import os
+import shutil
+import sys
+import zipfile
+from pathlib import Path
+
+# macOS APFS clonefile setup
+_clonefile = None
+if sys.platform == "darwin":
+    try:
+        _libc = ctypes.cdll.LoadLibrary(None)
+        if hasattr(_libc, "clonefile"):
+            _clonefile = _libc.clonefile
+            _clonefile.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int]
+            _clonefile.restype = ctypes.c_int
+    except (OSError, AttributeError):
+        _clonefile = None
+
+# Linux FICLONE ioctl constant
+FICLONE = 0x40049409
+
+
+def default_cache_dir() -> Path:
+    """Return default evok cache directory."""
+    custom = os.environ.get("EVOK_CACHE_DIR")
+    if custom:
+        return Path(custom).expanduser().resolve()
+    return Path.home() / ".cache" / "evok"
+
+
+def reflink_file(src: Path | str, dst: Path | str) -> str:
+    """Perform zero-copy file clone (reflink) or hardlink from src to dst.
+
+    Returns the strategy used: 'clonefile', 'ficlone', 'hardlink', or 'copy'.
+    """
+    src_p = Path(src).resolve()
+    dst_p = Path(dst).resolve()
+    dst_p.parent.mkdir(parents=True, exist_ok=True)
+
+    if dst_p.exists():
+        dst_p.unlink()
+
+    src_bytes = str(src_p).encode("utf-8")
+    dst_bytes = str(dst_p).encode("utf-8")
+
+    # 1. macOS APFS clonefile
+    if _clonefile is not None:
+        ret = _clonefile(src_bytes, dst_bytes, 0)
+        if ret == 0:
+            return "clonefile"
+
+    # 2. Linux FICLONE ioctl
+    if sys.platform.startswith("linux"):
+        try:
+            with open(src_p, "rb") as f_in, open(dst_p, "wb") as f_out:
+                fcntl.ioctl(f_out.fileno(), FICLONE, f_in.fileno())
+            return "ficlone"
+        except OSError:
+            if dst_p.exists():
+                dst_p.unlink()
+
+    # 3. os.link (Hardlink)
+    try:
+        os.link(src_p, dst_p)
+        return "hardlink"
+    except OSError:
+        pass
+
+    # 4. Fallback copy
+    shutil.copy2(src_p, dst_p)
+    return "copy"
+
+
+def materialize_tree(
+    src_dir: Path | str, dst_dir: Path | str, strategy: str = "auto"
+) -> dict[str, int]:
+    """Materialize files from src_dir into dst_dir using zero-copy links.
+
+    Returns a count of files linked by strategy.
+    """
+    src_root = Path(src_dir).resolve()
+    dst_root = Path(dst_dir).resolve()
+    counts: dict[str, int] = {}
+
+    for dirpath, _, filenames in os.walk(src_root):
+        rel_path = Path(dirpath).relative_to(src_root)
+        target_dir = dst_root / rel_path
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        for filename in filenames:
+            src_file = Path(dirpath) / filename
+            dst_file = target_dir / filename
+            if strategy == "hardlink":
+                try:
+                    if dst_file.exists():
+                        dst_file.unlink()
+                    os.link(src_file, dst_file)
+                    st = "hardlink"
+                except OSError:
+                    shutil.copy2(src_file, dst_file)
+                    st = "copy"
+            elif strategy == "copy":
+                shutil.copy2(src_file, dst_file)
+                st = "copy"
+            else:
+                st = reflink_file(src_file, dst_file)
+            counts[st] = counts.get(st, 0) + 1
+
+    return counts
+
+
+class WheelCache:
+    """Global unpacked wheel cache."""
+
+    def __init__(self, cache_dir: Path | str | None = None) -> None:
+        self.root = Path(cache_dir).expanduser().resolve() if cache_dir else default_cache_dir()
+        self.wheels_dir = self.root / "wheels"
+        self.wheels_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_wheel_dir(self, name: str, version: str) -> Path:
+        """Return the directory path for an unpacked wheel."""
+        safe_name = name.lower().replace("-", "_")
+        return self.wheels_dir / safe_name / version
+
+    def is_cached(self, name: str, version: str) -> bool:
+        """Check if an unpacked wheel already exists."""
+        w_dir = self.get_wheel_dir(name, version)
+        return w_dir.is_dir() and (w_dir / ".evok_complete").exists()
+
+    def unpack_wheel(self, wheel_path: Path | str) -> Path:
+        """Unpack a .whl file into the global cache."""
+        wheel_p = Path(wheel_path).resolve()
+        filename = wheel_p.name
+        # Wheel filename format: {distribution}-{version}(-{build_tag})?-{python_tag}-{abi_tag}-{platform_tag}.whl
+        parts = filename[:-4].split("-")
+        if len(parts) < 2:
+            raise ValueError(f"Invalid wheel filename format: {filename}")
+
+        name, version = parts[0], parts[1]
+        target_dir = self.get_wheel_dir(name, version)
+        if self.is_cached(name, version):
+            return target_dir
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(wheel_p, "r") as zf:
+            zf.extractall(target_dir)
+
+        # Mark complete
+        (target_dir / ".evok_complete").write_text("ok\n", encoding="utf-8")
+        return target_dir
+
+    def install_to(
+        self, name: str, version: str, target_dir: Path | str, strategy: str = "auto"
+    ) -> dict[str, int]:
+        """Materialize an unpacked wheel into target_dir (e.g. site-packages)."""
+        src = self.get_wheel_dir(name, version)
+        if not src.is_dir():
+            raise FileNotFoundError(f"Wheel {name}=={version} not found in cache")
+        return materialize_tree(src, target_dir, strategy=strategy)