comfy-env 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

comfy_env-0.1.17.dist-info/RECORD

@@ -0,0 +1,36 @@
+comfy_env/__init__.py,sha256=7R1WnVv6Rmq97bbK2Fvp1A50jkFwxIgcmfiILit9k8E,4666
+comfy_env/cli.py,sha256=SWErVa3lB2ZHc7aNJJgWElWCRMsCzVLP_CrupuOk_zw,7684
+comfy_env/install.py,sha256=CT3A3kIVQqXGA5nfp7jxTU_gHdsood4NsjW0tbXv7_8,10781
+comfy_env/config/__init__.py,sha256=QlxIc5Hdghje6cm4FutReMO6fQK5rBu-zr36V2fjcLE,474
+comfy_env/config/parser.py,sha256=bNSy8Jn4VZg3xw8pldlkEyGaaI_BmNsUEYQz-hKiXgE,2221
+comfy_env/config/types.py,sha256=vFgWeEl_p26OmcoUv0wAOlHe9GBio2isjIWl7kACKFY,1096
+comfy_env/detection/__init__.py,sha256=dH84PlSRJfs8MRJp2gp9_NX8ZzGIDHR8iZXy7_B8Ez4,1671
+comfy_env/detection/cuda.py,sha256=BOaRQOGP2yoaPCO9eqPvWBB5Us_MNo-sSbadQsIjHqM,1708
+comfy_env/detection/gpu.py,sha256=Rf7pgtZXzUbJqcXzZXQi-yK5naeuSP1FiL6SdreeADM,8393
+comfy_env/detection/platform.py,sha256=Xe01dIZm7JT19kIH-j11h7KIBVRaKTLh8u4TzI3uZ6E,2127
+comfy_env/detection/runtime.py,sha256=gDplni7ZPGW7WjNJuqWbtgSwkWz27kBWSFvYbhXun6o,3756
+comfy_env/environment/__init__.py,sha256=WfZnyOvbI0MrDQPYTtOG2kHn0XCSCrqKcOlJcmB29nU,1009
+comfy_env/environment/cache.py,sha256=RGfVW2caMO0Dd1nX2otUQP0xW3pVS7iSOP4vIUAMdEA,4568
+comfy_env/environment/libomp.py,sha256=nzr3kDnRLgcf9CZ_WF4ItWskqEDS2S0geqZS43XoKig,1319
+comfy_env/environment/paths.py,sha256=5TFFAkOZXa8R3cHfVHDEFnwy6_JcHilVBOHJuy-yqR0,1129
+comfy_env/environment/setup.py,sha256=KQgeqlEaqB_tOVhsR2RQF76-LuPud2EPtkQWUM3AJ5Y,3231
+comfy_env/isolation/__init__.py,sha256=XfMLEiBIcEzHG_k2vk9fT9GvFfmOsfbpM26czuxbdRI,800
+comfy_env/isolation/tensor_utils.py,sha256=2_f4jjylqCPaPldD1Jw-es5CyOtuF5I1ROdyEIxsg-U,2951
+comfy_env/isolation/wrap.py,sha256=K7GAkqU_Uxe717eUtPsFv5kcr_Jfbh3x79A-8vbY1nY,8592
+comfy_env/isolation/workers/__init__.py,sha256=Zp6sZSRBcb5Negqgzqs3jPjfO9T1u3nNrQhp6WqTAuc,325
+comfy_env/isolation/workers/base.py,sha256=4ZYTaQ4J0kBHCoO_OfZnsowm4rJCoqinZUaOtgkOPbw,2307
+comfy_env/isolation/workers/mp.py,sha256=ygOgx2iyLN7l5fWkKI4lqzQsDyfAAd9Gb4gTYLp7o1A,34061
+comfy_env/isolation/workers/subprocess.py,sha256=ML6I9IenReagP8iT0Cd2ipet6JPK1gnDbOianOuFwOw,57164
+comfy_env/packages/__init__.py,sha256=6PTwUfUdJDTbIw46dCiA42qk4zUe_gw29xOaklBiMMc,1193
+comfy_env/packages/apt.py,sha256=pxy3A5ZHv3X8ExCVyohODY8Fcy9ji4izIVPfYoxhqT4,1027
+comfy_env/packages/cuda_wheels.py,sha256=G_CnlwNcfeWlEU24aCVBpeqQQ05y8_02dDLBwBFNwII,3980
+comfy_env/packages/node_dependencies.py,sha256=AX_CY6j43tTY5KhyPfU7Wz6zgLAfWF0o0JkTrcNSecg,2966
+comfy_env/packages/pixi.py,sha256=RPu8x5sSOLE1CYAhWMMjoQrbFGGt00fdsbqtRcTz7LQ,3871
+comfy_env/packages/toml_generator.py,sha256=Vhc8F9euHhMTwH1TV6t96-D9Pjrn9jIN4e9WXrCIFE8,3414
+comfy_env/templates/comfy-env-instructions.txt,sha256=ve1RAthW7ouumU9h6DM7mIRX1MS8_Tyonq2U4tcrFu8,1031
+comfy_env/templates/comfy-env.toml,sha256=ROIqi4BlPL1MEdL1VgebfTHpdwPNYGHwWeigI9Kw-1I,4831
+comfy_env-0.1.17.dist-info/METADATA,sha256=XlM9mAERf1U2q9sBbrmY7jIgqrl8IsLrs8vK9CmLnpw,4808
+comfy_env-0.1.17.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.1.17.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.1.17.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.1.17.dist-info/RECORD,,

