comfy-env 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

comfy_env/decorator.py

@@ -113,6 +113,31 @@ def _clone_tensor_if_needed(obj: Any, smart_clone: bool = True) -> Any:
     return obj
 
 
+def _find_node_package_dir(source_file: Path) -> Path:
+    """
+    Find the node package root directory by searching for comfy-env.toml.
+
+    Walks up from the source file's directory until it finds a config file,
+    or falls back to heuristics if not found.
+    """
+    from .env.config_file import CONFIG_FILE_NAMES
+
+    current = source_file.parent
+
+    # Walk up the directory tree looking for config file
+    while current != current.parent:  # Stop at filesystem root
+        for config_name in CONFIG_FILE_NAMES:
+            if (current / config_name).exists():
+                return current
+        current = current.parent
+
+    # Fallback: use old heuristic if no config found
+    node_dir = source_file.parent
+    if node_dir.name == "nodes":
+        return node_dir.parent
+    return node_dir
+
+
 # ---------------------------------------------------------------------------
 # Worker Management
 # ---------------------------------------------------------------------------
@@ -262,10 +287,7 @@ def isolated(
         # Get source file info for sys.path setup
         source_file = Path(inspect.getfile(cls))
         node_dir = source_file.parent
-        if node_dir.name == "nodes":
-            node_package_dir = node_dir.parent
-        else:
-            node_package_dir = node_dir
+        node_package_dir = _find_node_package_dir(source_file)
 
         # Build sys.path for worker
         sys_path_additions = [str(node_dir)]
@@ -367,13 +389,10 @@ def isolated(
                     call_kwargs = {k: _clone_tensor_if_needed(v) for k, v in call_kwargs.items()}
 
                 # Get module name for import in worker
+                # Note: ComfyUI uses full filesystem paths as module names for custom nodes.
+                # The worker's _execute_method_call handles this by using file-based imports.
                 module_name = cls.__module__
 
-                # Handle ComfyUI's dynamic import which can set __module__ to a path
-                if module_name.startswith('/') or module_name.startswith('\\'):
-                    # Module name is a filesystem path - use the source file stem instead
-                    module_name = source_file.stem
-
                 # Call worker using appropriate method
                 if worker_config.python is None:
                     # TorchMPWorker - use call_method protocol (avoids pickle issues)

comfy_env/workers/torch_mp.py

@@ -106,6 +106,190 @@ def _worker_loop(queue_in, queue_out, sys_path_additions=None):
             break
 
 
+class PathBasedModuleFinder:
+    """
+    Meta path finder that handles ComfyUI's path-based module names.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This finder intercepts imports of such modules and loads them from disk.
+    """
+
+    def find_spec(self, fullname, path, target=None):
+        import importlib.util
+        import os
+
+        # Only handle path-based module names (starting with /)
+        if not fullname.startswith('/'):
+            return None
+
+        # Parse the module name to find base path and submodule parts
+        parts = fullname.split('.')
+        base_path = parts[0]
+        submodule_parts = parts[1:] if len(parts) > 1 else []
+
+        # Walk through parts to find where path ends and module begins
+        for i, part in enumerate(submodule_parts):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # Remaining parts are module names
+                submodule_parts = submodule_parts[i:]
+                break
+        else:
+            # All parts were path components
+            submodule_parts = []
+
+        # Determine the file to load
+        if submodule_parts:
+            # We're importing a submodule
+            current_path = base_path
+            for part in submodule_parts[:-1]:
+                current_path = os.path.join(current_path, part)
+
+            submod = submodule_parts[-1]
+            submod_file = os.path.join(current_path, submod + '.py')
+            submod_pkg = os.path.join(current_path, submod, '__init__.py')
+
+            if os.path.exists(submod_file):
+                return importlib.util.spec_from_file_location(fullname, submod_file)
+            elif os.path.exists(submod_pkg):
+                return importlib.util.spec_from_file_location(
+                    fullname, submod_pkg,
+                    submodule_search_locations=[os.path.join(current_path, submod)]
+                )
+        else:
+            # Top-level path-based module
+            if os.path.isdir(base_path):
+                init_path = os.path.join(base_path, "__init__.py")
+                if os.path.exists(init_path):
+                    return importlib.util.spec_from_file_location(
+                        fullname, init_path,
+                        submodule_search_locations=[base_path]
+                    )
+            elif os.path.isfile(base_path):
+                return importlib.util.spec_from_file_location(fullname, base_path)
+
+        return None
+
+
+# Global flag to track if we've installed the finder
+_path_finder_installed = False
+
+
+def _ensure_path_finder_installed():
+    """Install the PathBasedModuleFinder if not already installed."""
+    import sys
+    global _path_finder_installed
+    if not _path_finder_installed:
+        sys.meta_path.insert(0, PathBasedModuleFinder())
+        _path_finder_installed = True
+        logger.debug("[comfy_env] Installed PathBasedModuleFinder for path-based module names")
+
+
+def _load_path_based_module(module_name: str):
+    """
+    Load a module that has a filesystem path as its name.
+
+    ComfyUI uses full filesystem paths as module names for custom nodes.
+    This function handles that case by using file-based imports.
+    """
+    import importlib.util
+    import os
+    import sys
+
+    # Check if it's already in sys.modules
+    if module_name in sys.modules:
+        return sys.modules[module_name]
+
+    # Check if module_name contains submodule parts (e.g., "/path/to/pkg.submod.subsubmod")
+    # In this case, we need to load the parent packages first
+    if '.' in module_name:
+        parts = module_name.split('.')
+        # Find where the path ends and module parts begin
+        # The path part won't exist as a directory when combined with module parts
+        base_path = parts[0]
+        submodule_parts = []
+
+        for i, part in enumerate(parts[1:], 1):
+            test_path = os.path.join(base_path, part)
+            if os.path.exists(test_path):
+                base_path = test_path
+            else:
+                # This and remaining parts are module names, not path components
+                submodule_parts = parts[i:]
+                break
+
+        if submodule_parts:
+            # Load parent package first
+            parent_module = _load_path_based_module(base_path)
+
+            # Now load submodules
+            current_module = parent_module
+            current_name = base_path
+            for submod in submodule_parts:
+                current_name = f"{current_name}.{submod}"
+                if current_name in sys.modules:
+                    current_module = sys.modules[current_name]
+                else:
+                    # Try to import as attribute or load from file
+                    if hasattr(current_module, submod):
+                        current_module = getattr(current_module, submod)
+                    else:
+                        # Try to load the submodule file
+                        if hasattr(current_module, '__path__'):
+                            for parent_path in current_module.__path__:
+                                submod_file = os.path.join(parent_path, submod + '.py')
+                                submod_pkg = os.path.join(parent_path, submod, '__init__.py')
+                                if os.path.exists(submod_file):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_file)
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    current_module.__package__ = f"{base_path}.{'.'.join(submodule_parts[:-1])}" if len(submodule_parts) > 1 else base_path
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                                elif os.path.exists(submod_pkg):
+                                    spec = importlib.util.spec_from_file_location(current_name, submod_pkg,
+                                        submodule_search_locations=[os.path.dirname(submod_pkg)])
+                                    current_module = importlib.util.module_from_spec(spec)
+                                    sys.modules[current_name] = current_module
+                                    spec.loader.exec_module(current_module)
+                                    break
+                        else:
+                            raise ModuleNotFoundError(f"Cannot find submodule {submod} in {current_name}")
+            return current_module
+
+    # Simple path-based module (no submodule parts)
+    if os.path.isdir(module_name):
+        init_path = os.path.join(module_name, "__init__.py")
+        submodule_search_locations = [module_name]
+    else:
+        init_path = module_name
+        submodule_search_locations = None
+
+    if not os.path.exists(init_path):
+        raise ModuleNotFoundError(f"Cannot find module at path: {module_name}")
+
+    spec = importlib.util.spec_from_file_location(
+        module_name,
+        init_path,
+        submodule_search_locations=submodule_search_locations
+    )
+    module = importlib.util.module_from_spec(spec)
+
+    # Set up package attributes for relative imports
+    if os.path.isdir(module_name):
+        module.__path__ = [module_name]
+        module.__package__ = module_name
+    else:
+        module.__package__ = module_name.rsplit('.', 1)[0] if '.' in module_name else ''
+
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    return module
+
+
 def _execute_method_call(module_name: str, class_name: str, method_name: str,
                          self_state: dict, kwargs: dict) -> Any:
     """
@@ -114,9 +298,28 @@ def _execute_method_call(module_name: str, class_name: str, method_name: str,
     This function imports the class fresh and calls the original (un-decorated) method.
     """
     import importlib
+    import os
+    import sys
 
     # Import the module
-    module = importlib.import_module(module_name)
+    logger.debug(f"Attempting to import module_name={module_name}")
+
+    # Check if module_name is a filesystem path (ComfyUI uses paths as module names)
+    # This happens because ComfyUI's load_custom_node uses the full path as sys_module_name
+    if module_name.startswith('/') or (os.sep in module_name and not module_name.startswith('.')):
+        # Check if the base path exists to confirm it's a path-based module
+        base_path = module_name.split('.')[0] if '.' in module_name else module_name
+        if os.path.exists(base_path):
+            logger.debug(f"Detected path-based module name, using file-based import")
+            # Install the meta path finder to handle relative imports within the package
+            _ensure_path_finder_installed()
+            module = _load_path_based_module(module_name)
+        else:
+            # Doesn't look like a valid path, try standard import
+            module = importlib.import_module(module_name)
+    else:
+        # Standard module name - use importlib.import_module
+        module = importlib.import_module(module_name)
     cls = getattr(module, class_name)
 
     # Create instance with proper __slots__ handling

{comfy_env-0.0.19.dist-info → comfy_env-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-env
-Version: 0.0.19
+Version: 0.0.21
 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
@@ -126,7 +126,7 @@ comfy-env resolve nvdiffrast==0.4.0
 comfy-env doctor
 ```
 
-## Configuration
+## Configurations
 
 ### comfy-env.toml
 

{comfy_env-0.0.19.dist-info → comfy_env-0.0.21.dist-info}/RECORD

@@ -1,6 +1,6 @@
 comfy_env/__init__.py,sha256=76gIAh7qFff_v_bAolXVzuWzcgvD3bp-yQGCNzba_Iw,3287
 comfy_env/cli.py,sha256=X-GCQMP0mtMcE3ZgkT-VLQ4Gq3UUvcb_Ux_NClEFhgI,15975
-comfy_env/decorator.py,sha256=FwM6O0eIYK1FlKmniE4sJyzLLIr4mVg3ON-PnuTF2cw,16056
+comfy_env/decorator.py,sha256=6JCKwLHaZtOLVDexs_gh_-NtS2ZK0V7nGCPqkyeYEAA,16688
 comfy_env/errors.py,sha256=8hN8NDlo8oBUdapc-eT3ZluigI5VBzfqsSBvQdfWlz4,9943
 comfy_env/install.py,sha256=txjQh5mdtFt0uQL7682LWgH0-311TflunaKv-n0XlYM,24510
 comfy_env/registry.py,sha256=uFCtGmWYvwGCqObXgzmArX7o5JsFNsHXxayofk3m6no,2569
@@ -29,11 +29,11 @@ comfy_env/workers/__init__.py,sha256=IKZwOvrWOGqBLDUIFAalg4CdqzJ_YnAdxo2Ha7gZTJ0
 comfy_env/workers/base.py,sha256=ZILYXlvGCWuCZXmjKqfG8VeD19ihdYaASdlbasl2BMo,2312
 comfy_env/workers/pool.py,sha256=MtjeOWfvHSCockq8j1gfnxIl-t01GSB79T5N4YB82Lg,6956
 comfy_env/workers/tensor_utils.py,sha256=TCuOAjJymrSbkgfyvcKtQ_KbVWTqSwP9VH_bCaFLLq8,6409
-comfy_env/workers/torch_mp.py,sha256=1cNhcrCWZ9E6AHCIEMC3vDLo_qjyV2wuQh5iZslg0Hg,13222
+comfy_env/workers/torch_mp.py,sha256=4YSNPn7hALrvMVbkO4RkTeFTcc0lhfLMk5QTWjY4PHw,22134
 comfy_env/workers/venv.py,sha256=_ekHfZPqBIPY08DjqiXm6cTBQH4DrbxRWR3AAv3mit8,31589
 comfy_env/wheel_sources.yml,sha256=nSZ8XB_I5JXQGB7AgC6lHs_IXMd9Kcno10artNL8BKw,7775
-comfy_env-0.0.19.dist-info/METADATA,sha256=5L7G8zHaCX2gtDMpdadBG15csEsdHqsTm5HOeowTaSI,5399
-comfy_env-0.0.19.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-comfy_env-0.0.19.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
-comfy_env-0.0.19.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
-comfy_env-0.0.19.dist-info/RECORD,,
+comfy_env-0.0.21.dist-info/METADATA,sha256=UvyKIRRV4zWGCvxgQu-Og_Y7wNC--tzcBCFab4PvAYw,5400
+comfy_env-0.0.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+comfy_env-0.0.21.dist-info/entry_points.txt,sha256=J4fXeqgxU_YenuW_Zxn_pEL7J-3R0--b6MS5t0QmAr0,49
+comfy_env-0.0.21.dist-info/licenses/LICENSE,sha256=E68QZMMpW4P2YKstTZ3QU54HRQO8ecew09XZ4_Vn870,1093
+comfy_env-0.0.21.dist-info/RECORD,,