comfy-dynamic-widgets 0.0.6__tar.gz

comfy_dynamic_widgets-0.0.6/.github/workflows/publish.yml

@@ -0,0 +1,67 @@
+name: Bump Version & Publish
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  bump-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Get current version
+        id: get_version
+        run: |
+          current=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/' | tr -d '\r')
+          echo "current=$current" >> $GITHUB_OUTPUT
+
+      - name: Bump patch version
+        id: bump_version
+        run: |
+          current="${{ steps.get_version.outputs.current }}"
+          IFS='.' read -r major minor patch <<< "$current"
+          new_patch=$((patch + 1))
+          new_version="${major}.${minor}.${new_patch}"
+          sed -i "s/^version = \".*\"/version = \"${new_version}\"/" pyproject.toml
+          echo "new_version=$new_version" >> $GITHUB_OUTPUT
+          echo "Bumped version: $current -> $new_version"
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml
+          git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
+          git tag "v${{ steps.bump_version.outputs.new_version }}"
+          git push origin main --tags
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.bump_version.outputs.new_version }}
+          name: v${{ steps.bump_version.outputs.new_version }}
+          generate_release_notes: true
+          files: dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

comfy_dynamic_widgets-0.0.6/.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Generated files
+web/js/mappings.json

comfy_dynamic_widgets-0.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrea Pozzetti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

comfy_dynamic_widgets-0.0.6/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: comfy-dynamic-widgets
+Version: 0.0.6
+Summary: Dynamic widget visibility for ComfyUI nodes via simple metadata
+Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-dynamic-widgets
+Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-dynamic-widgets
+Project-URL: Issues, https://github.com/PozzettiAndrea/comfy-dynamic-widgets/issues
+Author: Andrea Pozzetti
+License: MIT
+License-File: LICENSE
+Keywords: comfyui,conditional,dynamic,visibility,widgets
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# comfy-dynamic-widgets
+
+A Python library that enables conditional widget visibility in ComfyUI nodes via simple metadata.
+
+## Installation
+
+```bash
+pip install comfy-dynamic-widgets
+```
+
+## Usage
+
+### For Node Authors
+
+Add `visible_when` metadata to widget definitions:
+
+```python
+@classmethod
+def INPUT_TYPES(cls):
+    return {
+        "required": {
+            "backend": (["option_a", "option_b", "option_c"], {"default": "option_a"}),
+        },
+        "optional": {
+            "param_for_a": ("FLOAT", {
+                "default": 0.1,
+                "visible_when": {"backend": ["option_a"]},
+            }),
+            "param_for_b_and_c": ("INT", {
+                "default": 10,
+                "visible_when": {"backend": ["option_b", "option_c"]},
+            }),
+        }
+    }
+```
+
+### For Custom Node Package Authors
+
+In your `prestartup_script.py`:
+
+```python
+import json
+import os
+
+def generate_widget_mappings():
+    try:
+        from comfy_dynamic_widgets import scan_all_nodes, generate_mappings
+
+        configs = scan_all_nodes()
+        if not configs:
+            return
+
+        mappings = generate_mappings(configs)
+
+        output_path = os.path.join(
+            os.path.dirname(__file__), "web", "js", "mappings.json"
+        )
+        with open(output_path, "w") as f:
+            json.dump(mappings, f, indent=2)
+
+    except ImportError:
+        print("comfy-dynamic-widgets not installed")
+
+generate_widget_mappings()
+```
+
+Copy the `dynamic_widgets.js` from this package to your `web/js/` folder and update the mappings path.
+
+## API
+
+### `scan_all_nodes() -> dict`
+
+Scans all registered ComfyUI nodes and extracts `visible_when` metadata.
+
+### `generate_mappings(configs: dict) -> dict`
+
+Transforms node visibility configs into a JS-friendly JSON format.
+
+## License
+
+MIT

comfy_dynamic_widgets-0.0.6/README.md

