Slightly less ruff

.github/workflows/ruff.yml

@@ -15,10 +15,3 @@ jobs:
       - uses: astral-sh/ruff-action@v1
         with:
           args: check --select I --fix --diff
-  ruff-format:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/ruff-action@v1
-        with:
-          args: format --diff

pyiron_workflow/__init__.py

@@ -27,16 +27,15 @@
 - GUI on top for code-lite/code-free visual scripting
 """
 
-# deactivate: imported but unused
-# flake8: noqa: F401
-
 from ._version import get_versions
 
 __version__ = get_versions()["version"]
 
 # API
 
 # User entry point
+from pyiron_workflow.workflow import Workflow  # ruff: isort: skip
+
 # Node developer entry points
 from pyiron_workflow.channels import NOT_DATA
 from pyiron_workflow.find import (
@@ -62,4 +61,3 @@
     TypeNotFoundError,
     available_backends,
 )
-from pyiron_workflow.workflow import Workflow

pyiron_workflow/create.py

@@ -4,9 +4,7 @@
 
 from __future__ import annotations
 
-from abc import ABC
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
-from functools import lru_cache
 
 from executorlib import Executor as ExecutorlibExecutor
 from pyiron_snippets.dotdict import DotDict
@@ -32,7 +30,6 @@ class Creator(metaclass=Singleton):
     """
 
     def __init__(self):
-
         # Standard lib
         self.ProcessPoolExecutor = ProcessPoolExecutor
         self.ThreadPoolExecutor = ThreadPoolExecutor
@@ -44,35 +41,30 @@ def __init__(self):
         self.function_node = function_node
 
     @property
-    @lru_cache(maxsize=1)
     def standard(self):
         from pyiron_workflow.nodes import standard
 
         return standard
 
     @property
-    @lru_cache(maxsize=1)
     def for_node(self):
         from pyiron_workflow.nodes.for_loop import for_node
 
         return for_node
 
     @property
-    @lru_cache(maxsize=1)
     def macro_node(self):
         from pyiron_workflow.nodes.macro import macro_node
 
         return macro_node
 
     @property
-    @lru_cache(maxsize=1)
     def Workflow(self):
         from pyiron_workflow.workflow import Workflow
 
         return Workflow
 
     @property
-    @lru_cache(maxsize=1)
     def meta(self):
         from pyiron_workflow.nodes.transform import inputs_to_list, list_to_outputs
 
@@ -84,7 +76,6 @@ def meta(self):
         )
 
     @property
