funcnodes-basic 0.1.8__tar.gz → 0.1.10__tar.gz

{funcnodes_basic-0.1.8 → funcnodes_basic-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-basic
-Version: 0.1.8
+Version: 0.1.10
 Summary: Basic functionalities for funcnodes
 License: MIT
 Author: Julian Kimmig
@@ -10,8 +10,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: funcnodes
-Requires-Dist: funcnodes-core (>=0.1.14)
+Requires-Dist: funcnodes-core (>=0.1.24)
 Project-URL: download, https://pypi.org/project/funcnodes-basic/#files
 Project-URL: homepage, https://github.com/Linkdlab/funcnodes_basic
 Project-URL: source, https://github.com/Linkdlab/funcnodes_basic

{funcnodes_basic-0.1.8 → funcnodes_basic-0.1.10}/funcnodes_basic/__init__.py

@@ -6,7 +6,7 @@ from .strings import NODE_SHELF as strings_shelf
 from .dicts import NODE_SHELF as dicts_shelf
 
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"
 
 NODE_SHELF = Shelf(
     nodes=[],

funcnodes_basic-0.1.10/funcnodes_basic/lists.py

@@ -0,0 +1,272 @@
+from typing import List, Union, Any, Tuple
+import funcnodes_core as fn
+import copy
+
+
+@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, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        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
+
+
+@fn.NodeDecorator(
+    id="to_list",
+    name="To List",
+)
+def to_list(obj: Any) -> List[Any]:
+    try:
+        return list(obj)
+    except TypeError:
+        return [obj]
+
+
+@fn.NodeDecorator(
+    id="list_length",
+    name="List Length",
+)
+def list_length(lst: List[Any]) -> int:
+    return len(lst)
+
+
+@fn.NodeDecorator(
+    id="list_append",
+    name="List Append",
+)
+def list_append(lst: List[Any], item: Any) -> List[Any]:
+    return lst + [item]
+
+
+@fn.NodeDecorator(
+    id="list_extend",
+    name="List Extend",
+)
+def list_extend(lst: List[Any], items: List[Any]) -> List[Any]:
+    return lst + items
+
+
+@fn.NodeDecorator(
+    id="list_pop",
+    name="List Pop",
+    default_io_options={
+        "lst": {
+            "on": {
+                "after_set_value": fn.decorator.update_other_io_value_options(
+                    "index",
+                    lambda result: {"min": 0, "max": len(result) - 1},
+                )
+            }
+        },
+    },
+    outputs=[
+        {"name": "new_list"},
+        {"name": "item"},
+    ],
+)
+def list_pop(lst: List[Any], index: int) -> Tuple[List[Any], Any]:
+    # shallow copy the list
+    lst = copy.copy(lst)
+    item = lst.pop(index)
+    return lst, item
+
+
+@fn.NodeDecorator(
+    id="list_remove",
+    name="List Remove",
+)
+def list_remove(lst: List[Any], item: Any, all: bool = False) -> List[Any]:
+    lst = copy.copy(lst)
+    if item in lst:
+        lst.remove(item)
+    if all:
+        while item in lst:
+            lst.remove(item)
+    return lst
+
+
+@fn.NodeDecorator(
+    id="list_index",
+    name="List Index",
+)
+def list_index(lst: List[Any], item: Any) -> int:
+    return lst.index(item)
+
+
+@fn.NodeDecorator(
+    id="list_reverse",
+    name="List Reverse",
+)
+def list_reverse(lst: List[Any]) -> List[Any]:
+    lst = copy.copy(lst)
+    lst.reverse()
+    return lst
+
+
+@fn.NodeDecorator(
+    id="list_sort",
+    name="List Sort",
+)
+def list_sort(lst: List[Any], reverse: bool = False) -> List[Any]:
+    lst = copy.copy(lst)
+    lst.sort(reverse=reverse)
+    return lst
+
+
+@fn.NodeDecorator(
+    id="list_count",
+    name="List Count",
+)
+def list_count(lst: List[Any], item: Any) -> int:
+    return lst.count(item)
+
+
+@fn.NodeDecorator(
+    id="list_insert",
+    name="List Insert",
+    default_io_options={
+        "lst": {
+            "on": {
+                "after_set_value": fn.decorator.update_other_io_value_options(
+                    "index",
+                    lambda result: {"min": 0, "max": len(result)},
+                )
+            }
+        },
+    },
+)
+def list_insert(lst: List[Any], index: int, item: Any) -> List[Any]:
+    lst = copy.copy(lst)
+    lst.insert(index, item)
+    return lst
+
+
+@fn.NodeDecorator(
+    id="list_set",
+    name="List Set",
+    default_io_options={
+        "lst": {
+            "on": {
+                "after_set_value": fn.decorator.update_other_io_value_options(
+                    "index",
+                    lambda result: {"min": 0, "max": len(result) - 1},
+                )
+            }
+        },
+    },
+)
+def list_set(lst: List[Any], index: int, item: Any) -> List[Any]:
+    lst = copy.copy(lst)
+    lst[index] = item
+    return lst
+
+
+@fn.NodeDecorator(
+    id="list_slice",
+    name="List Slice",
+    default_io_options={
+        "lst": {
+            "on": {
+                "after_set_value": fn.decorator.update_other_io_value_options(
+                    ["start", "end"],
+                    lambda result: {"min": -len(result), "max": len(result) + 1},
+                ),
+            }
+        },
+    },
+)
+def list_slice(lst: List[Any], start: int = 0, end: int = -1) -> List[Any]:
+    return lst[start:end]
+
+
+@fn.NodeDecorator(
+    id="list_slice_step",
+    name="List Slice Step",
+    default_io_options={
+        "lst": {
+            "on": {
+                "after_set_value": fn.decorator.update_other_io_value_options(
+                    ["start", "end"],
+                    lambda result: {"min": -len(result), "max": len(result) + 1},
+                ),
+            }
+        },
+    },
+)
+def list_slice_step(
+    lst: List[Any], start: int = 0, end: int = -1, step: int = 1
+) -> List[Any]:
+    return lst[start:end:step]
+
+
+NODE_SHELF = fn.Shelf(
+    nodes=[
+        contains,
+        GetIndexNode,
+        to_list,
+        list_length,
+        list_append,
+        list_extend,
+        list_pop,
+        list_remove,
+        list_index,
+        list_reverse,
+        list_sort,
+        list_count,
+        list_insert,
+        list_set,
+        list_slice,
+        list_slice_step,
+    ],
+    subshelves=[],
+    name="Lists",
+    description="List operations",
+)

{funcnodes_basic-0.1.8 → funcnodes_basic-0.1.10}/funcnodes_basic/math_nodes.py

@@ -22,9 +22,7 @@ def value_node(value: float) -> float:
 )
 def add_node(a: float, b: float) -> float:
     """Add two numbers"""
-    a = float(a)
-    b = float(b)
-    return a + b
+    return float(a) + float(b)
 
 
 @NodeDecorator(

{funcnodes_basic-0.1.8 → funcnodes_basic-0.1.10}/funcnodes_basic/strings.py

@@ -154,7 +154,7 @@ def string_split(s: str, delimiter: Optional[str] = None) -> List[str]:
         {"name": "joined"},
     ],
 )
-def string_join(strings: List[str], delimiter: str = " ") -> str:
+def string_join(strings: List[str], delimiter: str = "") -> str:
     return delimiter.join(strings)
 
 

{funcnodes_basic-0.1.8 → funcnodes_basic-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-basic"
-version = "0.1.8"
+version = "0.1.10"
 description = "Basic functionalities for funcnodes"
 authors = ["Julian Kimmig <julian.kimmig@gmx.net>"]
 readme = "README.md"
@@ -15,7 +15,7 @@ download = "https://pypi.org/project/funcnodes-basic/#files"
 
 [tool.poetry.dependencies]
 python = ">=3.11"
-funcnodes-core = ">=0.1.14"
+funcnodes-core = ">=0.1.24"
 funcnodes = "*"
 
 [tool.poetry.group.dev.dependencies]

funcnodes_basic-0.1.8/funcnodes_basic/lists.py

@@ -1,66 +0,0 @@
-from typing import List, Union, Any
-import funcnodes_core 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, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        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="Lists",
-    description="List operations",
-)