@@ -0,0 +1,81 @@
+# comfy-dynamic-widgets
+
+A Python library that enables conditional widget visibility in ComfyUI nodes via simple metadata.
+
+## Installation
+
+```bash
+pip install comfy-dynamic-widgets
+```
+
+## Usage
+
+### For Node Authors
+
+Add `visible_when` metadata to widget definitions:
+
+```python
+@classmethod
+def INPUT_TYPES(cls):
+    return {
+        "required": {
+            "backend": (["option_a", "option_b", "option_c"], {"default": "option_a"}),
+        },
+        "optional": {
+            "param_for_a": ("FLOAT", {
+                "default": 0.1,
+                "visible_when": {"backend": ["option_a"]},
+            }),
+            "param_for_b_and_c": ("INT", {
+                "default": 10,
+                "visible_when": {"backend": ["option_b", "option_c"]},
+            }),
+        }
+    }
+```
+
+### For Custom Node Package Authors
+
+In your `prestartup_script.py`:
+
+```python
+import json
+import os
+
+def generate_widget_mappings():
+    try:
+        from comfy_dynamic_widgets import scan_all_nodes, generate_mappings
+
+        configs = scan_all_nodes()
+        if not configs:
+            return
+
+        mappings = generate_mappings(configs)
+
+        output_path = os.path.join(
+            os.path.dirname(__file__), "web", "js", "mappings.json"
+        )
+        with open(output_path, "w") as f:
+            json.dump(mappings, f, indent=2)
+
+    except ImportError:
+        print("comfy-dynamic-widgets not installed")
+
+generate_widget_mappings()
+```
+
+Copy the `dynamic_widgets.js` from this package to your `web/js/` folder and update the mappings path.
+
+## API
+
+### `scan_all_nodes() -> dict`
+
+Scans all registered ComfyUI nodes and extracts `visible_when` metadata.
+
+### `generate_mappings(configs: dict) -> dict`
+
+Transforms node visibility configs into a JS-friendly JSON format.
+
+## License
+
+MIT

comfy_dynamic_widgets-0.0.6/comfy_dynamic_widgets/__init__.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) 2025 Comfy-DynamicWidgets Contributors
+
+"""
+Comfy Dynamic Widgets
+
+A standalone package that enables conditional widget visibility in ComfyUI nodes
+via simple metadata. Node authors can use "visible_when" in widget definitions
+to show/hide widgets based on selector values.
+
+Usage in node definitions:
+    "voxel_size": ("FLOAT", {
+        "default": 0.1,
+        "visible_when": {"backend": ["blender_voxel"]},
+    })
+"""
+
+import os
+
+__version__ = "0.0.3"
+
+from .scanner import scan_all_nodes
+from .generator import generate_mappings
+
+
+def get_js_path() -> str:
+    """Return path to the dynamic_widgets.js file in this package."""
+    return os.path.join(os.path.dirname(__file__), "web", "js", "dynamic_widgets.js")
+
+
+def get_web_dir() -> str:
+    """Return path to the web/js directory in this package."""
+    return os.path.join(os.path.dirname(__file__), "web", "js")
+
+
+__all__ = ["scan_all_nodes", "generate_mappings", "get_js_path", "get_web_dir", "__version__"]

comfy_dynamic_widgets-0.0.6/comfy_dynamic_widgets/generator.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) 2025 ComfyUI-DynamicWidgets Contributors
+
+"""
+Mapping Generator - Transforms node visibility configs into JS-friendly JSON format.
+"""
+
+
+def generate_mappings(node_configs: dict) -> dict:
+    """
+    Transform node visibility configs into JS-friendly format.
+
+    Args:
+        node_configs: Output from scan_all_nodes()
+        {
+            "NodeClassName": {
+                "selectors": {
+                    "backend": {
+                        "blender_voxel": ["voxel_size"],
+                        ...
+                    }
+                }
+            }
+        }
+
+    Returns:
+        dict: JS-friendly mapping format
+        {
+            "version": 1,
+            "nodes": {
+                "NodeClassName": {
+                    "selectors": {
+                        "backend": {
+                            "blender_voxel": ["voxel_size"],
+                            ...
+                        }
+                    }
+                }
+            }
+        }
+    """
+    return {
+        "version": 1,
+        "nodes": node_configs,
+    }