-    @lru_cache(maxsize=1)
     def transformer(self):
         from pyiron_workflow.nodes.transform import (
             dataclass_node,
@@ -117,21 +108,19 @@ class Wrappers(metaclass=Singleton):
     as_function_node = staticmethod(as_function_node)
 
     @property
-    @lru_cache(maxsize=1)
     def as_macro_node(self):
         from pyiron_workflow.nodes.macro import as_macro_node
 
         return as_macro_node
 
     @property
-    @lru_cache(maxsize=1)
     def as_dataclass_node(self):
         from pyiron_workflow.nodes.transform import as_dataclass_node
 
         return as_dataclass_node
 
 
-class HasCreator(ABC):
+class HasCreator:
     """
     A mixin class for creator (including both class-like and decorator).
     """

pyiron_workflow/mixin/has_interface_mixins.py

@@ -17,7 +17,7 @@
     from pyiron_workflow.channels import Channel
 
 
-class UsesState(ABC):
+class UsesState:
     """
     A mixin for any class using :meth:`__getstate__` or :meth:`__setstate__`.
 

pyiron_workflow/mixin/run.py

@@ -308,7 +308,7 @@ def _readiness_error_message(self) -> str:
 
     @staticmethod
     def _parse_executor(
-        executor: StdLibExecutor | (callable[..., StdLibExecutor], tuple, dict)
+        executor: StdLibExecutor | (callable[..., StdLibExecutor], tuple, dict),
     ) -> StdLibExecutor:
         """
         If you've already got an executor, you're done. But if you get callable and

pyiron_workflow/node.py

@@ -518,7 +518,6 @@ def _before_run(
             self.inputs.fetch()
 
         if self.use_cache and self.cache_hit:  # Read and use cache
-
             if self.parent is None and emit_ran_signal:
                 self.emit()
             elif self.parent is not None:

pyiron_workflow/nodes/for_loop.py

@@ -306,7 +306,6 @@ def _collect_output_as_dataframe(self, iter_maps):
         self.dataframe.outputs.df.value_receiver = self.outputs.df
 
         for n, channel_map in enumerate(iter_maps):
-
             row_collector = self._build_row_collector_node(n)
             for label, i in channel_map.items():
                 row_collector.inputs[label] = self.children[label][i]

pyiron_workflow/nodes/transform.py

@@ -197,7 +197,7 @@ def _build_inputs_preview(cls) -> dict[str, tuple[Any | None, Any | NOT_DATA]]:
 
     @staticmethod
     def hash_specification(
-        input_specification: list[str] | dict[str, tuple[Any | None, Any | NOT_DATA]]
+        input_specification: list[str] | dict[str, tuple[Any | None, Any | NOT_DATA]],
     ):
         """For generating unique subclass names."""
 

pyiron_workflow/output_parser.py

@@ -5,7 +5,6 @@
 import ast
 import inspect
 import re
-from functools import lru_cache
 from textwrap import dedent
 
 
@@ -57,7 +56,6 @@ def node_return(self):
             return None
 
     @property
-    @lru_cache(maxsize=1)
     def source(self):
         return self.dedented_source_string.split("\n")[:-1]
 

pyiron_workflow/storage.py

@@ -198,7 +198,6 @@ def _parse_filename(self, node: Node | None, filename: str | Path | None = None)
 
 
 class PickleStorage(StorageInterface):
-
     _PICKLE = ".pckl"
     _CLOUDPICKLE = ".cpckl"
 

pyiron_workflow/topology.py

@@ -142,7 +142,7 @@ def _set_run_connections_according_to_linear_dag(nodes: dict[str, Node]) -> list
 
 
 def set_run_connections_according_to_linear_dag(
-    nodes: dict[str, Node]
+    nodes: dict[str, Node],
 ) -> tuple[list[tuple[SignalChannel, SignalChannel]], list[Node]]:
     """
     Given a set of nodes that all have the same parent, have no upstream data
@@ -194,7 +194,7 @@ def _set_run_connections_according_to_dag(nodes: dict[str, Node]) -> list[Node]:
 
 
 def set_run_connections_according_to_dag(
-    nodes: dict[str, Node]
+    nodes: dict[str, Node],
 ) -> tuple[list[tuple[SignalChannel, SignalChannel]], list[Node]]:
     """
     Given a set of nodes that all have the same parent, have no upstream data

pyiron_workflow/workflow.py

@@ -241,7 +241,6 @@ def _after_node_setup(
         autorun: bool = False,
         **kwargs,
     ):
-
         for node in args:
             self.add_child(node)
         super()._after_node_setup(

pyproject.toml

@@ -84,3 +84,6 @@ select = [
     "I",
 ]
 ignore = ["E501"] #ignore line-length violations
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]  # Ignore unused imports in init files -- we specify APIs this way

tests/benchmark/__init__.py

@@ -1,3 +1,3 @@
 """
 Timed tests to make sure critical components stay sufficiently efficient.
-"""
+"""

tests/benchmark/test_benchmark.py

@@ -6,5 +6,5 @@ def test_nothing(self):
         self.assertTrue(True)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/integration/__init__.py

@@ -1,3 +1,3 @@
 """
 Large and potentially slower tests to check how the pieces fit together.
-"""
+"""

tests/integration/test_output_injection.py

@@ -8,12 +8,11 @@ class TestOutputInjection(unittest.TestCase):
     """
     I.e. the process of inserting new nodes on-the-fly by modifying output channels"
     """
+
     def setUp(self) -> None:
         self.wf = Workflow("injection")
         self.int = Workflow.create.standard.UserInput(42, autorun=True)
-        self.list = Workflow.create.standard.UserInput(
-            list(range(10)), autorun=True
-        )
+        self.list = Workflow.create.standard.UserInput(list(range(10)), autorun=True)
 
     def test_equality(self):
         with self.subTest("True expressions"):
@@ -76,7 +75,7 @@ def test_algebra(self):
             (x // 43, 0 * x),
             ((x + 1) % x, x + 1 - x),
             (-x, -1 * x),
-            (+x, (-x)**2 / x),
+            (+x, (-x) ** 2 / x),
             (x, abs(-x)),
         ]:
             with self.subTest(f"{lhs.label} == {rhs.label}"):
@@ -127,29 +126,24 @@ def test_casts(self):
         self.assertEqual(self.int.value, round(self.float).value)
 
     def test_access(self):
-
-        self.dict = Workflow.create.standard.UserInput(
-            {"foo": 42}, autorun=True
-        )
+        self.dict = Workflow.create.standard.UserInput({"foo": 42}, autorun=True)
 
         class Something:
             myattr = 1
 
-        self.obj = Workflow.create.standard.UserInput(
-            Something(), autorun=True
-        )
+        self.obj = Workflow.create.standard.UserInput(Something(), autorun=True)
 
         self.assertIsInstance(self.list[0].value, int)
         self.assertEqual(5, self.list[:5].len().value)
         self.assertEqual(4, self.list[1:5].len().value)
         self.assertEqual(3, self.list[-3:].len().value)
         self.assertEqual(2, self.list[1:5:2].len().value)
-        
+
         self.assertEqual(42, self.dict["foo"].value)
         self.assertEqual(1, self.obj.myattr.value)
 
     def test_chaining(self):
-        self.assertFalse((self.list[:self.int//42][0] != 0).value)
+        self.assertFalse((self.list[: self.int // 42][0] != 0).value)
 
     def test_repeated_access_in_parent_scope(self):
         wf = Workflow("output_manipulation")
@@ -162,13 +156,9 @@ def test_repeated_access_in_parent_scope(self):
         self.assertIs(
             a,
             b,
-            msg="The same operation should re-access an existing node in the parent"
-        )
-        self.assertIsNot(
-            a,
-            c,
-            msg="Unique operations should yield unique nodes"
+            msg="The same operation should re-access an existing node in the parent",
         )
+        self.assertIsNot(a, c, msg="Unique operations should yield unique nodes")
 
     def test_without_parent(self):
         d1 = self.list[5]
@@ -179,14 +169,14 @@ def test_without_parent(self):
             d1,
             d2,
             msg="Outside the scope of a parent, we can't expect to re-access an "
-                "equivalent node"
+                "equivalent node",
         )
         self.assertEqual(
             d1.label,
             d2.label,
-            msg="Equivalent operations should nonetheless generate equal labels"
+            msg="Equivalent operations should nonetheless generate equal labels",
         )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/integration/test_parallel_speedup.py

@@ -6,7 +6,6 @@
 
 class TestSpeedup(unittest.TestCase):
     def test_speedup(self):
-
         def make_workflow(label):
             wf = Workflow(label)
             wf.a = Workflow.create.standard.Sleep(t)
@@ -36,7 +35,7 @@ def make_workflow(label):
             dt_cached_serial,
             0.01 * t,
             msg="The cache should be trivially fast compared to actual execution of "
-                "a sleep node"
+            "a sleep node",
         )
 
         wf = make_workflow("parallel")
@@ -65,13 +64,13 @@ def make_workflow(label):
             0.5 * dt_serial,
             msg=f"Expected the parallel solution to be at least 2x faster, but got"
                 f"{dt_parallel}  and {dt_serial} for parallel and serial times, "
-                f"respectively"
+                f"respectively",
         )
         self.assertLess(
             dt_cached_parallel,
             0.01 * t,
             msg="The cache should be trivially fast compared to actual execution of "
-                "a sleep node"
+                "a sleep node",
         )
 
     def test_executor_instructions(self):
@@ -95,9 +94,9 @@ def test_executor_instructions(self):
             1.1 * t,
             msg="Expected the sleeps to run in parallel with minimal overhead (since "
                 "it's just a thread pool executor) -- the advantage is that the "
-                "constructors should survive (de)serialization"
+                "constructors should survive (de)serialization",
         )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()