comfy-env 0.0.62__tar.gz → 0.0.65__tar.gz

{comfy_env-0.0.62 → comfy_env-0.0.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.62
+Version: 0.0.65
 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.62 → comfy_env-0.0.65}/pyproject.toml

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

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/env/__init__.py

@@ -1,6 +1,6 @@
 """Environment management for comfyui-isolation."""
 
-from .config import IsolatedEnv, ToolConfig
+from .config import IsolatedEnv
 from .manager import IsolatedEnvManager
 from .cuda_gpu_detection import (
     GPUInfo,
@@ -24,7 +24,6 @@ from .security import (
 __all__ = [
     "IsolatedEnv",
     "IsolatedEnvManager",
-    "ToolConfig",
     # GPU Detection
     "GPUInfo",
     "CUDAEnvironment",

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/env/config.py

@@ -46,14 +46,6 @@ class NodeReq:
     repo: str  # GitHub repo path, e.g., "Kosinkadink/ComfyUI-VideoHelperSuite"
 
 
-@dataclass
-class ToolConfig:
-    """Configuration for an external tool like Blender."""
-    name: str
-    version: str = "latest"
-    install_dir: Optional[Path] = None
-
-
 @dataclass
 class EnvManagerConfig:
     """
@@ -67,14 +59,12 @@ class EnvManagerConfig:
         [envname.cuda]      - CUDA packages for isolated env
         [envname.packages]  - Regular packages for isolated env
         [node_reqs]         - Node dependencies
-        [tools]             - External tools (e.g., blender = "4.2")
         [wheel_sources]     - Custom wheel URL templates (override registry)
     """
     system: SystemConfig = field(default_factory=SystemConfig)
     local: LocalConfig = field(default_factory=LocalConfig)
     envs: Dict[str, "IsolatedEnv"] = field(default_factory=dict)
     node_reqs: List[NodeReq] = field(default_factory=list)
-    tools: Dict[str, ToolConfig] = field(default_factory=dict)
     wheel_sources: Dict[str, str] = field(default_factory=dict)  # package -> wheel_template URL
 
     @property

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/env/config_file.py

@@ -63,7 +63,7 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, ToolConfig, CondaConfig
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, SystemConfig, CondaConfig
 from .cuda_gpu_detection import detect_cuda_version
 
 
@@ -168,7 +168,7 @@ def _get_default_pytorch_version(cuda_version: Optional[str]) -> str:
         - CUDA 12.8 (Turing+): PyTorch 2.8.0
     """
     if cuda_version == "12.4":
-        return "2.5.1"  # Full: Pascal GPUs
+        return "2.4.0"  # Pascal GPUs (last PyTorch with sm_60/61 support)
     return "2.8.0"  # Modern: Turing through Blackwell
 
 
@@ -332,7 +332,7 @@ def _substitute_vars(s: str, variables: Dict[str, str]) -> str:
 # =============================================================================
 
 # Reserved table names that are NOT isolated environments
-RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools", "system", "wheel_sources"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "system", "wheel_sources"}
 
 
 def load_config(
@@ -431,7 +431,6 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
     local = _parse_local_section(data.get("local", {}))
     envs = _parse_env_sections(data, base_dir)
     node_reqs = _parse_node_reqs(data.get("node_reqs", {}))
-    tools = _parse_tools_section(data.get("tools", {}))
     wheel_sources = _parse_wheel_sources_section(data.get("wheel_sources", {}))
 
     return EnvManagerConfig(
@@ -439,7 +438,6 @@ def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig
         local=local,
         envs=envs,
         node_reqs=node_reqs,
-        tools=tools,
         wheel_sources=wheel_sources,
     )
 
@@ -614,35 +612,6 @@ def _parse_node_reqs(node_reqs_data: Dict[str, Any]) -> List[NodeReq]:
     return reqs
 
 
-def _parse_tools_section(tools_data: Dict[str, Any]) -> Dict[str, ToolConfig]:
-    """Parse [tools] section.
-
-    Supports:
-        [tools]
-        blender = "4.2"
-
-    Or extended:
-        [tools.blender]
-        version = "4.2"
-        install_dir = "/custom/path"
-    """
-    tools = {}
-
-    for name, value in tools_data.items():
-        if isinstance(value, str):
-            # Simple format: blender = "4.2"
-            tools[name] = ToolConfig(name=name, version=value)
-        elif isinstance(value, dict):
-            # Extended format: [tools.blender] with version, install_dir
-            version = value.get("version", "latest")
-            install_dir = value.get("install_dir")
-            if install_dir:
-                install_dir = Path(install_dir)
-            tools[name] = ToolConfig(name=name, version=version, install_dir=install_dir)
-
-    return tools
-
-
 def _parse_system_section(system_data: Dict[str, Any]) -> SystemConfig:
     """Parse [system] section.
 
@@ -698,8 +667,7 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
     # Parse using simple parser to get IsolatedEnv
     simple_env = _parse_config(data, base_dir)
 
-    # Parse tools, system, and wheel_sources sections (shared between simple and full format)
-    tools = _parse_tools_section(data.get("tools", {}))
+    # Parse system and wheel_sources sections (shared between simple and full format)
     system = _parse_system_section(data.get("system", {}))
     wheel_sources = _parse_wheel_sources_section(data.get("wheel_sources", {}))
 
@@ -714,7 +682,6 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             local=LocalConfig(),
             envs={simple_env.name: simple_env},
             node_reqs=[],
-            tools=tools,
             wheel_sources=wheel_sources,
         )
     else:
@@ -735,6 +702,5 @@ def _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerC
             ),
             envs={},
             node_reqs=[],
-            tools=tools,
             wheel_sources=wheel_sources,
         )

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/pixi.py

