funcnodes-basic 0.1.0__py3-none-any.whl

funcnodes_basic/__init__.py

@@ -0,0 +1,19 @@
+from funcnodes import Shelf
+from .logic import NODE_SHELF as logic_shelf
+from .math import NODE_SHELF as math_shelf
+from .lists import NODE_SHELF as lists_shelf
+from .strings import NODE_SHELF as strings_shelf
+
+__version__ = "0.1.0"
+
+NODE_SHELF = Shelf(
+    nodes=[],
+    subshelves=[
+        lists_shelf,
+        strings_shelf,
+        math_shelf,
+        logic_shelf,
+    ],
+    name="basics",
+    description="basic functionalities",
+)

funcnodes_basic/lists.py

@@ -0,0 +1,66 @@
+from typing import List, Union, Any
+import funcnodes as fn
+
+
+@fn.NodeDecorator(
+    id="contains_node",
+    name="Contains",
+)
+def contains(collection: List[Union[str, Any]], item: Union[str, Any]) -> bool:
+    return item in collection
+
+
+class GetIndexNode(fn.Node):
+    node_id = "list.get"
+    node_name = "Get Element"
+    description = "Gets an element from a list."
+    inputlist = fn.NodeInput(
+        name="List",
+        type=List[Union[str, Any]],
+        uuid="inputlist",
+    )
+
+    index = fn.NodeInput(
+        name="Index",
+        type=int,
+        uuid="index",
+    )
+
+    element = fn.NodeOutput(
+        name="Element",
+        type=Any,
+        uuid="element",
+    )
+
+    def __init__(self):
+        super().__init__()
+        self.get_input("inputlist").on("after_set_value", self._update_indices)
+
+    def _update_indices(self, **kwargs):
+        try:
+            lst = self.get_input("inputlist").value
+            index = self.get_input("index")
+        except KeyError:
+            return
+        try:
+            index.update_value_options(min=0, max=len(lst) - 1)
+        except Exception:
+            index.update_value_options(min=0, max=0)
+
+    async def func(
+        self,
+        inputlist: List[Any],
+        index: int,
+    ) -> Any:
+        index = int(index)
+        ele = inputlist[index]
+        self.get_output("element").value = ele
+        return ele
+
+
+NODE_SHELF = fn.Shelf(
+    nodes=[contains, GetIndexNode],
+    subshelves=[],
+    name="Logic",
+    description="Control flow and decision making nodes.",
+)

funcnodes_basic/logic.py

@@ -0,0 +1,114 @@
+"""Logic Nodes for control flow and decision making."""
+
+from funcnodes.node import Node, TriggerStack
+from typing import Any, List, Optional, Union
+from funcnodes.io import NodeInput, NodeOutput, NoValue
+import asyncio
+
+import funcnodes as fn
+
+
+class IfNode(Node):
+    node_id = "if_node"
+    node_name = "If"
+    on_true = NodeOutput(id="on_true", type=Any)
+    on_false = NodeOutput(id="on_false", type=Any)
+    condition = NodeInput(id="condition", type=bool)
+    input = NodeInput(id="input", type=Any)
+
+    async def func(self, condition: bool, input: Any) -> None:
+        if condition:
+            self.outputs["on_true"].value = input
+        else:
+            self.outputs["on_false"].value = input
+
+
+class WhileNode(Node):
+    node_id = "while_node"
+    node_name = "While"
+    condition = NodeInput(id="condition", type=bool)
+    input = NodeInput(id="input", type=Any)
+    do = NodeOutput(id="do", type=Any)
+    done = NodeOutput(id="done", type=Any)
+
+    async def func(self, condition: bool, input: Any) -> None:
+        if condition:
+            self.outputs["do"].value = input
+            self.request_trigger()
+        else:
+            self.outputs["done"].value = input
+
+
+class WaitNode(Node):
+    node_id = "wait_node"
+    node_name = "Wait"
+    delay = NodeInput(
+        id="delay",
+        type=float,
+        required=True,
+        default=1.0,
+        does_trigger=False,
+        render_options={"step": "0.1"},
+        value_options={"min": 0.0},
+    )
+    input = NodeInput(id="input", type=Any)
+    output = NodeOutput(id="output", type=Any)
+
+    async def func(self, delay: float, input: Any) -> None:
+        await asyncio.sleep(delay)
+        self.outputs["output"].value = input
+
+
+class ForNode(Node):
+    node_id = "for_node"
+    node_name = "For"
+    input = NodeInput(id="input", type=List[Any])
+    do = NodeOutput(id="do", type=Any)
+    collector = NodeInput(id="collector", type=Any, does_trigger=False, required=False)
+    done = NodeOutput(id="done", type=List[Any])
+
+    async def func(self, input: list, collector: Optional[Any] = None) -> None:
+        results = []
+        for i in input:
+            self.outputs["do"].set_value(i, does_trigger=False)
+            triggerstack = TriggerStack()
+            try:
+                await self.outputs["do"].trigger(triggerstack)
+                await triggerstack
+            except Exception as e:
+                pass
+            v = self.inputs["collector"].value
+            if v is not NoValue:
+                results.append(v)
+                self.inputs["collector"].value = NoValue
+        self.outputs["done"].value = results
+
+
+class CollectorNode(Node):
+    node_id = "collector_node"
+    node_name = "Collector"
+
+    reset = NodeInput(id="reset", type=Any, does_trigger=True, required=False)
+    input = NodeInput(id="input", type=Any)
+
+    output = NodeOutput(id="output", type=List[Any])
+    default_reset_inputs_on_trigger = True
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.collection = []
+
+    async def func(self, input: Any, reset: Any = NoValue) -> None:
+        if reset != NoValue:
+            self.collection = []
+
+        self.collection.append(input)
+        self.outputs["output"].value = self.collection
+
+
+NODE_SHELF = fn.Shelf(
+    nodes=[IfNode, WhileNode, WaitNode, ForNode, CollectorNode],
+    subshelves=[],
+    name="Logic",
+    description="Control flow and decision making nodes.",
+)