comfy-env 0.0.65__py3-none-any.whl → 0.0.66__py3-none-any.whl

comfy_env/env/__init__.py

@@ -1,46 +0,0 @@
-"""Environment management for comfyui-isolation."""
-
-from .config import IsolatedEnv
-from .manager import IsolatedEnvManager
-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,
-    validate_dependency,
-    validate_dependencies,
-    validate_path_within_root,
-    validate_wheel_url,
-)
-
-__all__ = [
-    "IsolatedEnv",
-    "IsolatedEnvManager",
-    # 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",
-    # Security
-    "normalize_env_name",
-    "validate_dependency",
-    "validate_dependencies",
-    "validate_path_within_root",
-    "validate_wheel_url",
-]

comfy_env/env/config.py

@@ -1,191 +0,0 @@
-"""Configuration for isolated environments."""
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Dict, List, Optional
-
-
-@dataclass
-class SystemConfig:
-    """Configuration for system-level packages.
-
-    These are OS-level packages (apt, brew, etc.) that need to be installed
-    before Python packages can work properly.
-    """
-    linux: List[str] = field(default_factory=list)    # apt packages
-    darwin: List[str] = field(default_factory=list)   # brew packages (future)
-    windows: List[str] = field(default_factory=list)  # winget packages (future)
-
-
-@dataclass
-class LocalConfig:
-    """Configuration for local (host environment) installs.
-
-    These packages are installed into ComfyUI's main environment,
-    not into an isolated venv.
-    """
-    cuda_packages: Dict[str, str] = field(default_factory=dict)  # package -> version
-    requirements: List[str] = field(default_factory=list)
-
-
-@dataclass
-class CondaConfig:
-    """Configuration for conda packages (installed via pixi).
-
-    When present, the environment uses pixi as the backend instead of uv.
-    Pixi manages both conda and pip packages in a unified environment.
-    """
-    channels: List[str] = field(default_factory=list)  # conda channels
-    packages: List[str] = field(default_factory=list)  # conda packages
-
-
-@dataclass
-class NodeReq:
-    """A node dependency (another ComfyUI node pack)."""
-    name: str
-    repo: str  # GitHub repo path, e.g., "Kosinkadink/ComfyUI-VideoHelperSuite"
-
-
-@dataclass
-class EnvManagerConfig:
-    """
-    Full configuration parsed from comfy-env.toml.
-
-    Supports the v2 schema:
-        [system]            - System-level packages (apt, brew, etc.)
-        [local.cuda]        - CUDA packages for host environment
-        [local.packages]    - Regular packages for host environment
-        [envname]           - Isolated env definition
-        [envname.cuda]      - CUDA packages for isolated env
-        [envname.packages]  - Regular packages for isolated env
-        [node_reqs]         - Node dependencies
-        [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)
-    wheel_sources: Dict[str, str] = field(default_factory=dict)  # package -> wheel_template URL
-
-    @property
-    def has_system(self) -> bool:
-        """Check if there are system packages to install."""
-        return bool(self.system.linux or self.system.darwin or self.system.windows)
-
-    @property
-    def has_local(self) -> bool:
-        """Check if there are local packages to install."""
-        return bool(self.local.cuda_packages or self.local.requirements)
-
-    @property
-    def has_envs(self) -> bool:
-        """Check if there are isolated environments defined."""
-        return bool(self.envs)
-
-    def get_env(self, name: str) -> Optional["IsolatedEnv"]:
-        """Get an isolated environment by name."""
-        return self.envs.get(name)
-
-    @property
-    def default_env(self) -> Optional["IsolatedEnv"]:
-        """Get the first/only isolated environment, or None."""
-        if self.envs:
-            return next(iter(self.envs.values()))
-        return None
-
-
-@dataclass
-class IsolatedEnv:
-    """
-    Configuration for an isolated Python environment.
-
-    This defines what Python version, CUDA version, and dependencies
-    should be installed in the isolated environment.
-
-    Args:
-        name: Unique name for this environment (used for caching)
-        python: Python version (e.g., "3.10", "3.11")
-        cuda: CUDA version (e.g., "12.4", "12.8") or None for CPU-only
-        requirements: List of pip requirements (e.g., ["torch==2.8.0", "numpy"])
-        requirements_file: Path to requirements.txt file
-        wheel_sources: List of URLs for --find-links (custom wheel repos)
-        index_urls: List of URLs for --extra-index-url
-        env_dir: Custom directory for the venv (default: auto-generated)
-        pytorch_version: Specific PyTorch version (auto-detected if None)
-        worker_package: Worker package directory (e.g., "worker" -> worker/__main__.py)
-        worker_script: Worker script file (e.g., "worker.py")
-
-    Example:
-        env = IsolatedEnv(
-            name="my-node",
-            python="3.10",
-            cuda="12.8",
-            requirements=["torch==2.8.0", "nvdiffrast"],
-            wheel_sources=["https://my-wheels.github.io/"],
-        )
-    """
-
-    name: str
-    python: str = "3.10"
-    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)
-    env_dir: Optional[Path] = None
-    pytorch_version: Optional[str] = None
-    # Worker configuration
-    worker_package: Optional[str] = None  # e.g., "worker" -> worker/__main__.py
-    worker_script: Optional[str] = None   # e.g., "worker.py" -> worker.py
-    # Conda configuration (uses pixi backend when present)
-    conda: Optional["CondaConfig"] = None
-    # Runtime isolation - run node FUNCTION methods in isolated subprocess
-    isolated: bool = False
-    # Environment variables for install (e.g., CMAKE_ARGS for build flags)
-    env_vars: Dict[str, str] = field(default_factory=dict)
-
-    def __post_init__(self):
-        """Validate and normalize configuration."""
-        # Normalize paths
-        if self.requirements_file is not None:
-            self.requirements_file = Path(self.requirements_file)
-        if self.env_dir is not None:
-            self.env_dir = Path(self.env_dir)
-
-        # Validate Python version
-        if not self.python.replace(".", "").isdigit():
-            raise ValueError(f"Invalid Python version: {self.python}")
-
-        # Validate CUDA version if specified
-        if self.cuda is not None:
-            cuda_clean = self.cuda.replace(".", "")
-            if not cuda_clean.isdigit():
-                raise ValueError(f"Invalid CUDA version: {self.cuda}")
-
-    @property
-    def cuda_short(self) -> Optional[str]:
-        """Get CUDA version without dots (e.g., '128' for '12.8')."""
-        if self.cuda is None:
-            return None
-        return self.cuda.replace(".", "")
-
-    @property
-    def python_short(self) -> str:
-        """Get Python version without dots (e.g., '310' for '3.10')."""
-        return self.python.replace(".", "")
-
-    def get_default_env_dir(self, base_dir: Path) -> Path:
-        """Get the default environment directory path."""
-        if self.env_dir is not None:
-            return self.env_dir
-        return base_dir / f"_env_{self.name}"
-
-    @property
-    def uses_conda(self) -> bool:
-        """Check if this environment uses conda packages (pixi backend)."""
-        return self.conda is not None and bool(self.conda.packages)