comfy-env 0.1.13__tar.gz → 0.1.15__tar.gz

{comfy_env-0.1.13 → comfy_env-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.13
+Version: 0.1.15
 Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
 Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
 Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: pip>=21.0
 Requires-Dist: tomli-w>=1.0.0
-Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: tomli>=2.0.0
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

{comfy_env-0.1.13 → comfy_env-0.1.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.1.13"
+version = "0.1.15"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}
@@ -19,10 +19,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "tomli>=2.0.0; python_version < '3.11'",  # TOML parsing (built-in tomllib for 3.11+)
-    "tomli-w>=1.0.0",  # TOML writing (no stdlib equivalent)
-    "uv>=0.4.0",  # Fast Python package installer and venv creator
-    "pip>=21.0",  # Fallback package installer
+    "tomli>=2.0.0",
+    "tomli-w>=1.0.0",
+    "uv>=0.4.0",
+    "pip>=21.0",
 ]
 
 [project.optional-dependencies]

{comfy_env-0.1.13 → comfy_env-0.1.15}/src/comfy_env/__init__.py

@@ -1,12 +1,4 @@
-"""
-comfy-env: Environment management for ComfyUI custom nodes.
-
-All dependencies go through pixi for unified management.
-
-Main APIs:
-- install(): Install dependencies from comfy-env.toml
-- wrap_isolated_nodes(): Wrap nodes for subprocess isolation
-"""
+"""Environment management for ComfyUI custom nodes."""
 
 from importlib.metadata import version, PackageNotFoundError
 
@@ -48,32 +40,34 @@ from .workers import (
 )
 
 # Isolation
-from .isolation import wrap_isolated_nodes
+from .isolation import wrap_isolated_nodes, wrap_nodes
 
 # Install API
-from .install import install, verify_installation
+from .install import install, verify_installation, USE_COMFY_ENV_VAR
 
 # Prestartup helpers
-from .prestartup import setup_env
+from .prestartup import setup_env, copy_files
 