@@ -329,15 +329,10 @@ def create_pixi_toml(
     lines.append(f'name = "{env_config.name}"')
     lines.append('version = "0.1.0"')
 
-    # Channels - add pytorch channel, and nvidia if CUDA GPU detected
+    # Channels - use conda-forge only (pytorch channel is deprecated)
+    # PyTorch is installed via PyPI with extra-index-urls for proper CUDA version support
     base_channels = conda.channels or ["conda-forge"]
-    if env_config.cuda:
-        # GPU detected - add pytorch and nvidia channels for CUDA support
-        channels = ["pytorch", "nvidia"] + [ch for ch in base_channels if ch not in ["pytorch", "nvidia"]]
-    else:
-        # No GPU - just add pytorch channel for CPU-only pytorch
-        channels = ["pytorch"] + [ch for ch in base_channels if ch != "pytorch"]
-    channels_str = ", ".join(f'"{ch}"' for ch in channels)
+    channels_str = ", ".join(f'"{ch}"' for ch in base_channels)
     lines.append(f"channels = [{channels_str}]")
 
     # Platforms
@@ -365,20 +360,6 @@ def create_pixi_toml(
     lines.append(f'python = "{env_config.python}.*"')
     lines.append('pip = "*"')  # Required for installing CUDA packages with --no-deps
 
-    # Add PyTorch via conda
-    # - With GPU: pytorch + pytorch-cuda for CUDA support
-    # - No GPU: pytorch 2.8.0 CPU-only (default)
-    torch_version = env_config.pytorch_version or "2.8.0"
-    torch_parts = torch_version.split(".")
-    torch_mm = ".".join(torch_parts[:2])  # "2.8.0" -> "2.8"
-    lines.append(f'pytorch = "{torch_mm}.*"')
-
-    if env_config.cuda:
-        # GPU detected - add pytorch-cuda for CUDA runtime
-        cuda_parts = env_config.cuda.split(".")
-        cuda_mm = ".".join(cuda_parts[:2])  # "12.8" -> "12.8"
-        lines.append(f'pytorch-cuda = "{cuda_mm}"')
-
     # On Windows, use MKL BLAS to avoid OpenBLAS crashes (numpy blas_fpe_check issue)
     if sys.platform == "win32":
         lines.append('libblas = { version = "*", build = "*mkl" }')
@@ -455,6 +436,23 @@ def create_pixi_toml(
     elif sys.platform == "win32" and env_config.windows_requirements:
         pypi_deps.extend(env_config.windows_requirements)
 
+    # PyPI options for PyTorch - use CUDA index for GPU, plain PyPI for CPU
+    # The pytorch conda channel is deprecated, so we use PyPI wheels
+    if env_config.cuda:
+        # GPU detected - use CUDA-enabled PyTorch wheels
+        cuda_parts = env_config.cuda.split(".")
+        cuda_short = "".join(cuda_parts[:2])  # "12.8" -> "128"
+        lines.append("[pypi-options]")
+        lines.append(f'extra-index-urls = ["https://download.pytorch.org/whl/cu{cuda_short}"]')
+        lines.append("")
+    # For CPU-only, no extra index needed - plain torch from PyPI works
+
+    # Add torch to pypi dependencies
+    torch_version = env_config.pytorch_version or "2.8.0"
+    torch_parts = torch_version.split(".")
+    torch_mm = ".".join(torch_parts[:2])  # "2.8.0" -> "2.8"
+    pypi_deps.insert(0, f"torch>={torch_mm},<{torch_parts[0]}.{int(torch_parts[1])+1}")
+
     if pypi_deps or special_deps:
         lines.append("[pypi-dependencies]")
 

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/templates/comfy-env.toml

@@ -85,15 +85,6 @@ requirements = []
 # ComfyUI-Impact-Pack = "ltdrdata/ComfyUI-Impact-Pack"
 
 
-# =============================================================================
-# EXTERNAL TOOLS (optional)
-# =============================================================================
-# External applications required by the node.
-
-[tools]
-# blender = "4.2"
-
-
 # #############################################################################
 #
 #                       PROCESS ISOLATION (ADVANCED)

{comfy_env-0.0.62 → comfy_env-0.0.65}/src/comfy_env/workers/venv.py

@@ -204,6 +204,11 @@ def _serialize_for_ipc(obj, visited=None):
     if obj_id in visited:
         return visited[obj_id]  # Return cached serialized result
 
+    # Handle Path objects - convert to string for JSON serialization
+    from pathlib import PurePath
+    if isinstance(obj, PurePath):
+        return str(obj)
+
     # Check if this is a custom object with broken module path
     if (hasattr(obj, '__dict__') and
         hasattr(obj, '__class__') and
@@ -762,7 +767,10 @@ def _should_use_reference(obj):
     # Dicts, lists, tuples - recurse into contents (don't ref the container)
     if isinstance(obj, (dict, list, tuple)):
         return False
-    # Everything else (trimesh, custom classes) - pass by reference
+    # Trimesh - pass by value (pickle handles it well across Python versions)
+    if obj_type == 'Trimesh':
+        return False
+    # Everything else (custom classes) - pass by reference
     return True
 
 def _serialize_result(obj, visited=None):
@@ -1435,12 +1443,14 @@ class PersistentVenvWorker(Worker):
                         print(f"[PersistentVenvWorker] saved inputs", file=sys.stderr, flush=True)
 
                 # Send request with class info
+                # Serialize self_state to handle Path objects and other non-JSON types
+                serialized_self_state = _serialize_for_ipc(self_state) if self_state else None
                 request = {
                     "type": "call_method",
                     "module": module_name,
                     "class_name": class_name,
                     "method_name": method_name,
-                    "self_state": self_state,
+                    "self_state": serialized_self_state,
                     "inputs_path": str(inputs_path) if kwargs else None,
                     "outputs_path": str(outputs_path),
                 }