comfy_env/cache.py

@@ -1,203 +0,0 @@
-"""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/nodes.py

@@ -1,187 +0,0 @@
-"""
-Node dependency installation for comfy-env.
-
-This module handles installation of dependent ComfyUI custom nodes
-specified in the [node_reqs] section of comfy-env.toml.
-
-Example configuration:
-    [node_reqs]
-    ComfyUI_essentials = "cubiq/ComfyUI_essentials"
-    ComfyUI-DepthAnythingV2 = "kijai/ComfyUI-DepthAnythingV2"
-"""
-
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from typing import TYPE_CHECKING, Callable, List, Set
-
-if TYPE_CHECKING:
-    from .config.parser import NodeReq
-
-
-def normalize_repo_url(repo: str) -> str:
-    """
-    Convert GitHub shorthand to full URL.
-
-    Args:
-        repo: Either 'owner/repo' or full URL like 'https://github.com/owner/repo'
-
-    Returns:
-        Full GitHub URL
-    """
-    if repo.startswith("http://") or repo.startswith("https://"):
-        return repo
-    return f"https://github.com/{repo}"
-
-
-def clone_node(
-    repo: str,
-    name: str,
-    target_dir: Path,
-    log: Callable[[str], None],
-) -> Path:
-    """
-    Clone a node repository to target_dir/name.
-
-    Args:
-        repo: GitHub repo path (e.g., 'owner/repo') or full URL
-        name: Directory name for the cloned repo
-        target_dir: Parent directory (usually custom_nodes/)
-        log: Logging callback
-
-    Returns:
-        Path to the cloned node directory
-
-    Raises:
-        RuntimeError: If git clone fails
-    """
-    node_path = target_dir / name
-    url = normalize_repo_url(repo)
-
-    log(f"  Cloning {name} from {url}...")
-    result = subprocess.run(
-        ["git", "clone", "--depth", "1", url, str(node_path)],
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode != 0:
-        raise RuntimeError(f"Failed to clone {url}: {result.stderr.strip()}")
-
-    return node_path
-
-
-def install_requirements(
-    node_dir: Path,
-    log: Callable[[str], None],
-) -> None:
-    """
-    Install requirements.txt in a node directory if it exists.
-
-    Args:
-        node_dir: Path to the node directory
-        log: Logging callback
-    """
-    requirements_file = node_dir / "requirements.txt"
-
-    if not requirements_file.exists():
-        return
-
-    log(f"  Installing requirements for {node_dir.name}...")
-
-    # Try uv first, fall back to pip if uv not in PATH
-    if shutil.which("uv"):
-        cmd = ["uv", "pip", "install", "-r", str(requirements_file), "--python", sys.executable]
-    else:
-        cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
-
-    result = subprocess.run(cmd, cwd=node_dir, capture_output=True, text=True)
-    if result.returncode != 0:
-        log(f"  Warning: requirements.txt install failed for {node_dir.name}: {result.stderr.strip()[:200]}")
-
-
-def run_install_script(
-    node_dir: Path,
-    log: Callable[[str], None],
-) -> None:
-    """
-    Run install.py in a node directory if it exists.
-
-    Args:
-        node_dir: Path to the node directory
-        log: Logging callback
-    """
-    install_script = node_dir / "install.py"
-
-    if install_script.exists():
-        log(f"  Running install.py for {node_dir.name}...")
-        result = subprocess.run(
-            [sys.executable, str(install_script)],
-            cwd=node_dir,
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            log(f"  Warning: install.py failed for {node_dir.name}: {result.stderr.strip()[:200]}")
-
-
-def install_node_deps(
-    node_reqs: "List[NodeReq]",
-    custom_nodes_dir: Path,
-    log: Callable[[str], None],
-    visited: Set[str],
-) -> None:
-    """
-    Install node dependencies recursively.
-
-    Args:
-        node_reqs: List of NodeReq objects to install
-        custom_nodes_dir: Path to custom_nodes directory
-        log: Logging callback
-        visited: Set of already-processed node names (for cycle detection)
-    """
-    from .config.parser import discover_config
-
-    for req in node_reqs:
-        # Skip if already visited (cycle detection)
-        if req.name in visited:
-            log(f"  {req.name}: already in dependency chain, skipping")
-            continue
-
-        visited.add(req.name)
-
-        node_path = custom_nodes_dir / req.name
-
-        # Skip if already installed (directory exists)
-        if node_path.exists():
-            log(f"  {req.name}: already installed, skipping")
-            continue
-
-        try:
-            # Clone the repository
-            clone_node(req.repo, req.name, custom_nodes_dir, log)
-
-            # Install requirements.txt if present
-            install_requirements(node_path, log)
-
-            # Run install.py if present
-            run_install_script(node_path, log)
-
-            # Recursively process nested node_reqs
-            try:
-                nested_config = discover_config(node_path)
-                if nested_config and nested_config.node_reqs:
-                    log(f"  {req.name}: found {len(nested_config.node_reqs)} nested dependencies")
-                    install_node_deps(
-                        nested_config.node_reqs,
-                        custom_nodes_dir,
-                        log,
-                        visited,
-                    )
-            except Exception as e:
-                # Don't fail if we can't parse nested config
-                log(f"  {req.name}: could not check for nested deps: {e}")
-
-        except Exception as e:
-            log(f"  Warning: Failed to install {req.name}: {e}")

comfy_env/pixi/__init__.py

@@ -1,48 +0,0 @@
-"""
-Pixi integration for comfy-env.
-
-All dependencies go through pixi for unified management.
-"""
-
-from .core import (
-    ensure_pixi,
-    get_pixi_path,
-    get_pixi_python,
-    pixi_run,
-    pixi_install,
-    clean_pixi_artifacts,
-    CUDA_WHEELS_INDEX,
-)
-from .cuda_detection import (
-    detect_cuda_version,
-    detect_cuda_environment,
-    detect_gpu_info,
-    detect_gpus,
-    get_gpu_summary,
-    get_recommended_cuda_version,
-    GPUInfo,
-    CUDAEnvironment,
-)
-from .resolver import RuntimeEnv
-
-__all__ = [
-    # Core pixi functions
-    "ensure_pixi",
-    "get_pixi_path",
-    "get_pixi_python",
-    "pixi_run",
-    "pixi_install",
-    "clean_pixi_artifacts",
-    "CUDA_WHEELS_INDEX",
-    # CUDA detection
-    "detect_cuda_version",
-    "detect_cuda_environment",
-    "detect_gpu_info",
-    "detect_gpus",
-    "get_gpu_summary",
-    "get_recommended_cuda_version",
-    "GPUInfo",
-    "CUDAEnvironment",
-    # Resolver
-    "RuntimeEnv",
-]