-# Errors
-from .errors import (
-    EnvManagerError,
-    ConfigError,
-    WheelNotFoundError,
-    DependencyError,
-    CUDANotFoundError,
-    InstallError,
+# Cache management
+from .cache import (
+    get_cache_dir,
+    cleanup_orphaned_envs,
+    resolve_env_path,
+    CACHE_DIR,
+    MARKER_FILE,
 )
 
 __all__ = [
     # Install API
     "install",
     "verify_installation",
+    "USE_COMFY_ENV_VAR",
     # Prestartup
     "setup_env",
+    "copy_files",
     # Isolation
     "wrap_isolated_nodes",
+    "wrap_nodes",
     # Config
     "ComfyEnvConfig",
     "NodeReq",
@@ -98,11 +92,20 @@ __all__ = [
     "WorkerError",
     "MPWorker",
     "SubprocessWorker",
-    # Errors
-    "EnvManagerError",
-    "ConfigError",
-    "WheelNotFoundError",
-    "DependencyError",
-    "CUDANotFoundError",
-    "InstallError",
+    # Cache
+    "get_cache_dir",
+    "cleanup_orphaned_envs",
+    "resolve_env_path",
+    "CACHE_DIR",
+    "MARKER_FILE",
 ]
+
+# Run orphan cleanup once on module load (silently)
+def _run_startup_cleanup():
+    """Clean orphaned envs on startup."""
+    try:
+        cleanup_orphaned_envs(log=lambda x: None)  # Silent
+    except Exception:
+        pass  # Never fail startup due to cleanup
+
+_run_startup_cleanup()

comfy_env-0.1.15/src/comfy_env/cache.py

@@ -0,0 +1,203 @@
+"""Central environment cache management."""
+
+import hashlib
+import os
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple, Callable
+
+# Import version
+try:
+    from . import __version__
+except ImportError:
+    __version__ = "0.0.0-dev"
+
+import tomli
+import tomli_w
+
+
+# Constants
+CACHE_DIR = Path.home() / ".comfy-env" / "envs"
+MARKER_FILE = ".comfy-env-marker.toml"
+METADATA_FILE = ".comfy-env-metadata.toml"
+
+
+def get_cache_dir() -> Path:
+    """Get central cache directory, create if needed."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return CACHE_DIR
+
+
+def compute_config_hash(config_path: Path) -> str:
+    """Compute hash of comfy-env.toml content (first 8 chars of SHA256)."""
+    content = config_path.read_bytes()
+    return hashlib.sha256(content).hexdigest()[:8]
+
+
+def sanitize_name(name: str) -> str:
+    """Sanitize a name for use in filesystem paths."""
+    # Lowercase and replace problematic chars
+    name = name.lower()
+    for prefix in ("comfyui-", "comfyui_"):
+        if name.startswith(prefix):
+            name = name[len(prefix):]
+    return name.replace("-", "_").replace(" ", "_")
+
+
+def get_env_name(node_dir: Path, config_path: Path) -> str:
+    """Generate env name: <nodename>_<subfolder>_<hash>."""
+    # Get node name
+    node_name = sanitize_name(node_dir.name)
+
+    # Get subfolder (relative path from node_dir to config parent)
+    config_parent = config_path.parent
+    if config_parent == node_dir:
+        subfolder = ""
+    else:
+        try:
+            rel_path = config_parent.relative_to(node_dir)
+            subfolder = rel_path.as_posix().replace("/", "_")
+        except ValueError:
+            # config_path not under node_dir - use parent folder name
+            subfolder = sanitize_name(config_parent.name)
+
+    # Compute hash
+    config_hash = compute_config_hash(config_path)
+
+    return f"{node_name}_{subfolder}_{config_hash}"
+
+
+def get_central_env_path(node_dir: Path, config_path: Path) -> Path:
+    """Get path to central environment for this config."""
+    env_name = get_env_name(node_dir, config_path)
+    return get_cache_dir() / env_name
+
+
+def write_marker(config_path: Path, env_path: Path) -> None:
+    """Write marker file linking node to central env."""
+    marker_path = config_path.parent / MARKER_FILE
+    marker_data = {
+        "env": {
+            "name": env_path.name,
+            "path": str(env_path),
+            "config_hash": compute_config_hash(config_path),
+            "created": datetime.now().isoformat(),
+            "comfy_env_version": __version__,
+        }
+    }
+    marker_path.write_text(tomli_w.dumps(marker_data))
+
+
+def write_env_metadata(env_path: Path, marker_path: Path) -> None:
+    """Write metadata file for orphan detection."""
+    metadata_path = env_path / METADATA_FILE
+    metadata = {
+        "marker_path": str(marker_path),
+        "created": datetime.now().isoformat(),
+    }
+    metadata_path.write_text(tomli_w.dumps(metadata))
+
+
+def read_marker(marker_path: Path) -> Optional[dict]:
+    """Read marker file, return None if invalid/missing."""
+    if not marker_path.exists():
+        return None
+    try:
+        with open(marker_path, "rb") as f:
+            return tomli.load(f)
+    except Exception:
+        return None
+
+
+def read_env_metadata(env_path: Path) -> Optional[dict]:
+    """Read metadata file from env, return None if invalid/missing."""
+    metadata_path = env_path / METADATA_FILE
+    if not metadata_path.exists():
+        return None
+    try:
+        with open(metadata_path, "rb") as f:
+            return tomli.load(f)
+    except Exception:
+        return None
+
+
+def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Optional[Path]]:
+    """Resolve environment path. Returns (env_path, site_packages, lib_dir)."""
+    # 1. Check marker file -> central cache
+    marker_path = node_dir / MARKER_FILE
+    marker = read_marker(marker_path)
+    if marker and "env" in marker:
+        env_path = Path(marker["env"]["path"])
+        if env_path.exists():
+            return _get_env_paths(env_path)
+
+    # 2. Check _env_<name>
+    node_name = sanitize_name(node_dir.name)
+    env_name = f"_env_{node_name}"
+    local_env = node_dir / env_name
+    if local_env.exists():
+        return _get_env_paths(local_env)
+
+    # 3. Check .pixi/envs/default
+    pixi_env = node_dir / ".pixi" / "envs" / "default"
+    if pixi_env.exists():
+        return _get_env_paths(pixi_env)
+
+    # 4. Check .venv
+    venv_dir = node_dir / ".venv"
+    if venv_dir.exists():
+        return _get_env_paths(venv_dir)
+
+    return None, None, None
+
+
+def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
+    """Get site-packages and lib paths from an environment."""
+    import glob
+
+    if sys.platform == "win32":
+        site_packages = env_path / "Lib" / "site-packages"
+        lib_dir = env_path / "Library" / "bin"
+    else:
+        # Linux/Mac: lib/python*/site-packages
+        matches = glob.glob(str(env_path / "lib" / "python*" / "site-packages"))
+        site_packages = Path(matches[0]) if matches else None
+        lib_dir = env_path / "lib"
+
+    return env_path, site_packages, lib_dir
+
+
+def cleanup_orphaned_envs(log: Callable[[str], None] = print) -> int:
+    """Remove orphaned environments. Returns count cleaned."""
+    cache_dir = get_cache_dir()
+    if not cache_dir.exists():
+        return 0
+
+    cleaned = 0
+    for env_dir in cache_dir.iterdir():
+        if not env_dir.is_dir():
+            continue
+
+        # Skip if no metadata (might be manually created or old format)
+        metadata = read_env_metadata(env_dir)
+        if not metadata:
+            continue
+
+        # Check if marker file still exists
+        marker_path_str = metadata.get("marker_path", "")
+        if not marker_path_str:
+            continue
+
+        marker_path = Path(marker_path_str)
+        if not marker_path.exists():
+            # Marker gone = node was deleted = orphan
+            log(f"[comfy-env] Cleaning orphaned env: {env_dir.name}")
+            try:
+                shutil.rmtree(env_dir)
+                cleaned += 1
+            except Exception as e:
+                log(f"[comfy-env] Failed to cleanup {env_dir.name}: {e}")
+
+    return cleaned

{comfy_env-0.1.13 → comfy_env-0.1.15}/src/comfy_env/cli.py

@@ -309,7 +309,7 @@ def cmd_info(args) -> int:
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation
-    from .config.parser import discover_env_config, load_env_from_file
+    from .config.parser import load_config, discover_config
 
     print("Running diagnostics...")
     print("=" * 40)
@@ -325,21 +325,19 @@ def cmd_doctor(args) -> int:
     if args.package:
         packages = [args.package]
     elif args.config:
-        config = load_env_from_file(Path(args.config))
+        config = load_config(Path(args.config))
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            # Get packages from pypi-dependencies
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
     else:
-        config = discover_env_config(Path.cwd())
+        config = discover_config(Path.cwd())
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
 
     if packages:
-        pkg_names = []
-        for pkg in packages:
-            name = pkg.split("==")[0].split(">=")[0].split("[")[0]
-            pkg_names.append(name)
-
-        all_ok = verify_installation(pkg_names)
+        all_ok = verify_installation(packages)
         if all_ok:
             print("\nAll packages verified!")
             return 0

comfy_env-0.1.15/src/comfy_env/config/__init__.py

@@ -0,0 +1,17 @@
+"""Config parsing for comfy-env."""
+
+from .parser import (
+    ComfyEnvConfig,
+    NodeReq,
+    load_config,
+    discover_config,
+    CONFIG_FILE_NAME,
+)
+
+__all__ = [
+    "ComfyEnvConfig",
+    "NodeReq",
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAME",
+]

{comfy_env-0.1.13 → comfy_env-0.1.15}/src/comfy_env/config/parser.py

@@ -1,100 +1,53 @@
-"""Load configuration from comfy-env.toml.
-
-comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
-- python = "3.11" - Python version for isolated envs
-- [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
-- [node_reqs] - Other ComfyUI nodes to clone
-
-Everything else passes through to pixi.toml directly.
-
-Example config:
-
-    python = "3.11"
-
-    [cuda]
-    packages = ["cumesh"]
-
-    [dependencies]
-    mesalib = "*"
-    cgal = "*"
-
-    [pypi-dependencies]
-    numpy = ">=1.21.0,<2"
-    trimesh = { version = ">=4.0.0", extras = ["easy"] }
-
-    [target.linux-64.pypi-dependencies]
-    embreex = "*"
+"""
+Configuration parsing for comfy-env.
 
-    [node_reqs]
-    SomeNode = "owner/repo"
+Loads comfy-env.toml (a superset of pixi.toml) and provides typed config objects.
 """
 
 import copy
 import sys
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional, Dict, Any, List
+import tomli
 
-# Use built-in tomllib (Python 3.11+) or tomli fallback
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    try:
-        import tomli as tomllib
-    except ImportError:
-        tomllib = None  # type: ignore
-
-from .types import ComfyEnvConfig, NodeReq
-
-
+# --- Types&Constants ---
 CONFIG_FILE_NAME = "comfy-env.toml"
 
-# Sections we handle specially (not passed through to pixi.toml)
-CUSTOM_SECTIONS = {"python", "cuda", "node_reqs", "apt", "env_vars"}
-
+@dataclass
+class NodeReq:
+    """A node dependency (another ComfyUI custom node)."""
+    name: str
+    repo: str  # GitHub repo, e.g., "owner/repo"
 
-def load_config(path: Path) -> ComfyEnvConfig:
-    """
-    Load configuration from a TOML file.
+@dataclass
+class ComfyEnvConfig:
+    """Configuration from comfy-env.toml."""
+    python: Optional[str] = None
+    cuda_packages: List[str] = field(default_factory=list)
+    apt_packages: List[str] = field(default_factory=list)
+    env_vars: Dict[str, str] = field(default_factory=dict)
+    node_reqs: List[NodeReq] = field(default_factory=list)
+    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
 
-    Args:
-        path: Path to comfy-env.toml
+    @property
+    def has_cuda(self) -> bool:
+        return bool(self.cuda_packages)
+# --- Types&Constants ---
 
-    Returns:
-        ComfyEnvConfig instance
-
-    Raises:
-        FileNotFoundError: If config file doesn't exist
-        ImportError: If tomli not installed (Python < 3.11)
-    """
-    if tomllib is None:
-        raise ImportError(
-            "TOML parsing requires tomli for Python < 3.11. "
-            "Install with: pip install tomli"
-        )
 
+def load_config(path: Path) -> ComfyEnvConfig:
+    """Load config from a TOML file."""
     path = Path(path)
     if not path.exists():
         raise FileNotFoundError(f"Config file not found: {path}")
-
     with open(path, "rb") as f:
-        data = tomllib.load(f)
-
+        data = tomli.load(f)
     return _parse_config(data)
 
 
 def discover_config(node_dir: Path) -> Optional[ComfyEnvConfig]:
-    """
-    Find and load comfy-env.toml from a directory.
-
-    Args:
-        node_dir: Directory to search
-
-    Returns:
-        ComfyEnvConfig if found, None otherwise
-    """
-    if tomllib is None:
-        return None
-
+    """Find and load comfy-env.toml from a directory."""
     config_path = Path(node_dir) / CONFIG_FILE_NAME
     if config_path.exists():
         return load_config(config_path)