comfy_dynamic_widgets-0.0.6/comfy_dynamic_widgets/scanner.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: MIT
+# Copyright (C) 2025 ComfyUI-DynamicWidgets Contributors
+
+"""
+Node Scanner - Introspects ComfyUI nodes to extract visible_when metadata.
+"""
+
+from typing import Any
+
+
+def scan_all_nodes() -> dict[str, dict]:
+    """
+    Scan all registered ComfyUI nodes and extract visible_when metadata.
+
+    Returns:
+        dict: Mapping of node_class -> visibility configuration
+        {
+            "NodeClassName": {
+                "selectors": {
+                    "selector_widget_name": {
+                        "selector_value": ["widget1", "widget2"],
+                        ...
+                    }
+                }
+            }
+        }
+    """
+    try:
+        import nodes
+    except ImportError:
+        print("[DynamicWidgets] Warning: Could not import ComfyUI nodes module")
+        return {}
+
+    # Get the node class mappings from ComfyUI
+    node_mappings = getattr(nodes, "NODE_CLASS_MAPPINGS", {})
+
+    results = {}
+
+    for node_name, node_class in node_mappings.items():
+        config = _scan_node_class(node_name, node_class)
+        if config:
+            results[node_name] = config
+
+    return results
+
+
+def _scan_node_class(node_name: str, node_class: type) -> dict | None:
+    """
+    Scan a single node class for visible_when metadata.
+
+    Args:
+        node_name: The registered name of the node
+        node_class: The node class to scan
+
+    Returns:
+        dict or None: Visibility configuration if any visible_when found
+    """
+    # Get INPUT_TYPES - it's typically a classmethod
+    if not hasattr(node_class, "INPUT_TYPES"):
+        return None
+
+    try:
+        input_types = node_class.INPUT_TYPES()
+    except Exception as e:
+        print(f"[DynamicWidgets] Warning: Failed to call INPUT_TYPES for {node_name}: {e}")
+        return None
+
+    if not isinstance(input_types, dict):
+        return None
+
+    # Collect all visible_when entries
+    # Structure: selector_name -> selector_value -> [widget_names]
+    selectors: dict[str, dict[str, list[str]]] = {}
+
+    # Scan both required and optional inputs
+    for section in ["required", "optional"]:
+        section_inputs = input_types.get(section, {})
+        if not isinstance(section_inputs, dict):
+            continue
+
+        for widget_name, widget_def in section_inputs.items():
+            visible_when = _extract_visible_when(widget_def)
+            if visible_when:
+                _add_to_selectors(selectors, widget_name, visible_when)
+
+    if not selectors:
+        return None
+
+    return {"selectors": selectors}
+
+
+def _extract_visible_when(widget_def: Any) -> dict | None:
+    """
+    Extract visible_when metadata from a widget definition.
+
+    Widget definitions are typically tuples like:
+        ("FLOAT", {"default": 0.1, "visible_when": {"backend": ["blender_voxel"]}})
+
+    Args:
+        widget_def: The widget definition tuple/list
+
+    Returns:
+        dict or None: The visible_when dict if present
+    """
+    if not isinstance(widget_def, (tuple, list)):
+        return None
+
+    if len(widget_def) < 2:
+        return None
+
+    # Second element should be the options dict
+    options = widget_def[1]
+    if not isinstance(options, dict):
+        return None
+
+    visible_when = options.get("visible_when")
+    if not isinstance(visible_when, dict):
+        return None
+
+    return visible_when
+
+
+def _add_to_selectors(
+    selectors: dict[str, dict[str, list[str]]],
+    widget_name: str,
+    visible_when: dict
+) -> None:
+    """
+    Add widget visibility rules to the selectors structure.
+
+    Args:
+        selectors: The selectors dict to update
+        widget_name: The name of the widget with visible_when
+        visible_when: The visible_when dict, e.g. {"backend": ["blender_voxel"]}
+    """
+    for selector_name, selector_values in visible_when.items():
+        if not isinstance(selector_values, list):
+            # Allow single value without list wrapper
+            selector_values = [selector_values]
+
+        if selector_name not in selectors:
+            selectors[selector_name] = {}
+
+        for value in selector_values:
+            value_str = str(value)
+            if value_str not in selectors[selector_name]:
+                selectors[selector_name][value_str] = []
+
+            if widget_name not in selectors[selector_name][value_str]:
+                selectors[selector_name][value_str].append(widget_name)

comfy_dynamic_widgets-0.0.6/comfy_dynamic_widgets/web/js/dynamic_widgets.js

