comfy-env 0.0.8__py3-none-any.whl → 0.0.16__py3-none-any.whl

comfy_env/__init__.py

@@ -1,46 +1,4 @@
-"""
-comfy-env: Environment management for ComfyUI custom nodes.
-
-This package provides:
-- CUDA wheel resolution and in-place installation (Type 2 nodes)
-- Process isolation with separate venvs (Type 1 nodes)
-
-## Quick Start - In-Place Installation
-
-    from comfy_env import install
-
-    # Auto-discover config and install CUDA wheels
-    install()
-
-    # Or with explicit config
-    install(config="comfyui_env.toml")
-
-## Quick Start - Process Isolation
-
-    from comfy_env.workers import get_worker, TorchMPWorker
-
-    # Same-venv isolation (zero-copy tensors)
-    worker = TorchMPWorker()
-    result = worker.call(my_gpu_function, image=tensor)
-
-    # Cross-venv isolation
-    from comfy_env.workers import PersistentVenvWorker
-    worker = PersistentVenvWorker(python="/path/to/venv/bin/python")
-    result = worker.call_module("my_module", "my_func", image=tensor)
-
-## CLI
-
-    comfy-env install          # Install from config
-    comfy-env info             # Show environment info
-    comfy-env resolve pkg==1.0 # Show resolved wheel URL
-    comfy-env doctor           # Verify installation
-
-## Legacy APIs (still supported)
-
-The @isolated decorator and WorkerBridge are still available.
-"""
-
-__version__ = "0.0.8"
+__version__ = "0.0.14"
 
 from .env.config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
 from .env.config_file import (
@@ -51,7 +9,16 @@ from .env.config_file import (
     CONFIG_FILE_NAMES,
 )
 from .env.manager import IsolatedEnvManager
-from .env.detection import detect_cuda_version, detect_gpu_info, get_gpu_summary
+from .env.cuda_gpu_detection import (
+    GPUInfo,
+    CUDAEnvironment,
+    detect_cuda_environment,
+    detect_cuda_version,
+    detect_gpu_info,
+    detect_gpus,
+    get_gpu_summary,
+    get_recommended_cuda_version,
+)
 from .env.security import (
     normalize_env_name,
     validate_dependency,
@@ -134,9 +101,14 @@ __all__ = [
     "discover_config",
     "CONFIG_FILE_NAMES",
     # Detection
+    "GPUInfo",
+    "CUDAEnvironment",
+    "detect_cuda_environment",
     "detect_cuda_version",
     "detect_gpu_info",
+    "detect_gpus",
     "get_gpu_summary",
+    "get_recommended_cuda_version",
     # Security validation
     "normalize_env_name",
     "validate_dependency",

comfy_env/cli.py

@@ -234,6 +234,7 @@ def cmd_info(args) -> int:
 def cmd_resolve(args) -> int:
     """Handle resolve command."""
     from .resolver import RuntimeEnv, WheelResolver, parse_wheel_requirement
+    from .registry import PACKAGE_REGISTRY
     from .env.config_file import discover_env_config, load_env_from_file
 
     env = RuntimeEnv.detect()
@@ -270,19 +271,116 @@ def cmd_resolve(args) -> int:
             print(f"  {package}: No version specified, skipping")
             continue
 
+        pkg_lower = package.lower()
         try:
-            url = resolver.resolve(package, version, env, verify=args.verify)
-            status = "OK" if args.verify else "resolved"
-            print(f"  {package}=={version}: {status}")
-            print(f"    {url}")
+            # Check if package is in registry with github_release method
+            if pkg_lower in PACKAGE_REGISTRY:
+                registry_config = PACKAGE_REGISTRY[pkg_lower]
+                method = registry_config.get("method")
+
+                if method == "github_release":
+                    # Resolve URL from registry sources
+                    url = _resolve_github_release_url(package, version, env, registry_config)
+                    status = "OK" if args.verify else "resolved"
+                    print(f"  {package}=={version}: {status}")
+                    print(f"    {url}")
+                else:
+                    # For other methods, just show what method will be used
+                    print(f"  {package}=={version}: uses {method} method")
+                    if "index_url" in registry_config:
+                        index_url = _substitute_template(registry_config["index_url"], env)
+                        print(f"    index: {index_url}")
+                    elif "package_template" in registry_config:
+                        pkg_name = _substitute_template(registry_config["package_template"], env)
+                        print(f"    installs as: {pkg_name}")
+            else:
+                # Fall back to WheelResolver
+                url = resolver.resolve(package, version, env, verify=args.verify)
+                status = "OK" if args.verify else "resolved"
+                print(f"  {package}=={version}: {status}")
+                print(f"    {url}")
         except Exception as e:
             print(f"  {package}=={version}: FAILED")
-            print(f"    {e}")
+            _print_wheel_not_found_error(package, version, env, e)
             all_ok = False
 
     return 0 if all_ok else 1
 
 
+def _substitute_template(template: str, env) -> str:
+    """Substitute environment variables into a URL template."""
+    vars_dict = env.as_dict()
+    result = template
+    for key, value in vars_dict.items():
+        if value is not None:
+            result = result.replace(f"{{{key}}}", str(value))
+    return result
+
+
+def _resolve_github_release_url(package: str, version: str, env, config: dict) -> str:
+    """Resolve URL for github_release method packages."""
+    sources = config.get("sources", [])
+    if not sources:
+        raise ValueError(f"No sources configured for {package}")
+
+    # Build template variables
+    vars_dict = env.as_dict()
+    vars_dict["version"] = version
+    vars_dict["py_tag"] = f"cp{env.python_short}"
+    if env.cuda_version:
+        vars_dict["cuda_major"] = env.cuda_version.split(".")[0]
+
+    # Filter sources by platform
+    current_platform = env.platform_tag
+    compatible_sources = [
+        s for s in sources
+        if current_platform in s.get("platforms", [])
+    ]
+
+    if not compatible_sources:
+        available = set()
+        for s in sources:
+            available.update(s.get("platforms", []))
+        raise ValueError(
+            f"No {package} wheels for platform {current_platform}. "
+            f"Available: {', '.join(sorted(available))}"
+        )
+
+    # Return URL from first compatible source
+    source = compatible_sources[0]
+    url_template = source.get("url_template", "")
+    url = url_template
+    for key, value in vars_dict.items():
+        if value is not None:
+            url = url.replace(f"{{{key}}}", str(value))
+
+    return url
+
+
+def _print_wheel_not_found_error(package: str, version: str, env, error: Exception) -> None:
+    """Print a formatted error message for wheel not found."""
+    from .errors import WheelNotFoundError
+
+    if isinstance(error, WheelNotFoundError):
+        print(f"    CUDA wheel not found: {package}=={version}")
+        print()
+        print("+------------------------------------------------------------------+")
+        print("|  CUDA Wheel Not Found                                            |")
+        print("+------------------------------------------------------------------+")
+        print(f"|  Package:   {package}=={version:<46} |")
+        print(f"|  Requested: cu{env.cuda_short}-torch{env.torch_mm}-{env.python_short}-{env.platform_tag:<17} |")
+        print("|                                                                  |")
+        print(f"|  Reason: {error.reason:<54} |")
+        print("|                                                                  |")
+        print("|  Suggestions:                                                    |")
+        print(f"|    1. Check if wheel exists: comfy-env resolve {package:<15} |")
+        print(f"|    2. Build wheel locally: comfy-env build {package:<18} |")
+        print("|                                                                  |")
+        print("+------------------------------------------------------------------+")
+    else:
+        print(f"    {error}")
+
+
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation

comfy_env/env/__init__.py

@@ -1,8 +1,17 @@
 """Environment management for comfyui-isolation."""
 
-from .config import IsolatedEnv
+from .config import IsolatedEnv, ToolConfig
 from .manager import IsolatedEnvManager
-from .detection import detect_cuda_version, detect_gpu_info, get_gpu_summary
+from .cuda_gpu_detection import (
+    GPUInfo,
+    CUDAEnvironment,
+    detect_cuda_environment,
+    detect_cuda_version,
+    detect_gpu_info,
+    detect_gpus,
+    get_gpu_summary,
+    get_recommended_cuda_version,
+)
 from .platform import get_platform, PlatformProvider, PlatformPaths
 from .security import (
     normalize_env_name,
@@ -15,9 +24,17 @@ from .security import (
 __all__ = [
     "IsolatedEnv",
     "IsolatedEnvManager",
+    "ToolConfig",
+    # GPU Detection
+    "GPUInfo",
+    "CUDAEnvironment",
+    "detect_cuda_environment",
     "detect_cuda_version",
     "detect_gpu_info",
+    "detect_gpus",
     "get_gpu_summary",
+    "get_recommended_cuda_version",
+    # Platform
     "get_platform",
     "PlatformProvider",
     "PlatformPaths",

comfy_env/env/config.py

@@ -23,6 +23,14 @@ 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:
     """
@@ -35,10 +43,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")
     """
     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)
 
     @property
     def has_local(self) -> bool:
@@ -98,6 +108,10 @@ class IsolatedEnv:
     cuda: Optional[str] = None
     requirements: list[str] = field(default_factory=list)
     no_deps_requirements: list[str] = field(default_factory=list)  # Install with --no-deps
+    # Platform-specific requirements (merged at install time)
+    windows_requirements: list[str] = field(default_factory=list)
+    linux_requirements: list[str] = field(default_factory=list)
+    darwin_requirements: list[str] = field(default_factory=list)
     requirements_file: Optional[Path] = None
     wheel_sources: list[str] = field(default_factory=list)
     index_urls: list[str] = field(default_factory=list)

comfy_env/env/config_file.py

@@ -63,8 +63,8 @@ else:
     except ImportError:
         tomllib = None  # type: ignore
 
-from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq
-from .detection import detect_cuda_version
+from .config import IsolatedEnv, EnvManagerConfig, LocalConfig, NodeReq, ToolConfig
+from .cuda_gpu_detection import detect_cuda_version
 
 
 # Config file name
@@ -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"  # Legacy: Pascal GPUs
+        return "2.5.1"  # Full: Pascal GPUs
     return "2.8.0"  # Modern: Turing through Blackwell
 
 
@@ -176,7 +176,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
     """
     Parse TOML data into IsolatedEnv.
 
-    Supports both simplified and legacy config formats:
+    Supports both simplified and full config formats:
 
     Simplified (CUDA packages only):
         [packages]
@@ -186,7 +186,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
     Or as list:
         packages = ["torch-scatter==2.1.2", "torch-cluster==1.6.3"]
 
-    Legacy:
+    Full:
         [env]
         name = "my-node"
         [packages]
@@ -233,7 +233,7 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
         variables.setdefault("pytorch_mm", pytorch_mm)
 
     # Parse CUDA packages - support multiple formats
-    # Priority: [cuda] section > cuda = [...] > legacy [packages] section
+    # Priority: [cuda] section > cuda = [...] > [packages] section
     no_deps_requirements = []
     requirements = []
 
@@ -258,12 +258,12 @@ def _parse_config(data: Dict[str, Any], base_dir: Path) -> IsolatedEnv:
 
     elif isinstance(packages_section, dict):
         # Check for simplified format: [packages] with key=value pairs
-        # vs legacy format: [packages] with requirements/no_deps lists
+        # vs old format: [packages] with requirements/no_deps lists
 
-        has_legacy_keys = any(k in packages_section for k in ["requirements", "no_deps", "requirements_file"])
+        has_old_keys = any(k in packages_section for k in ["requirements", "no_deps", "requirements_file"])
 
-        if has_legacy_keys:
-            # Legacy format
+        if has_old_keys:
+            # Old format
             raw_requirements = packages_section.get("requirements", [])
             requirements = [_substitute_vars(req, variables) for req in raw_requirements]
 
@@ -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"}
+RESERVED_TABLES = {"local", "node_reqs", "env", "packages", "sources", "cuda", "variables", "worker", "tools"}
 
 
 def load_config(
@@ -340,9 +340,9 @@ def load_config(
     base_dir: Optional[Path] = None,
 ) -> EnvManagerConfig:
     """
-    Load full EnvManagerConfig from a TOML file (v2 schema).
+    Load full EnvManagerConfig from a TOML file.
 
-    Supports both v2 schema and legacy format (auto-detected).
+    Supports both full schema (named envs) and simple format (auto-detected).
 
     Args:
         path: Path to the TOML config file
@@ -373,7 +373,7 @@ def load_config(
     with open(path, "rb") as f:
         data = tomllib.load(f)
 
-    return _parse_config_v2(data, base_dir)
+    return _parse_full_config(data, base_dir)
 
 
 def discover_config(
@@ -404,9 +404,9 @@ def discover_config(
     return None
 
 
-def _parse_config_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
+def _parse_full_config(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
     """
-    Parse TOML data into EnvManagerConfig (v2 schema).
+    Parse TOML data into EnvManagerConfig.
 
     Schema:
         [local.cuda]        - CUDA packages for host
@@ -416,24 +416,26 @@ def _parse_config_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
         [envname.packages]  - Packages for env
         [node_reqs]         - Node dependencies
 
-    Also supports legacy format for backward compatibility.
+    Also supports simple format ([env] + [packages]) for backward compatibility.
     """
-    # Detect if this is v2 schema or legacy
-    is_v2 = "local" in data or _has_named_env(data)
+    # Detect if this is full schema or simple format
+    is_full = "local" in data or _has_named_env(data)
 
-    if not is_v2:
-        # Legacy format - convert to v2 structure
-        return _convert_legacy_to_v2(data, base_dir)
+    if not is_full:
+        # Simple format - convert to full structure
+        return _convert_simple_to_full(data, base_dir)
 
-    # Parse v2 schema
+    # Parse full schema
     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", {}))
 
     return EnvManagerConfig(
         local=local,
         envs=envs,
         node_reqs=node_reqs,
+        tools=tools,
     )
 
 
@@ -529,6 +531,30 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
     elif isinstance(packages_section, list):
         requirements = packages_section
 
+    # Parse platform-specific packages [envname.packages.windows], etc.
+    windows_reqs = []
+    linux_reqs = []
+    darwin_reqs = []
+
+    if isinstance(packages_section, dict):
+        win_section = packages_section.get("windows", {})
+        if isinstance(win_section, dict):
+            windows_reqs = win_section.get("requirements", [])
+        elif isinstance(win_section, list):
+            windows_reqs = win_section
+
+        linux_section = packages_section.get("linux", {})
+        if isinstance(linux_section, dict):
+            linux_reqs = linux_section.get("requirements", [])
+        elif isinstance(linux_section, list):
+            linux_reqs = linux_section
+
+        darwin_section = packages_section.get("darwin", {})
+        if isinstance(darwin_section, dict):
+            darwin_reqs = darwin_section.get("requirements", [])
+        elif isinstance(darwin_section, list):
+            darwin_reqs = darwin_section
+
     return IsolatedEnv(
         name=name,
         python=python,
@@ -536,6 +562,9 @@ def _parse_single_env(name: str, env_data: Dict[str, Any], base_dir: Path) -> Is
         pytorch_version=pytorch,
         requirements=requirements,
         no_deps_requirements=no_deps_requirements,
+        windows_requirements=windows_reqs,
+        linux_requirements=linux_reqs,
+        darwin_requirements=darwin_reqs,
     )
 
 
@@ -555,27 +584,63 @@ def _parse_node_reqs(node_reqs_data: Dict[str, Any]) -> List[NodeReq]:
     return reqs
 
 
-def _convert_legacy_to_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
-    """Convert legacy config format to v2 EnvManagerConfig."""
-    # Parse using legacy parser to get IsolatedEnv
-    legacy_env = _parse_config(data, base_dir)
+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 _convert_simple_to_full(data: Dict[str, Any], base_dir: Path) -> EnvManagerConfig:
+    """Convert simple config format to full EnvManagerConfig.
 
-    # Check if this is really just a Type 2 config (local CUDA only, no venv)
-    # Type 2 indicators: no [env] section with name, or name matches directory
+    Simple configs have [env] and [packages] sections but no named environments.
+    This converts them to the full format with a single named environment.
+    """
+    # Parse using simple parser to get IsolatedEnv
+    simple_env = _parse_config(data, base_dir)
+
+    # Parse tools section (shared between simple and full format)
+    tools = _parse_tools_section(data.get("tools", {}))
+
+    # Check if this has explicit env settings (isolated venv) vs just CUDA packages (local install)
     env_section = data.get("env", {})
     has_explicit_env = bool(env_section.get("name") or env_section.get("python"))
 
     if has_explicit_env:
-        # This is a Type 1 config (isolated venv)
+        # Isolated venv config
         return EnvManagerConfig(
             local=LocalConfig(),
-            envs={legacy_env.name: legacy_env},
+            envs={simple_env.name: simple_env},
             node_reqs=[],
+            tools=tools,
         )
     else:
-        # This is a Type 2 config (local CUDA only)
+        # Local CUDA packages only (no isolated venv)
         cuda_packages = {}
-        for req in legacy_env.no_deps_requirements:
+        for req in simple_env.no_deps_requirements:
             if "==" in req:
                 pkg, ver = req.split("==", 1)
                 cuda_packages[pkg] = ver
@@ -585,8 +650,9 @@ def _convert_legacy_to_v2(data: Dict[str, Any], base_dir: Path) -> EnvManagerCon
         return EnvManagerConfig(
             local=LocalConfig(
                 cuda_packages=cuda_packages,
-                requirements=legacy_env.requirements,
+                requirements=simple_env.requirements,
             ),
             envs={},
             node_reqs=[],
-        )
+            tools=tools,
+        )