funcnodes-core 2.3.2__tar.gz → 2.4.0__tar.gz

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v2.4.0 (2026-03-17)
+
+### Feat
+
+- **context**: add context7 configuration file with URL and public key
+
+### Fix
+
+- **io**: preserve trigger propagation semantics across node chains
+- **tests**: correct typo in test function name for clarity
+
 ## v2.3.2 (2025-12-24)
 
 ### Fix

funcnodes_core-2.4.0/CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing to funcnodes-core
+
+This repository contains the **core runtime** (nodes, IO, nodespace, library, config, serialization).
+
+## Development setup (Python)
+
+Prereqs:
+
+- Python **3.11+**
+- `uv` (https://github.com/astral-sh/uv)
+
+Recommended environment variables (keep caches/config local):
+
+- `UV_CACHE_DIR=.cache/uv`
+- `FUNCNODES_CONFIG_DIR=.funcnodes`
+
+Install dev dependencies:
+
+```bash
+cd funcnodes_core
+UV_CACHE_DIR=.cache/uv uv sync --group dev
+```
+
+Run tests:
+
+```bash
+cd funcnodes_core
+FUNCNODES_CONFIG_DIR=.funcnodes UV_CACHE_DIR=.cache/uv uv run pytest
+```
+
+## Code style & hooks
+
+Run pre-commit:
+
+```bash
+cd funcnodes_core
+UV_CACHE_DIR=.cache/uv uv run pre-commit install
+UV_CACHE_DIR=.cache/uv uv run pre-commit run -a
+```
+
+## TDD expectations
+
+- Write tests first; add edge cases as separate tests.
+- Avoid mocks unless simulating external resources.
+
+## Pull requests
+
+- Work on a feature branch (direct commits to `main`/`master`/`test` are blocked by pre-commit).
+- Keep changes scoped: core is widely used across FuncNodes packages.

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: funcnodes-core
-Version: 2.3.2
+Version: 2.4.0
 Summary: core package for funcnodes
 Project-URL: homepage, https://github.com/Linkdlab/funcnodes_core
 Project-URL: source, https://github.com/Linkdlab/funcnodes_core
@@ -37,5 +37,28 @@ Requires-Dist: vulture>=2.14; extra == 'dev'
 Requires-Dist: yappi>=1.6.10; extra == 'dev'
 Description-Content-Type: text/markdown
 
-Core package for funcnodes.
-for detailed instructions go to the funcnodes repo
+# FuncNodes Core
+
+This is the core package for **FuncNodes**, a flexible and modular framework for building and managing computational graphs.
+
+`funcnodes_core` contains the fundamental logic for Nodes, NodeSpaces, and the event-driven architecture that powers the system.
+
+> [!NOTE]
+> If you are looking for the full application, including the web interface and worker management, please visit the main [FuncNodes repository](https://github.com/Linkdlab/FuncNodes) or install the `funcnodes` package.
+
+## Installation
+
+If you are developing a custom implementation or only need the core logic:
+
+```bash
+pip install funcnodes-core
+```
+
+For the full experience:
+```bash
+pip install funcnodes
+```
+
+## Documentation
+
+For detailed instructions and documentation, please visit the [FuncNodes Documentation](https://linkdlab.github.io/FuncNodes).

funcnodes_core-2.4.0/README.md

@@ -0,0 +1,25 @@
+# FuncNodes Core
+
+This is the core package for **FuncNodes**, a flexible and modular framework for building and managing computational graphs.
+
+`funcnodes_core` contains the fundamental logic for Nodes, NodeSpaces, and the event-driven architecture that powers the system.
+
+> [!NOTE]
+> If you are looking for the full application, including the web interface and worker management, please visit the main [FuncNodes repository](https://github.com/Linkdlab/FuncNodes) or install the `funcnodes` package.
+
+## Installation
+
+If you are developing a custom implementation or only need the core logic:
+
+```bash
+pip install funcnodes-core
+```
+
+For the full experience:
+```bash
+pip install funcnodes
+```
+
+## Documentation
+
+For detailed instructions and documentation, please visit the [FuncNodes Documentation](https://linkdlab.github.io/FuncNodes).

funcnodes_core-2.4.0/context7.json

@@ -0,0 +1,4 @@
+{
+    "url": "https://context7.com/linkdlab/funcnodes_core",
+    "public_key": "pk_jr5hlTznUKh2bFkliKxXR"
+  }

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "funcnodes-core"
 
-version = "2.3.2"
+version = "2.4.0"
 
 description = "core package for funcnodes"
 authors = [{name = "Julian Kimmig", email = "julian.kimmig@linkdlab.de"}]

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/src/funcnodes_core/io.py

@@ -1039,10 +1039,11 @@ class NodeInput(NodeIO, Generic[NodeIOType]):
 
         self.datapath = new_datapath
 
+        resolved_does_trigger = does_trigger
         if self.node is not None:
-            if does_trigger is None:
-                does_trigger = self.does_trigger
-            if does_trigger:
+            if resolved_does_trigger is None:
+                resolved_does_trigger = self.does_trigger
+            if resolved_does_trigger:
                 self.node.request_trigger()
 
         for other in self._forwards:
@@ -1153,7 +1154,7 @@ class NodeInput(NodeIO, Generic[NodeIOType]):
         self._forwards.add(other)
         other.forwards_from(self, replace=replace)
 
-        other.set_value(self.value)
+        other.set_value(self.value, does_trigger=False)
 
         return [
             self.node.uuid if self.node else None,
@@ -1304,6 +1305,7 @@ class NodeOutput(NodeIO):
         else:
             datapath = None
             # input_paths = []
+        propagated_does_trigger = False if does_trigger is False else None
         for other in self.connections:
             # if self.node is not None:
             #     for input_path in input_paths:
@@ -1311,7 +1313,11 @@ class NodeOutput(NodeIO):
             # else:
             #     datapath = None
 
-            other.set_value(value, does_trigger=does_trigger, datapath=datapath)
+            other.set_value(
+                value,
+                does_trigger=propagated_does_trigger,
+                datapath=datapath,
+            )
 
     def post_connect(self, other: NodeIO):
         """Called after a connection is made.

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/tests/test_config.py

@@ -42,7 +42,7 @@ def test_no_deprecation_warning():
         warnings.simplefilter("error", DeprecationWarning)
 
 
-def test_config_not_laoded():
+def test_config_not_loaded():
     try:
         assert not fn.config._CONFIG_CHANGED, "Expected _CONFIG_CHANGED to be False"
 

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/tests/test_nodeclass.py

@@ -37,6 +37,25 @@ class DummyNode(Node):
         return input
 
 
+def make_counter_node(node_id: str, *, does_trigger: bool = True):
+    resolved_node_id = node_id
+
+    class CounterNode(Node):
+        node_id = resolved_node_id
+        value = NodeInput(id="value", type=int, does_trigger=does_trigger)
+        output = NodeOutput(id="output", type=int)
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, pretrigger_delay=0.0, **kwargs)
+            self.call_count = 0
+
+        async def func(self, value: int):
+            self.call_count += 1
+            self.outputs["output"].value = value
+
+    return CounterNode
+
+
 @funcnodes_test
 async def test_nodeclass_initialization():
     with pytest.raises(TypeError):
@@ -128,6 +147,161 @@ async def test_trigger_stack():
     assert not trigger_stack.done()
 
 
+@funcnodes_test
+async def test_forwarded_input_respects_target_does_trigger_flag():
+    ForwardSourceNode = make_counter_node("forward_source_node_test")
+    ForwardTargetNode = make_counter_node(
+        "forward_target_node_test", does_trigger=False
+    )
+
+    node_a = ForwardSourceNode()
+    node_b = ForwardTargetNode()
+    node_a.inputs["value"].connect(node_b.inputs["value"])
+
+    node_a.inputs["value"].value = 42
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_a.inputs["value"].value == 42
+    assert node_b.inputs["value"].value == 42
+    assert node_a.call_count == 1
+    assert node_b.call_count == 0
+    assert node_a.outputs["output"].value == 42
+    assert node_b.outputs["output"].value is fn.NoValue
+
+
+@funcnodes_test
+async def test_forwarded_input_uses_target_flag_when_source_flag_disables_self_only():
+    ForwardSourceNode = make_counter_node(
+        "forward_source_node_no_trigger_test", does_trigger=False
+    )
+    ForwardTargetNode = make_counter_node("forward_target_node_allow_test")
+
+    node_a = ForwardSourceNode()
+    node_b = ForwardTargetNode()
+    node_a.inputs["value"].connect(node_b.inputs["value"])
+
+    node_a.inputs["value"].value = 42
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_a.call_count == 0
+    assert node_b.call_count == 1
+    assert node_b.inputs["value"].value == 42
+    assert node_b.outputs["output"].value == 42
+
+
+@funcnodes_test
+async def test_forwarded_input_propagates_explicit_false_downstream():
+    ForwardSourceNode = make_counter_node("forward_source_node_explicit_false_test")
+    ForwardTargetNode = make_counter_node("forward_target_node_explicit_false_test")
+
+    node_a = ForwardSourceNode()
+    node_b = ForwardTargetNode()
+    node_a.inputs["value"].connect(node_b.inputs["value"])
+
+    node_a.inputs["value"].set_value(42, does_trigger=False)
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_a.call_count == 0
+    assert node_b.call_count == 0
+    assert node_b.inputs["value"].value == 42
+    assert node_b.outputs["output"].value is fn.NoValue
+
+
+@funcnodes_test
+async def test_forwarded_input_triggers_downstream_when_both_allow_triggering():
+    ForwardSourceNode = make_counter_node("forward_source_node_trigger_test")
+    ForwardTargetNode = make_counter_node("forward_target_node_trigger_test")
+
+    node_a = ForwardSourceNode()
+    node_b = ForwardTargetNode()
+    node_a.inputs["value"].connect(node_b.inputs["value"])
+
+    node_a.inputs["value"].value = 42
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_a.call_count == 1
+    assert node_b.call_count == 1
+    assert node_b.outputs["output"].value == 42
+
+
+@funcnodes_test
+async def test_forward_chain_skips_non_triggering_middle_node_but_triggers_downstream():
+    NodeA = make_counter_node("forward_chain_source_node_test")
+    NodeB = make_counter_node("forward_chain_middle_node_test", does_trigger=False)
+    NodeC = make_counter_node("forward_chain_target_node_test")
+
+    node_a = NodeA()
+    node_b = NodeB()
+    node_c = NodeC()
+
+    node_a.inputs["value"].connect(node_b.inputs["value"])
+    node_b.inputs["value"].connect(node_c.inputs["value"])
+
+    node_a.inputs["value"].value = 42
+    await fn.run_until_complete(node_a, node_b, node_c)
+
+    assert node_a.call_count == 1
+    assert node_b.call_count == 0
+    assert node_c.call_count == 1
+    assert node_b.inputs["value"].value == 42
+    assert node_c.inputs["value"].value == 42
+    assert node_b.outputs["output"].value is fn.NoValue
+    assert node_c.outputs["output"].value == 42
+
+
+@funcnodes_test
+async def test_output_set_value_respects_explicit_false_downstream():
+    SourceNode = make_counter_node("output_source_node_explicit_false_test")
+    TargetNode = make_counter_node("output_target_node_explicit_false_test")
+
+    node_a = SourceNode()
+    node_b = TargetNode()
+    node_a.outputs["output"].connect(node_b.inputs["value"])
+
+    node_a.outputs["output"].set_value(42, does_trigger=False)
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_b.inputs["value"].value == 42
+    assert node_b.call_count == 0
+    assert node_b.outputs["output"].value is fn.NoValue
+
+
+@funcnodes_test
+async def test_output_set_value_uses_target_does_trigger_flag_when_unspecified():
+    SourceNode = make_counter_node("output_source_node_unspecified_test")
+    TargetNode = make_counter_node(
+        "output_target_node_unspecified_false_test", does_trigger=False
+    )
+
+    node_a = SourceNode()
+    node_b = TargetNode()
+    node_a.outputs["output"].connect(node_b.inputs["value"])
+
+    node_a.outputs["output"].set_value(42)
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_b.inputs["value"].value == 42
+    assert node_b.call_count == 0
+    assert node_b.outputs["output"].value is fn.NoValue
+
+
+@funcnodes_test
+async def test_output_set_value_triggers_target_when_target_allows_triggering():
+    SourceNode = make_counter_node("output_source_node_trigger_test")
+    TargetNode = make_counter_node("output_target_node_trigger_test")
+
+    node_a = SourceNode()
+    node_b = TargetNode()
+    node_a.outputs["output"].connect(node_b.inputs["value"])
+
+    node_a.outputs["output"].set_value(42)
+    await fn.run_until_complete(node_a, node_b)
+
+    assert node_b.inputs["value"].value == 42
+    assert node_b.call_count == 1
+    assert node_b.outputs["output"].value == 42
+
+
 @funcnodes_test
 def test_nodeclass_string():
     test_node = DummyNode(uuid="test_uuid")

funcnodes_core-2.4.0/tests/test_trigger_propagation_matrix.py

@@ -0,0 +1,353 @@
+import pytest
+
+import funcnodes_core as fn
+from funcnodes_core.node import Node, NodeInput, NodeOutput
+from pytest_funcnodes import funcnodes_test
+
+
+UNSPECIFIED = object()
+
+
+def make_counter_node(node_id: str, *, does_trigger: bool = True):
+    resolved_node_id = node_id
+
+    class CounterNode(Node):
+        node_id = resolved_node_id
+        value = NodeInput(id="value", type=int, does_trigger=does_trigger)
+        output = NodeOutput(id="output", type=int)
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, pretrigger_delay=0.0, **kwargs)
+            self.call_count = 0
+
+        async def func(self, value: int):
+            self.call_count += 1
+            self.outputs["output"].value = value
+
+    return CounterNode
+
+
+def build_nodes(scenario_name: str, node_flags: dict[str, bool]) -> dict[str, Node]:
+    nodes: dict[str, Node] = {}
+    for name, does_trigger in node_flags.items():
+        node_cls = make_counter_node(
+            f"trigger_matrix_{scenario_name.lower()}_{name.lower()}",
+            does_trigger=does_trigger,
+        )
+        nodes[name] = node_cls()
+    return nodes
+
+
+def connect_nodes(
+    nodes: dict[str, Node], connections: list[tuple[str, str, str]]
+) -> None:
+    for connection_type, src, dst in connections:
+        if connection_type == "forward":
+            nodes[src].inputs["value"].connect(nodes[dst].inputs["value"])
+        elif connection_type == "output":
+            nodes[src].outputs["output"].connect(nodes[dst].inputs["value"])
+        else:
+            raise ValueError(f"Unknown connection type: {connection_type}")
+
+
+def apply_action(nodes: dict[str, Node], action: dict[str, object]) -> None:
+    node = nodes[action["node"]]  # type: ignore[index]
+    value = action["value"]
+    does_trigger = action.get("does_trigger", UNSPECIFIED)
+
+    if action["io"] == "input":
+        setter = node.inputs["value"].set_value
+    elif action["io"] == "output":
+        setter = node.outputs["output"].set_value
+    else:
+        raise ValueError(f"Unknown io type: {action['io']}")
+
+    if does_trigger is UNSPECIFIED:
+        setter(value)
+    else:
+        setter(value, does_trigger=does_trigger)  # type: ignore[arg-type]
+
+
+async def run_scenario(scenario: dict[str, object]) -> None:
+    nodes = build_nodes(scenario["name"], scenario["node_flags"])  # type: ignore[arg-type]
+    connect_nodes(nodes, scenario["connections"])  # type: ignore[arg-type]
+    apply_action(nodes, scenario["action"])  # type: ignore[arg-type]
+    await fn.run_until_complete(*nodes.values())
+
+    expected_counts = scenario["expected_counts"]  # type: ignore[assignment]
+    for name, expected_count in expected_counts.items():
+        assert nodes[name].call_count == expected_count
+
+
+INPUT_FORWARDING_SCENARIOS = [
+    {
+        "name": "input_forward_tt_unspecified",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 1},
+    },
+    {
+        "name": "input_forward_ft_unspecified",
+        "node_flags": {"A": False, "B": True},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 0, "B": 1},
+    },
+    {
+        "name": "input_forward_tf_unspecified",
+        "node_flags": {"A": True, "B": False},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 0},
+    },
+    {
+        "name": "input_forward_ff_unspecified",
+        "node_flags": {"A": False, "B": False},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 0, "B": 0},
+    },
+    {
+        "name": "input_forward_tt_explicit_false",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": False},
+        "expected_counts": {"A": 0, "B": 0},
+    },
+    {
+        "name": "input_forward_chain_tft_unspecified",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("forward", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 0, "C": 1},
+    },
+    {
+        "name": "input_forward_chain_tft_explicit_false",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("forward", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": False},
+        "expected_counts": {"A": 0, "B": 0, "C": 0},
+    },
+    {
+        "name": "input_forward_chain_ftft_unspecified",
+        "node_flags": {"A": False, "B": True, "C": False, "D": True},
+        "connections": [
+            ("forward", "A", "B"),
+            ("forward", "B", "C"),
+            ("forward", "C", "D"),
+        ],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 0, "B": 1, "C": 0, "D": 1},
+    },
+    {
+        "name": "input_forward_fanout_t_tf_unspecified",
+        "node_flags": {"A": True, "B": True, "C": False},
+        "connections": [("forward", "A", "B"), ("forward", "A", "C")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 1, "C": 0},
+    },
+    {
+        "name": "input_forward_fanout_t_tt_explicit_false",
+        "node_flags": {"A": True, "B": True, "C": True},
+        "connections": [("forward", "A", "B"), ("forward", "A", "C")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": False},
+        "expected_counts": {"A": 0, "B": 0, "C": 0},
+    },
+    {
+        "name": "input_forward_tt_explicit_true",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1},
+    },
+    {
+        "name": "input_forward_tf_explicit_true",
+        "node_flags": {"A": True, "B": False},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1},
+    },
+    {
+        "name": "input_forward_ft_explicit_true",
+        "node_flags": {"A": False, "B": True},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1},
+    },
+    {
+        "name": "input_forward_ff_explicit_true",
+        "node_flags": {"A": False, "B": False},
+        "connections": [("forward", "A", "B")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1},
+    },
+    {
+        "name": "input_forward_chain_tft_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("forward", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1, "C": 1},
+    },
+    {
+        "name": "input_forward_chain_tff_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": False},
+        "connections": [("forward", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1, "C": 1},
+    },
+    {
+        "name": "input_forward_fanout_t_ft_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("forward", "A", "B"), ("forward", "A", "C")],
+        "action": {"node": "A", "io": "input", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 1, "B": 1, "C": 1},
+    },
+    {
+        "name": "input_forward_diamond",
+        "node_flags": {"A": True, "B": True, "C": True, "D": True, "E": False},
+        "connections": [
+            ("forward", "A", "B"),
+            ("forward", "A", "C"),
+            ("forward", "B", "D"),
+            ("forward", "C", "E"),
+        ],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 1, "C": 1, "D": 1, "E": 0},
+    },
+]
+
+
+OUTPUT_PROPAGATION_SCENARIOS = [
+    {
+        "name": "output_to_input_t_unspecified",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("output", "A", "B")],
+        "action": {"node": "A", "io": "output", "value": 1},
+        "expected_counts": {"A": 0, "B": 1},
+    },
+    {
+        "name": "output_to_input_f_unspecified",
+        "node_flags": {"A": True, "B": False},
+        "connections": [("output", "A", "B")],
+        "action": {"node": "A", "io": "output", "value": 1},
+        "expected_counts": {"A": 0, "B": 0},
+    },
+    {
+        "name": "output_to_input_t_explicit_false",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("output", "A", "B")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": False},
+        "expected_counts": {"A": 0, "B": 0},
+    },
+    {
+        "name": "output_forward_chain_ft_unspecified",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("output", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1},
+        "expected_counts": {"A": 0, "B": 0, "C": 1},
+    },
+    {
+        "name": "output_forward_chain_ft_explicit_false",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("output", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": False},
+        "expected_counts": {"A": 0, "B": 0, "C": 0},
+    },
+    {
+        "name": "output_to_input_t_explicit_true",
+        "node_flags": {"A": True, "B": True},
+        "connections": [("output", "A", "B")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 1},
+    },
+    {
+        "name": "output_to_input_f_explicit_true",
+        "node_flags": {"A": True, "B": False},
+        "connections": [("output", "A", "B")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 0},
+    },
+    {
+        "name": "output_forward_chain_ft_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("output", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 0, "C": 1},
+    },
+    {
+        "name": "output_forward_chain_tf_explicit_true",
+        "node_flags": {"A": True, "B": True, "C": False},
+        "connections": [("output", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 1, "C": 0},
+    },
+    {
+        "name": "output_forward_chain_ff_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": False},
+        "connections": [("output", "A", "B"), ("forward", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 0, "C": 0},
+    },
+    {
+        "name": "output_fanout_explicit_true",
+        "node_flags": {"A": True, "B": False, "C": True},
+        "connections": [("output", "A", "B"), ("output", "A", "C")],
+        "action": {"node": "A", "io": "output", "value": 1, "does_trigger": True},
+        "expected_counts": {"A": 0, "B": 0, "C": 1},
+    },
+]
+
+
+MIXED_PROPAGATION_SCENARIOS = [
+    {
+        "name": "execution_chain_output_output",
+        "node_flags": {"A": True, "B": True, "C": True},
+        "connections": [("output", "A", "B"), ("output", "B", "C")],
+        "action": {"node": "A", "io": "output", "value": 1},
+        "expected_counts": {"A": 0, "B": 1, "C": 1},
+    },
+    {
+        "name": "input_then_execution_chain_output_false",
+        "node_flags": {"A": True, "B": True, "C": False},
+        "connections": [("forward", "A", "B"), ("output", "B", "C")],
+        "action": {"node": "A", "io": "input", "value": 1},
+        "expected_counts": {"A": 1, "B": 1, "C": 0},
+    },
+    {
+        "name": "mixed_output_diamond",
+        "node_flags": {"A": True, "B": False, "C": True, "D": True, "E": True},
+        "connections": [
+            ("output", "A", "B"),
+            ("output", "A", "C"),
+            ("forward", "B", "D"),
+            ("output", "C", "E"),
+        ],
+        "action": {"node": "A", "io": "output", "value": 1},
+        "expected_counts": {"A": 0, "B": 0, "C": 1, "D": 1, "E": 1},
+    },
+]
+
+
+@pytest.mark.parametrize(
+    "scenario", INPUT_FORWARDING_SCENARIOS, ids=lambda s: s["name"]
+)
+@funcnodes_test
+async def test_input_forwarding_trigger_matrix(scenario):
+    await run_scenario(scenario)
+
+
+@pytest.mark.parametrize(
+    "scenario", OUTPUT_PROPAGATION_SCENARIOS, ids=lambda s: s["name"]
+)
+@funcnodes_test
+async def test_output_propagation_trigger_matrix(scenario):
+    await run_scenario(scenario)
+
+
+@pytest.mark.parametrize(
+    "scenario", MIXED_PROPAGATION_SCENARIOS, ids=lambda s: s["name"]
+)
+@funcnodes_test
+async def test_mixed_trigger_propagation_matrix(scenario):
+    await run_scenario(scenario)

{funcnodes_core-2.3.2 → funcnodes_core-2.4.0}/uv.lock

@@ -457,7 +457,7 @@ wheels = [
 
 [[package]]
 name = "funcnodes-core"
-version = "2.3.2"
+version = "2.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "dill" },

funcnodes_core-2.3.2/README.md

@@ -1,2 +0,0 @@
-Core package for funcnodes.
-for detailed instructions go to the funcnodes repo