comfy-env 0.0.55__tar.gz → 0.0.57__tar.gz

{comfy_env-0.0.55 → comfy_env-0.0.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.55
+Version: 0.0.57
 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

{comfy_env-0.0.55 → comfy_env-0.0.57}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.0.55"
+version = "0.0.57"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}

{comfy_env-0.0.55 → comfy_env-0.0.57}/src/comfy_env/isolation.py

@@ -30,6 +30,9 @@ from functools import wraps
 from pathlib import Path
 from typing import Any, Dict, Optional
 
+# Debug logging (set COMFY_ENV_DEBUG=1 to enable)
+_DEBUG = os.environ.get("COMFY_ENV_DEBUG", "").lower() in ("1", "true", "yes")
+
 # Global worker cache (one per isolated environment)
 _workers: Dict[str, Any] = {}
 _workers_lock = threading.Lock()
@@ -158,11 +161,13 @@ def _wrap_node_class(
 
     @wraps(original_method)
     def proxy(self, **kwargs):
-        print(f"[comfy-env] PROXY CALLED: {cls.__name__}.{func_name}", flush=True)
-        print(f"[comfy-env]   kwargs keys: {list(kwargs.keys())}", flush=True)
+        if _DEBUG:
+            print(f"[comfy-env] PROXY CALLED: {cls.__name__}.{func_name}", flush=True)
+            print(f"[comfy-env]   kwargs keys: {list(kwargs.keys())}", flush=True)
 
         worker = _get_worker(env_name, python_path, working_dir, sys_path)
-        print(f"[comfy-env]   worker alive: {worker.is_alive()}", flush=True)
+        if _DEBUG:
+            print(f"[comfy-env]   worker alive: {worker.is_alive()}", flush=True)
 
         # Clone tensors for IPC if needed
         try:
@@ -172,7 +177,8 @@ def _wrap_node_class(
         except ImportError:
             pass  # No torch available, skip cloning
 
-        print(f"[comfy-env]   calling worker.call_method...", flush=True)
+        if _DEBUG:
+            print(f"[comfy-env]   calling worker.call_method...", flush=True)
         result = worker.call_method(
             module_name=module_name,
             class_name=cls.__name__,
@@ -181,7 +187,8 @@ def _wrap_node_class(
             kwargs=kwargs,
             timeout=600.0,
         )
-        print(f"[comfy-env]   call_method returned", flush=True)
+        if _DEBUG:
+            print(f"[comfy-env]   call_method returned", flush=True)
 
         # Clone result tensors
         try:

{comfy_env-0.0.55 → comfy_env-0.0.57}/src/comfy_env/pixi.py

@@ -181,6 +181,97 @@ def _parse_pypi_requirement(dep: str) -> Tuple[str, Optional[str], List[str]]:
     return name, version_spec, extras
 
 
+def _build_cuda_vars(env_config: IsolatedEnv) -> dict:
+    """
+    Build variable dict for CUDA wheel URL resolution.
+
+    Returns a dict with CUDA, PyTorch, Python, and platform variables
+    for template substitution.
+    """
+    # Use fixed CUDA 12.8 / PyTorch 2.8 for pixi environments (modern GPU default)
+    vars_dict = {
+        "cuda_version": "12.8",
+        "cuda_short": "128",
+        "cuda_short2": "128",
+        "cuda_major": "12",
+        "torch_version": "2.8.0",
+        "torch_short": "280",
+        "torch_mm": "28",
+        "torch_dotted_mm": "2.8",
+    }
+
+    # Platform detection
+    if sys.platform == "linux":
+        vars_dict["platform"] = "linux_x86_64"
+    elif sys.platform == "darwin":
+        vars_dict["platform"] = "macosx_arm64" if platform.machine() == "arm64" else "macosx_x86_64"
+    elif sys.platform == "win32":
+        vars_dict["platform"] = "win_amd64"
+
+    # Python version from env config
+    if env_config.python:
+        py_parts = env_config.python.split(".")
+        py_major = py_parts[0]
+        py_minor = py_parts[1] if len(py_parts) > 1 else "0"
+        vars_dict["py_version"] = env_config.python
+        vars_dict["py_short"] = f"{py_major}{py_minor}"
+        vars_dict["py_minor"] = py_minor
+        vars_dict["py_tag"] = f"cp{py_major}{py_minor}"
+
+    return vars_dict
+
+
+def _resolve_cuda_wheel_url(
+    req: str,
+    vars_dict: dict,
+    log: Callable[[str], None] = print,
+) -> Optional[str]:
+    """
+    Resolve a CUDA package requirement to a wheel URL.
+
+    Args:
+        req: Package requirement (e.g., "cumesh" or "cumesh==0.0.1")
+        vars_dict: Variable dict for URL template substitution
+        log: Logging callback
+
+    Returns:
+        Resolved wheel URL, or None if package not in registry.
+    """
+    from .registry import PACKAGE_REGISTRY
+
+    # Parse requirement (e.g., "cumesh" or "cumesh==0.0.1")
+    if "==" in req:
+        pkg_name, version = req.split("==", 1)
+    else:
+        pkg_name = req
+        version = None
+
+    pkg_lower = pkg_name.lower()
+    if pkg_lower not in PACKAGE_REGISTRY:
+        log(f"  Warning: CUDA package {pkg_name} not in registry")
+        return None
+
+    config = PACKAGE_REGISTRY[pkg_lower]
+    template = config.get("wheel_template")
+    if not template:
+        log(f"  Warning: No wheel template for {pkg_name}")
+        return None
+
+    # Use version from requirement or default
+    v = version or config.get("default_version")
+    if v:
+        vars_dict = vars_dict.copy()  # Don't mutate original
+        vars_dict["version"] = v
+
+    # Resolve URL template
+    url = template
+    for key, value in vars_dict.items():
+        if value:
+            url = url.replace(f"{{{key}}}", str(value))
+
+    return url
+
+
 def create_pixi_toml(
     env_config: IsolatedEnv,
     node_dir: Path,
@@ -193,7 +284,11 @@ def create_pixi_toml(
     - Project metadata
     - Conda channels
     - Conda dependencies
-    - PyPI dependencies (from requirements + no_deps_requirements)
+    - PyPI dependencies (from requirements)
+
+    Note: CUDA packages (no_deps_requirements) are NOT included in pixi.toml.
+    They are installed separately with pip --no-deps after pixi install
+    to avoid transitive dependency conflicts.
 
     Args:
         env_config: The isolated environment configuration.
@@ -312,67 +407,9 @@ def create_pixi_toml(
     if env_config.requirements:
         pypi_deps.extend(env_config.requirements)
 
-    # Add CUDA packages with resolved wheel URLs
-    if env_config.no_deps_requirements:
-        from .registry import PACKAGE_REGISTRY
-
-        # Use fixed CUDA 12.8 / PyTorch 2.8 for pixi environments (modern GPU default)
-        # This ensures wheels match what pixi will install, not what the host has
-        vars_dict = {
-            "cuda_version": "12.8",
-            "cuda_short": "128",
-            "cuda_short2": "128",
-            "cuda_major": "12",
-            "torch_version": "2.8.0",
-            "torch_short": "280",
-            "torch_mm": "28",
-            "torch_dotted_mm": "2.8",
-        }
-
-        # Platform detection
-        if sys.platform == "linux":
-            vars_dict["platform"] = "linux_x86_64"
-        elif sys.platform == "darwin":
-            vars_dict["platform"] = "macosx_arm64" if platform.machine() == "arm64" else "macosx_x86_64"
-        elif sys.platform == "win32":
-            vars_dict["platform"] = "win_amd64"
-
-        # Python version from pixi env config
-        if env_config.python:
-            py_parts = env_config.python.split(".")
-            py_major = py_parts[0]
-            py_minor = py_parts[1] if len(py_parts) > 1 else "0"
-            vars_dict["py_version"] = env_config.python
-            vars_dict["py_short"] = f"{py_major}{py_minor}"
-            vars_dict["py_minor"] = py_minor
-            vars_dict["py_tag"] = f"cp{py_major}{py_minor}"
-
-        for req in env_config.no_deps_requirements:
-            # Parse requirement (e.g., "cumesh" or "cumesh==0.0.1")
-            if "==" in req:
-                pkg_name, version = req.split("==", 1)
-            else:
-                pkg_name = req
-                version = None
-
-            pkg_lower = pkg_name.lower()
-            if pkg_lower in PACKAGE_REGISTRY:
-                config = PACKAGE_REGISTRY[pkg_lower]
-                template = config.get("wheel_template")
-                if template:
-                    # Use version from requirement or default
-                    v = version or config.get("default_version")
-                    if v:
-                        vars_dict["version"] = v
-
-                    # Resolve URL
-                    url = template
-                    for key, value in vars_dict.items():
-                        if value:
-                            url = url.replace(f"{{{key}}}", str(value))
-
-                    special_deps[pkg_name] = f'{{ url = "{url}" }}'
-                    log(f"  CUDA package {pkg_name}: resolved wheel URL")
+    # NOTE: CUDA packages (no_deps_requirements) are NOT added to pixi.toml.
+    # They are installed separately with pip --no-deps after pixi install
+    # to avoid transitive dependency conflicts. See pixi_install().
 
     # Add platform-specific requirements
     if sys.platform == "linux" and env_config.linux_requirements:
@@ -557,6 +594,36 @@ def pixi_install(
 
     log("pixi install completed successfully!")
 
+    # Phase 2: Install CUDA packages with pip --no-deps
+    # These are kept out of pixi.toml to avoid transitive dependency conflicts
+    # Skip on macOS - CUDA is not supported
+    if env_config.no_deps_requirements:
+        if sys.platform == "darwin":
+            log("Skipping CUDA packages (not supported on macOS)")
+        else:
+            log("Installing CUDA packages with --no-deps...")
+            python_path = get_pixi_python(node_dir)
+            if not python_path:
+                raise RuntimeError("Failed to find Python in pixi environment")
+
+            vars_dict = _build_cuda_vars(env_config)
+
+            for req in env_config.no_deps_requirements:
+                url = _resolve_cuda_wheel_url(req, vars_dict, log)
+                if url:
+                    log(f"  Installing {req} (--no-deps)...")
+                    result = subprocess.run(
+                        [str(python_path), "-m", "pip", "install", "--no-deps", url],
+                        capture_output=True,
+                        text=True,
+                    )
+                    if result.returncode != 0:
+                        log(f"  Failed to install {req}:")
+                        log(result.stderr)
+                        raise RuntimeError(f"Failed to install {req} with --no-deps: {result.stderr}")
+                else:
+                    log(f"  Warning: Could not resolve wheel URL for {req}, skipping")
+
     # Create _env_{name} link for compatibility with uv backend
     # This ensures code that expects _env_envname/bin/python works with pixi
     symlink_path = node_dir / f"_env_{env_config.name}"

{comfy_env-0.0.55 → comfy_env-0.0.57}/src/comfy_env/workers/venv.py

@@ -41,7 +41,10 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from .base import Worker, WorkerError
+from ..pixi import get_pixi_path
 
+# Debug logging (set COMFY_ENV_DEBUG=1 to enable)
+_DEBUG = os.environ.get("COMFY_ENV_DEBUG", "").lower() in ("1", "true", "yes")
 
 # =============================================================================
 # Socket IPC utilities - cross-platform with TCP fallback
@@ -614,16 +617,21 @@ from types import SimpleNamespace
 # Enable faulthandler to dump traceback on SIGSEGV/SIGABRT/etc
 faulthandler.enable(file=sys.stderr, all_threads=True)
 
+# Debug logging (set COMFY_ENV_DEBUG=1 to enable)
+_DEBUG = os.environ.get("COMFY_ENV_DEBUG", "").lower() in ("1", "true", "yes")
+
 # Pre-import bpy FIRST to avoid DLL conflicts with numpy/torch/MKL
 # bpy's DLLs must be loaded before other packages load conflicting versions
 try:
     import bpy
-    print("[worker] Pre-imported bpy successfully", file=sys.stderr, flush=True)
+    if _DEBUG:
+        print("[worker] Pre-imported bpy successfully", file=sys.stderr, flush=True)
 except ImportError as e:
     # bpy not available in this environment - that's fine
     pass
 except Exception as e:
-    print(f"[worker] bpy pre-import warning: {e}", file=sys.stderr, flush=True)
+    if _DEBUG:
+        print(f"[worker] bpy pre-import warning: {e}", file=sys.stderr, flush=True)
 
 # Watchdog: dump all thread stacks every 60 seconds to catch hangs
 import threading
@@ -656,7 +664,8 @@ def _watchdog():
 
 _watchdog_thread = threading.Thread(target=_watchdog, daemon=True)
 _watchdog_thread.start()
-print(f"[worker] Watchdog started, logging to: {_watchdog_log}", flush=True)
+if _DEBUG:
+    print(f"[worker] Watchdog started, logging to: {_watchdog_log}", flush=True)
 
 # File-based logging for debugging (persists even if stdout/stderr are swallowed)
 import tempfile
@@ -676,14 +685,15 @@ def wlog(msg):
 
 wlog(f"[worker] === Worker starting, log file: {_worker_log_file} ===")
 
-# Debug: print PATH at startup
-_path_sep = ";" if sys.platform == "win32" else ":"
-_path_parts = os.environ.get("PATH", "").split(_path_sep)
-print(f"[worker] PATH has {len(_path_parts)} entries:", file=sys.stderr, flush=True)
-for _i, _p in enumerate(_path_parts[:15]):
-    print(f"[worker]   [{_i}] {_p}", file=sys.stderr, flush=True)
-if len(_path_parts) > 15:
-    print(f"[worker]   ... and {len(_path_parts) - 15} more", file=sys.stderr, flush=True)
+# Debug: print PATH at startup (only if debug enabled)
+if _DEBUG:
+    _path_sep = ";" if sys.platform == "win32" else ":"
+    _path_parts = os.environ.get("PATH", "").split(_path_sep)
+    print(f"[worker] PATH has {len(_path_parts)} entries:", file=sys.stderr, flush=True)
+    for _i, _p in enumerate(_path_parts[:15]):
+        print(f"[worker]   [{_i}] {_p}", file=sys.stderr, flush=True)
+    if len(_path_parts) > 15:
+        print(f"[worker]   ... and {len(_path_parts) - 15} more", file=sys.stderr, flush=True)
 
 # On Windows, add host Python's DLL directories so packages like opencv can find VC++ runtime
 if sys.platform == "win32":
@@ -1199,7 +1209,8 @@ class PersistentVenvWorker(Worker):
         # For pixi environments, use "pixi run python" to get proper environment activation
         # (CONDA_PREFIX, Library paths, etc.) which fixes DLL loading issues with bpy
         is_pixi = '.pixi' in str(self.python)
-        print(f"[PersistentVenvWorker] is_pixi={is_pixi}, python={self.python}", flush=True)
+        if _DEBUG:
+            print(f"[PersistentVenvWorker] is_pixi={is_pixi}, python={self.python}", flush=True)
         if is_pixi:
             # Find pixi project root (parent of .pixi directory)
             pixi_project = self.python
@@ -1207,10 +1218,14 @@ class PersistentVenvWorker(Worker):
                 pixi_project = pixi_project.parent
             pixi_project = pixi_project.parent  # Go up from .pixi to project root
             pixi_toml = pixi_project / "pixi.toml"
-            print(f"[PersistentVenvWorker] pixi_toml={pixi_toml}, exists={pixi_toml.exists()}", flush=True)
+            if _DEBUG:
+                print(f"[PersistentVenvWorker] pixi_toml={pixi_toml}, exists={pixi_toml.exists()}", flush=True)
 
             if pixi_toml.exists():
-                cmd = ["pixi", "run", "--manifest-path", str(pixi_toml),
+                pixi_exe = get_pixi_path()
+                if pixi_exe is None:
+                    raise WorkerError("pixi not found - required for isolated environment execution")
+                cmd = [str(pixi_exe), "run", "--manifest-path", str(pixi_toml),
                        "python", str(self._worker_script), self._socket_addr]
                 # Clean PATH to remove ct-env entries that have conflicting DLLs
                 # Pixi will add its own environment paths
@@ -1230,15 +1245,16 @@ class PersistentVenvWorker(Worker):
             cmd = [str(self.python), str(self._worker_script), self._socket_addr]
             launch_env = env
 
-        print(f"[PersistentVenvWorker] launching cmd={cmd[:3]}...", flush=True)
-        if launch_env:
-            path_sep = ";" if sys.platform == "win32" else ":"
-            path_parts = launch_env.get("PATH", "").split(path_sep)
-            print(f"[PersistentVenvWorker] PATH has {len(path_parts)} entries:", flush=True)
-            for i, p in enumerate(path_parts[:10]):  # Show first 10
-                print(f"[PersistentVenvWorker]   [{i}] {p}", flush=True)
-            if len(path_parts) > 10:
-                print(f"[PersistentVenvWorker]   ... and {len(path_parts) - 10} more", flush=True)
+        if _DEBUG:
+            print(f"[PersistentVenvWorker] launching cmd={cmd[:3]}...", flush=True)
+            if launch_env:
+                path_sep = ";" if sys.platform == "win32" else ":"
+                path_parts = launch_env.get("PATH", "").split(path_sep)
+                print(f"[PersistentVenvWorker] PATH has {len(path_parts)} entries:", flush=True)
+                for i, p in enumerate(path_parts[:10]):  # Show first 10
+                    print(f"[PersistentVenvWorker]   [{i}] {p}", flush=True)
+                if len(path_parts) > 10:
+                    print(f"[PersistentVenvWorker]   ... and {len(path_parts) - 10} more", flush=True)
         self._process = subprocess.Popen(
             cmd,
             stdin=subprocess.DEVNULL,
@@ -1389,12 +1405,15 @@ class PersistentVenvWorker(Worker):
             Return value of the method.
         """
         import sys
-        print(f"[PersistentVenvWorker] call_method: {module_name}.{class_name}.{method_name}", file=sys.stderr, flush=True)
+        if _DEBUG:
+            print(f"[PersistentVenvWorker] call_method: {module_name}.{class_name}.{method_name}", file=sys.stderr, flush=True)
 
         with self._lock:
-            print(f"[PersistentVenvWorker] acquired lock, ensuring started...", file=sys.stderr, flush=True)
+            if _DEBUG:
+                print(f"[PersistentVenvWorker] acquired lock, ensuring started...", file=sys.stderr, flush=True)
             self._ensure_started()
-            print(f"[PersistentVenvWorker] worker started/confirmed", file=sys.stderr, flush=True)
+            if _DEBUG:
+                print(f"[PersistentVenvWorker] worker started/confirmed", file=sys.stderr, flush=True)
 
             timeout = timeout or 600.0
             call_id = str(uuid.uuid4())[:8]
@@ -1406,11 +1425,14 @@ class PersistentVenvWorker(Worker):
             try:
                 # Serialize kwargs
                 if kwargs:
-                    print(f"[PersistentVenvWorker] serializing kwargs...", file=sys.stderr, flush=True)
+                    if _DEBUG:
+                        print(f"[PersistentVenvWorker] serializing kwargs...", file=sys.stderr, flush=True)
                     serialized_kwargs = _serialize_for_ipc(kwargs)
-                    print(f"[PersistentVenvWorker] saving to {inputs_path}...", file=sys.stderr, flush=True)
+                    if _DEBUG:
+                        print(f"[PersistentVenvWorker] saving to {inputs_path}...", file=sys.stderr, flush=True)
                     torch.save(serialized_kwargs, str(inputs_path))
-                    print(f"[PersistentVenvWorker] saved inputs", file=sys.stderr, flush=True)
+                    if _DEBUG:
+                        print(f"[PersistentVenvWorker] saved inputs", file=sys.stderr, flush=True)
 
                 # Send request with class info
                 request = {
@@ -1422,9 +1444,11 @@ class PersistentVenvWorker(Worker):
                     "inputs_path": str(inputs_path) if kwargs else None,
                     "outputs_path": str(outputs_path),
                 }
-                print(f"[PersistentVenvWorker] sending request via socket...", file=sys.stderr, flush=True)
+                if _DEBUG:
+                    print(f"[PersistentVenvWorker] sending request via socket...", file=sys.stderr, flush=True)
                 response = self._send_request(request, timeout)
-                print(f"[PersistentVenvWorker] got response: {response.get('status')}", file=sys.stderr, flush=True)
+                if _DEBUG:
+                    print(f"[PersistentVenvWorker] got response: {response.get('status')}", file=sys.stderr, flush=True)
 
                 if response.get("status") == "error":
                     raise WorkerError(