Initial commit: ComfyUI-WorkflowGenerator

utils/node_utils.py

@@ -0,0 +1,141 @@
+import logging
+
+try:
+    import psutil
+except ImportError:
+    psutil = None
+
+
+def get_n_threads_options() -> list[str]:
+    """
+    Generate options for n_threads Combo input.
+    Returns: List of strings ["All", "Auto"] + integer options up to CPU count
+    """
+    try:
+        if psutil is not None:
+            cpu_count = psutil.cpu_count(logical=True)
+        else:
+            import multiprocessing
+
+            cpu_count = multiprocessing.cpu_count()
+
+        options = ["All", "Auto"]
+        options.extend([str(i) for i in range(1, cpu_count + 1)])
+        return options
+    except (OSError, RuntimeError, AttributeError, Exception) as e:
+        logging.warning(f"Could not detect CPU count, using fallback options: {e}")
+        return ["All", "Auto"] + [str(i) for i in range(1, 33)]
+
+
+def parse_n_threads(value: str) -> int | None:
+    """
+    Parse n_threads Combo value to integer or None.
+
+    Args:
+        value: String from Combo input ("All", "Auto", or integer string)
+
+    Returns:
+        int for "All" or specific count, None for "Auto"
+    """
+    if value == "All":
+        try:
+            if psutil is not None:
+                return psutil.cpu_count(logical=True)
+            else:
+                import multiprocessing
+
+                return multiprocessing.cpu_count()
+        except Exception:
+            return 32
+    elif value == "Auto":
+        return None
+    else:
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return None
+
+
+def check_llm_lazy_status(
+    use_llm_refinement: bool = False,
+    refine_model_path: str | None = None,
+    max_new_tokens: int | None = None,
+    device_preference: str | None = None,
+    n_gpu_layers: int | None = None,
+    dtype: str | None = None,
+    attn_implementation: str | None = None,
+    context_size: int | None = None,
+    temperature: float | None = None,
+    top_p: float | None = None,
+    seed: int | None = None,
+    # Additional parameters that might be present
+    refine_max_new_tokens: int | None = None,
+    refine_device_preference: str | None = None,
+    refine_n_gpu_layers: int | None = None,
+    refine_dtype: str | None = None,
+    refine_attn_implementation: str | None = None,
+    refine_context_size: int | None = None,
+    refine_temperature: float | None = None,
+    refine_top_p: float | None = None,
+    refine_auto_gpu_layers: bool | None = None,
+    auto_gpu_layers: bool | None = None,
+    **kwargs,
+) -> list[str]:
+    """
+    Determine which lazy inputs need to be evaluated for LLM refinement.
+    Handles both standard parameter names (NodeValidator) and prefixed names (Pipeline).
+
+    Returns:
+        List of input names that need to be evaluated.
+    """
+    needed = []
+
+    if not use_llm_refinement:
+        return needed
+
+    def check_add(val, name):
+        if val is None:
+            needed.append(name)
+
+    # Detect if we're in pipeline context (any prefixed parameter is not None)
+    is_pipeline_context = any(
+        [
+            refine_max_new_tokens is not None,
+            refine_device_preference is not None,
+            refine_n_gpu_layers is not None,
+            refine_dtype is not None,
+            refine_attn_implementation is not None,
+            refine_context_size is not None,
+            refine_temperature is not None,
+            refine_top_p is not None,
+            refine_auto_gpu_layers is not None,
+        ]
+    )
+
+    if is_pipeline_context:
+        # Pipeline node context - check prefixed names
+        check_add(refine_model_path, "refine_model_path")
+        check_add(refine_max_new_tokens, "refine_max_new_tokens")
+        check_add(refine_device_preference, "refine_device_preference")
+        check_add(refine_n_gpu_layers, "refine_n_gpu_layers")
+        check_add(refine_dtype, "refine_dtype")
+        check_add(refine_attn_implementation, "refine_attn_implementation")
+        check_add(refine_context_size, "refine_context_size")
+        check_add(refine_temperature, "refine_temperature")
+        check_add(refine_top_p, "refine_top_p")
+        check_add(refine_auto_gpu_layers, "refine_auto_gpu_layers")
+    else:
+        # NodeValidator node context - check standard names
+        check_add(refine_model_path, "refine_model_path")
+        check_add(max_new_tokens, "max_new_tokens")
+        check_add(device_preference, "device_preference")
+        check_add(n_gpu_layers, "n_gpu_layers")
+        check_add(dtype, "dtype")
+        check_add(attn_implementation, "attn_implementation")
+        check_add(context_size, "context_size")
+        check_add(temperature, "temperature")
+        check_add(top_p, "top_p")
+        check_add(seed, "seed")
+        check_add(auto_gpu_layers, "auto_gpu_layers")
+
+    return needed