@@ -0,0 +1,141 @@
+/**
+ * Dynamic Widget Visibility for ComfyUI
+ *
+ * Shows/hides widgets based on selector widget values.
+ * Mappings are loaded from mappings.json (generated by prestartup_script.py).
+ *
+ * Usage in node definitions:
+ *   "voxel_size": ("FLOAT", {
+ *       "default": 0.1,
+ *       "visible_when": {"backend": ["blender_voxel"]},
+ *   })
+ */
+import { app } from "../../../scripts/app.js";
+
+console.log("[DynamicWidgets] Loading extension...");
+
+// Will be populated from JSON
+let MAPPINGS = null;
+
+/**
+ * Fetch mappings from generated JSON (relative to this script's location)
+ */
+async function loadMappings() {
+    // Get the directory this script is loaded from
+    const scriptUrl = new URL(import.meta.url);
+    const baseDir = scriptUrl.pathname.substring(0, scriptUrl.pathname.lastIndexOf('/'));
+
+    // Load mappings.json from same directory
+    try {
+        const response = await fetch(baseDir + "/mappings.json");
+        if (response.ok) {
+            const data = await response.json();
+            MAPPINGS = data;
+            const nodeCount = Object.keys(data.nodes || {}).length;
+            console.log(`[DynamicWidgets] Loaded mappings for ${nodeCount} nodes`);
+            return true;
+        }
+    } catch (e) {
+        console.warn("[DynamicWidgets] Could not load mappings.json:", e);
+    }
+    return false;
+}
+
+// Load mappings on startup
+loadMappings();
+
+/**
+ * Get the node configuration from mappings
+ */
+function getNodeConfig(nodeClass) {
+    if (!MAPPINGS || !MAPPINGS.nodes) return null;
+    return MAPPINGS.nodes[nodeClass] || null;
+}
+
+/**
+ * Update widget visibility based on selector value
+ */
+function updateWidgetVisibility(node, selectorName, selectedValue) {
+    const nodeConfig = getNodeConfig(node.comfyClass);
+    if (!nodeConfig || !nodeConfig.selectors) return;
+
+    const selectorConfig = nodeConfig.selectors[selectorName];
+    if (!selectorConfig) return;
+
+    // Get widgets that should be visible for this selector value
+    const visibleWidgets = selectorConfig[selectedValue] || [];
+
+    // Get all widgets controlled by this selector
+    const allControlledWidgets = new Set();
+    for (const widgets of Object.values(selectorConfig)) {
+        for (const w of widgets) {
+            allControlledWidgets.add(w);
+        }
+    }
+
+    console.log(`[DynamicWidgets] ${node.comfyClass}: ${selectorName}="${selectedValue}", visible=[${visibleWidgets.join(', ')}]`);
+
+    let visibilityChanged = false;
+
+    for (const widget of node.widgets || []) {
+        // Only control widgets that are in our mapping
+        if (!allControlledWidgets.has(widget.name)) continue;
+
+        const shouldShow = visibleWidgets.includes(widget.name);
+        const wasHidden = widget.hidden;
+        widget.hidden = !shouldShow;
+
+        if (wasHidden !== widget.hidden) {
+            visibilityChanged = true;
+            console.log(`[DynamicWidgets] Widget "${widget.name}": hidden=${widget.hidden}`);
+        }
+    }
+
+    if (visibilityChanged) {
+        node.setSize(node.computeSize());
+        app.graph.setDirtyCanvas(true, true);
+    }
+}
+
+/**
+ * Set up visibility control for a selector widget
+ */
+function setupSelectorWidget(node, selectorName) {
+    const selectorWidget = node.widgets?.find(w => w.name === selectorName);
+    if (!selectorWidget) {
+        console.log(`[DynamicWidgets] Selector widget "${selectorName}" not found on ${node.comfyClass}`);
+        return;
+    }
+
+    // Store original callback
+    const originalCallback = selectorWidget.callback;
+
+    // Override callback to update visibility on change
+    selectorWidget.callback = function(value) {
+        if (originalCallback) originalCallback.call(this, value);
+        updateWidgetVisibility(node, selectorName, value);
+    };
+
+    // Initial visibility update (with delay to ensure widgets are created)
+    setTimeout(() => {
+        updateWidgetVisibility(node, selectorName, selectorWidget.value);
+    }, 50);
+}
+
+app.registerExtension({
+    name: "Comfy.DynamicWidgets",
+
+    nodeCreated(node) {
+        const nodeConfig = getNodeConfig(node.comfyClass);
+        if (!nodeConfig || !nodeConfig.selectors) return;
+
+        console.log(`[DynamicWidgets] Setting up node: ${node.comfyClass}`);
+
+        // Set up each selector
+        for (const selectorName of Object.keys(nodeConfig.selectors)) {
+            setupSelectorWidget(node, selectorName);
+        }
+    }
+});
+
+console.log("[DynamicWidgets] Extension registered");

comfy_dynamic_widgets-0.0.6/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "comfy-dynamic-widgets"
+version = "0.0.6"
+description = "Dynamic widget visibility for ComfyUI nodes via simple metadata"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "Andrea Pozzetti"}
+]
+keywords = ["comfyui", "widgets", "dynamic", "visibility", "conditional"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff"]
+
+[project.urls]
+Homepage = "https://github.com/PozzettiAndrea/comfy-dynamic-widgets"
+Repository = "https://github.com/PozzettiAndrea/comfy-dynamic-widgets"
+Issues = "https://github.com/PozzettiAndrea/comfy-dynamic-widgets/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["comfy_dynamic_widgets"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"