comfy-env 0.1.14__tar.gz → 0.1.15__tar.gz

{comfy_env-0.1.14 → comfy_env-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.1.14
+Version: 0.1.15
 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
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: pip>=21.0
 Requires-Dist: tomli-w>=1.0.0
-Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: tomli>=2.0.0
 Requires-Dist: uv>=0.4.0
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

{comfy_env-0.1.14 → comfy_env-0.1.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "comfy-env"
-version = "0.1.14"
+version = "0.1.15"
 description = "Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation"
 readme = "README.md"
 license = {text = "MIT"}
@@ -19,10 +19,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "tomli>=2.0.0; python_version < '3.11'",  # TOML parsing (built-in tomllib for 3.11+)
-    "tomli-w>=1.0.0",  # TOML writing (no stdlib equivalent)
-    "uv>=0.4.0",  # Fast Python package installer and venv creator
-    "pip>=21.0",  # Fallback package installer
+    "tomli>=2.0.0",
+    "tomli-w>=1.0.0",
+    "uv>=0.4.0",
+    "pip>=21.0",
 ]
 
 [project.optional-dependencies]

{comfy_env-0.1.14 → comfy_env-0.1.15}/src/comfy_env/__init__.py

@@ -1,12 +1,4 @@
-"""
-comfy-env: Environment management for ComfyUI custom nodes.
-
-All dependencies go through pixi for unified management.
-
-Main APIs:
-- install(): Install dependencies from comfy-env.toml
-- wrap_isolated_nodes(): Wrap nodes for subprocess isolation
-"""
+"""Environment management for ComfyUI custom nodes."""
 
 from importlib.metadata import version, PackageNotFoundError
 
@@ -48,13 +40,13 @@ from .workers import (
 )
 
 # Isolation
-from .isolation import wrap_isolated_nodes
+from .isolation import wrap_isolated_nodes, wrap_nodes
 
 # Install API
-from .install import install, verify_installation
+from .install import install, verify_installation, USE_COMFY_ENV_VAR
 
 # Prestartup helpers
-from .prestartup import setup_env
+from .prestartup import setup_env, copy_files
 
 # Cache management
 from .cache import (
@@ -65,24 +57,17 @@ from .cache import (
     MARKER_FILE,
 )
 
-# Errors
-from .errors import (
-    EnvManagerError,
-    ConfigError,
-    WheelNotFoundError,
-    DependencyError,
-    CUDANotFoundError,
-    InstallError,
-)
-
 __all__ = [
     # Install API
     "install",
     "verify_installation",
+    "USE_COMFY_ENV_VAR",
     # Prestartup
     "setup_env",
+    "copy_files",
     # Isolation
     "wrap_isolated_nodes",
+    "wrap_nodes",
     # Config
     "ComfyEnvConfig",
     "NodeReq",
@@ -107,13 +92,6 @@ __all__ = [
     "WorkerError",
     "MPWorker",
     "SubprocessWorker",
-    # Errors
-    "EnvManagerError",
-    "ConfigError",
-    "WheelNotFoundError",
-    "DependencyError",
-    "CUDANotFoundError",
-    "InstallError",
     # Cache
     "get_cache_dir",
     "cleanup_orphaned_envs",
@@ -124,7 +102,7 @@ __all__ = [
 
 # Run orphan cleanup once on module load (silently)
 def _run_startup_cleanup():
-    """Clean orphaned envs on startup. Runs silently, never fails startup."""
+    """Clean orphaned envs on startup."""
     try:
         cleanup_orphaned_envs(log=lambda x: None)  # Silent
     except Exception:

{comfy_env-0.1.14 → comfy_env-0.1.15}/src/comfy_env/cache.py

@@ -1,11 +1,4 @@
-"""
-Central environment cache management for comfy-env.
-
-Stores environments in ~/.comfy-env/envs/<nodename>_<subfolder>_<hash>/
-to avoid Windows MAX_PATH (260 char) issues.
-
-Marker files in node folders link to central envs and enable orphan cleanup.
-"""
+"""Central environment cache management."""
 
 import hashlib
 import os
@@ -21,24 +14,8 @@ try:
 except ImportError:
     __version__ = "0.0.0-dev"
 
-# Lazy import tomli/tomllib
-def _get_tomli():
-    if sys.version_info >= (3, 11):
-        import tomllib
-        return tomllib
-    else:
-        try:
-            import tomli
-            return tomli
-        except ImportError:
-            return None
-
-def _get_tomli_w():
-    try:
-        import tomli_w
-        return tomli_w
-    except ImportError:
-        return None
+import tomli
+import tomli_w
 
 
 # Constants
@@ -70,17 +47,7 @@ def sanitize_name(name: str) -> str:
 
 
 def get_env_name(node_dir: Path, config_path: Path) -> str:
-    """
-    Generate env name: <nodename>_<subfolder>_<hash>
-
-    Args:
-        node_dir: The custom node directory (e.g., custom_nodes/ComfyUI-UniRig)
-        config_path: Path to comfy-env.toml
-
-    Examples:
-        - ComfyUI-UniRig/nodes/comfy-env.toml -> unirig_nodes_a1b2c3d4
-        - ComfyUI-Pack/comfy-env.toml -> pack__f5e6d7c8 (double underscore = no subfolder)
-    """
+    """Generate env name: <nodename>_<subfolder>_<hash>."""
     # Get node name
     node_name = sanitize_name(node_dir.name)
 
@@ -109,27 +76,7 @@ def get_central_env_path(node_dir: Path, config_path: Path) -> Path:
 
 
 def write_marker(config_path: Path, env_path: Path) -> None:
-    """
-    Write marker file linking node to central env.
-
-    Args:
-        config_path: Path to comfy-env.toml
-        env_path: Path to central environment
-    """
-    tomli_w = _get_tomli_w()
-    if not tomli_w:
-        # Fallback to manual TOML writing
-        marker_path = config_path.parent / MARKER_FILE
-        content = f'''[env]
-name = "{env_path.name}"
-path = "{env_path}"
-config_hash = "{compute_config_hash(config_path)}"
-created = "{datetime.now().isoformat()}"
-comfy_env_version = "{__version__}"
-'''
-        marker_path.write_text(content)
-        return
-
+    """Write marker file linking node to central env."""
     marker_path = config_path.parent / MARKER_FILE
     marker_data = {
         "env": {
@@ -144,24 +91,8 @@ comfy_env_version = "{__version__}"
 
 
 def write_env_metadata(env_path: Path, marker_path: Path) -> None:
-    """
-    Write metadata file in env for orphan detection.
-
-    Args:
-        env_path: Path to central environment
-        marker_path: Path to marker file in node folder
-    """
-    tomli_w = _get_tomli_w()
+    """Write metadata file for orphan detection."""
     metadata_path = env_path / METADATA_FILE
-
-    if not tomli_w:
-        # Fallback to manual TOML writing
-        content = f'''marker_path = "{marker_path}"
-created = "{datetime.now().isoformat()}"
-'''
-        metadata_path.write_text(content)
-        return
-
     metadata = {
         "marker_path": str(marker_path),
         "created": datetime.now().isoformat(),
@@ -170,22 +101,9 @@ created = "{datetime.now().isoformat()}"
 
 
 def read_marker(marker_path: Path) -> Optional[dict]:
-    """
-    Read marker file, return None if invalid/missing.
-
-    Args:
-        marker_path: Path to .comfy-env-marker.toml
-
-    Returns:
-        Parsed marker data or None
-    """
+    """Read marker file, return None if invalid/missing."""
     if not marker_path.exists():
         return None
-
-    tomli = _get_tomli()
-    if not tomli:
-        return None
-
     try:
         with open(marker_path, "rb") as f:
             return tomli.load(f)
@@ -194,23 +112,10 @@ def read_marker(marker_path: Path) -> Optional[dict]:
 
 
 def read_env_metadata(env_path: Path) -> Optional[dict]:
-    """
-    Read metadata file from env, return None if invalid/missing.
-
-    Args:
-        env_path: Path to central environment
-
-    Returns:
-        Parsed metadata or None
-    """
+    """Read metadata file from env, return None if invalid/missing."""
     metadata_path = env_path / METADATA_FILE
     if not metadata_path.exists():
         return None
-
-    tomli = _get_tomli()
-    if not tomli:
-        return None
-
     try:
         with open(metadata_path, "rb") as f:
             return tomli.load(f)
@@ -219,21 +124,7 @@ def read_env_metadata(env_path: Path) -> Optional[dict]:
 
 
 def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Optional[Path]]:
-    """
-    Resolve environment path with fallback chain.
-
-    Args:
-        node_dir: Directory containing comfy-env.toml or marker file
-
-    Returns:
-        (env_path, site_packages, lib_dir) or (None, None, None)
-
-    Fallback order:
-        1. Marker file -> central cache
-        2. _env_<name> (current location)
-        3. .pixi/envs/default (old pixi)
-        4. .venv (venv support)
-    """
+    """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)
@@ -263,15 +154,7 @@ def resolve_env_path(node_dir: Path) -> Tuple[Optional[Path], Optional[Path], Op
 
 
 def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]]:
-    """
-    Get site-packages and lib paths from an environment.
-
-    Args:
-        env_path: Path to environment root
-
-    Returns:
-        (env_path, site_packages, lib_dir)
-    """
+    """Get site-packages and lib paths from an environment."""
     import glob
 
     if sys.platform == "win32":
@@ -287,18 +170,7 @@ def _get_env_paths(env_path: Path) -> Tuple[Path, Optional[Path], Optional[Path]
 
 
 def cleanup_orphaned_envs(log: Callable[[str], None] = print) -> int:
-    """
-    Scan central cache and remove orphaned environments.
-
-    An env is orphaned if its marker file no longer exists
-    (meaning the node was deleted).
-
-    Args:
-        log: Logging function
-
-    Returns:
-        Number of envs cleaned up
-    """
+    """Remove orphaned environments. Returns count cleaned."""
     cache_dir = get_cache_dir()
     if not cache_dir.exists():
         return 0

{comfy_env-0.1.14 → comfy_env-0.1.15}/src/comfy_env/cli.py

@@ -309,7 +309,7 @@ def cmd_info(args) -> int:
 def cmd_doctor(args) -> int:
     """Handle doctor command."""
     from .install import verify_installation
-    from .config.parser import discover_env_config, load_env_from_file
+    from .config.parser import load_config, discover_config
 
     print("Running diagnostics...")
     print("=" * 40)
@@ -325,21 +325,19 @@ def cmd_doctor(args) -> int:
     if args.package:
         packages = [args.package]
     elif args.config:
-        config = load_env_from_file(Path(args.config))
+        config = load_config(Path(args.config))
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            # Get packages from pypi-dependencies
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
     else:
-        config = discover_env_config(Path.cwd())
+        config = discover_config(Path.cwd())
         if config:
-            packages = (config.requirements or []) + (config.no_deps_requirements or [])
+            pypi_deps = config.pixi_passthrough.get("pypi-dependencies", {})
+            packages = list(pypi_deps.keys()) + config.cuda_packages
 
     if packages:
-        pkg_names = []
-        for pkg in packages:
-            name = pkg.split("==")[0].split(">=")[0].split("[")[0]
-            pkg_names.append(name)
-
-        all_ok = verify_installation(pkg_names)
+        all_ok = verify_installation(packages)
         if all_ok:
             print("\nAll packages verified!")
             return 0

comfy_env-0.1.15/src/comfy_env/config/__init__.py

@@ -0,0 +1,17 @@
+"""Config parsing for comfy-env."""
+
+from .parser import (
+    ComfyEnvConfig,
+    NodeReq,
+    load_config,
+    discover_config,
+    CONFIG_FILE_NAME,
+)
+
+__all__ = [
+    "ComfyEnvConfig",
+    "NodeReq",
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAME",
+]

{comfy_env-0.1.14 → comfy_env-0.1.15}/src/comfy_env/config/parser.py

@@ -1,100 +1,53 @@
-"""Load configuration from comfy-env.toml.
-
-comfy-env.toml is a superset of pixi.toml. Custom sections we handle:
-- python = "3.11" - Python version for isolated envs
-- [cuda] packages = [...] - CUDA packages (triggers find-links + PyTorch detection)
-- [node_reqs] - Other ComfyUI nodes to clone
-
-Everything else passes through to pixi.toml directly.
-
-Example config:
-
-    python = "3.11"
-
-    [cuda]
-    packages = ["cumesh"]
-
-    [dependencies]
-    mesalib = "*"
-    cgal = "*"
-
-    [pypi-dependencies]
-    numpy = ">=1.21.0,<2"
-    trimesh = { version = ">=4.0.0", extras = ["easy"] }
-
-    [target.linux-64.pypi-dependencies]
-    embreex = "*"
+"""
+Configuration parsing for comfy-env.
 
-    [node_reqs]
-    SomeNode = "owner/repo"
+Loads comfy-env.toml (a superset of pixi.toml) and provides typed config objects.
 """
 
 import copy
 import sys
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional, Dict, Any, List
+import tomli
 
-# Use built-in tomllib (Python 3.11+) or tomli fallback
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    try:
-        import tomli as tomllib
-    except ImportError:
-        tomllib = None  # type: ignore
-
-from .types import ComfyEnvConfig, NodeReq
-
-
+# --- Types&Constants ---
 CONFIG_FILE_NAME = "comfy-env.toml"
 
-# Sections we handle specially (not passed through to pixi.toml)
-CUSTOM_SECTIONS = {"python", "cuda", "node_reqs", "apt", "env_vars"}
-
+@dataclass
+class NodeReq:
+    """A node dependency (another ComfyUI custom node)."""
+    name: str
+    repo: str  # GitHub repo, e.g., "owner/repo"
 
-def load_config(path: Path) -> ComfyEnvConfig:
-    """
-    Load configuration from a TOML file.
+@dataclass
+class ComfyEnvConfig:
+    """Configuration from comfy-env.toml."""
+    python: Optional[str] = None
+    cuda_packages: List[str] = field(default_factory=list)
+    apt_packages: List[str] = field(default_factory=list)
+    env_vars: Dict[str, str] = field(default_factory=dict)
+    node_reqs: List[NodeReq] = field(default_factory=list)
+    pixi_passthrough: Dict[str, Any] = field(default_factory=dict)
 
-    Args:
-        path: Path to comfy-env.toml
+    @property
+    def has_cuda(self) -> bool:
+        return bool(self.cuda_packages)
+# --- Types&Constants ---
 
-    Returns:
-        ComfyEnvConfig instance
-
-    Raises:
-        FileNotFoundError: If config file doesn't exist
-        ImportError: If tomli not installed (Python < 3.11)
-    """
-    if tomllib is None:
-        raise ImportError(
-            "TOML parsing requires tomli for Python < 3.11. "
-            "Install with: pip install tomli"
-        )
 
+def load_config(path: Path) -> ComfyEnvConfig:
+    """Load config from a TOML file."""
     path = Path(path)
     if not path.exists():
         raise FileNotFoundError(f"Config file not found: {path}")
-
     with open(path, "rb") as f:
-        data = tomllib.load(f)
-
+        data = tomli.load(f)
     return _parse_config(data)
 
 
 def discover_config(node_dir: Path) -> Optional[ComfyEnvConfig]:
-    """
-    Find and load comfy-env.toml from a directory.
-
-    Args:
-        node_dir: Directory to search
-
-    Returns:
-        ComfyEnvConfig if found, None otherwise
-    """
-    if tomllib is None:
-        return None
-
+    """Find and load comfy-env.toml from a directory."""
     config_path = Path(node_dir) / CONFIG_FILE_NAME
     if config_path.exists():
         return load_config(config_path)