[minor] Shift responsibility

pyiron_workflow/mixin/semantics.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 from abc import ABC
+from pathlib import Path
 from typing import Optional
 
 from bidict import bidict
@@ -97,6 +98,15 @@ def semantic_root(self) -> Semantic:
         """The parent-most object in this semantic path; may be self."""
         return self.parent.semantic_root if isinstance(self.parent, Semantic) else self
 
+    def as_path(self, root: Path | str | None = None) -> Path:
+        """
+        The semantic path as a :class:`pathlib.Path`, with a filesystem :param:`root`
+        (default is the current working directory).
+        """
+        return (Path.cwd() if root is None else Path(root)).joinpath(
+            *self.semantic_path.split(self.semantic_delimiter)
+        )
+
     def __getstate__(self):
         state = super().__getstate__()
         state["_parent"] = None

pyiron_workflow/node.py

@@ -22,7 +22,7 @@
 from pyiron_workflow.mixin.run import Runnable, ReadinessError
 from pyiron_workflow.mixin.semantics import Semantic
 from pyiron_workflow.mixin.single_output import ExploitsSingleOutput
-from pyiron_workflow.storage import StorageInterface, PickleStorage
+from pyiron_workflow.storage import StorageInterface, available_backends
 from pyiron_workflow.topology import (
     get_nodes_in_data_tree,
     set_run_connections_according_to_linear_dag,
@@ -33,7 +33,6 @@
     from pathlib import Path
 
     import graphviz
-    from pyiron_snippets.files import DirectoryObject
 
     from pyiron_workflow.channels import OutputSignal
     from pyiron_workflow.nodes.composite import Composite
@@ -343,13 +342,16 @@ def _after_node_setup(
         if delete_existing_savefiles:
             self.delete_storage(backend=autoload)
 
-        if autoload is not None and self.any_storage_has_contents(autoload):
-            logger.info(
-                f"A saved file was found for the node {self.full_label} -- "
-                f"attempting to load it...(To delete the saved file instead, use "
-                f"`delete_existing_savefiles=True`)"
-            )
-            self.load(backend=autoload)
+        if autoload is not None:
+            for backend in available_backends(backend=autoload):
+                if backend.has_contents(self):
+                    logger.info(
+                        f"A saved file was found for the node {self.full_label} -- "
+                        f"attempting to load it...(To delete the saved file instead, "
+                        f"use `delete_existing_savefiles=True`) "
+                    )
+                    self.load(backend=autoload)
+                    break
 
         self.set_input_values(*args, **kwargs)
 
@@ -359,8 +361,6 @@ def _after_node_setup(
             except ReadinessError:
                 pass
 
-        self.graph_root.tidy_working_directory()
-
     @property
     def graph_path(self) -> str:
         """
@@ -786,25 +786,6 @@ def replace_with(self, other: Node | type[Node]):
         else:
             logger.info(f"Could not replace_child {self.label}, as it has no parent.")
 
-    @classmethod
-    def _storage_interfaces(cls):
-        return {"pickle": PickleStorage}
-
-    @classmethod
-    def allowed_backends(cls):
-        return tuple(cls._storage_interfaces().keys())
-
-    @property
-    def storage_directory(self) -> DirectoryObject:
-        return self.working_directory
-
-    @property
-    def storage_path(self) -> str:
-        return self.graph_path
-
-    def tidy_storage_directory(self):
-        self.tidy_working_directory()
-
     _save_load_warnings = """
         HERE BE DRAGONS!!!
 
@@ -829,13 +810,10 @@ def tidy_storage_directory(self):
 
     def save(self, backend: str | StorageInterface = "pickle"):
         """
-        Writes the node to file (using HDF5) such that a new node instance of the same
-        type can :meth:`load()` the data to return to the same state as the save point,
-        i.e. the same data IO channel values, the same flags, etc.
+        Writes the node to file using the requested interface as a back end.
         """
-        if isinstance(backend, str):
-            backend = self._storage_interfaces()[backend]()
-        backend.save(self)
+        for backend in available_backends(backend=backend, only_requested=True):
+            backend.save(self)
 
     save.__doc__ += _save_load_warnings
 
@@ -847,69 +825,40 @@ def save_checkpoint(self, backend: str | StorageInterface = "pickle"):
 
     def load(self, backend: str | StorageInterface = "pickle"):
         """
-        Loads the node file (from HDF5) such that this node restores its state at time
-        of loading.
+        Loads the node file and set the loaded state as the node's own.
 
         Raises:
             TypeError: when the saved node has a different class name.
         """
-        if isinstance(backend, str):
-            backend = self._storage_interfaces()[backend]()
-
-        if backend.has_contents(self):
-            backend.load(self)
-        else:
-            # Check for saved content using any other backend
-            for backend_class in self.allowed_backends():
-                backend = self._storage_interfaces()[backend_class]()
-                if backend.has_contents(self):
-                    backend.load(self)
-                    break
+        for backend in available_backends(backend=backend):
+            if backend.has_contents(self):
+                inst = backend.load(self)
+                break
+            raise FileNotFoundError(f"{self.label} could not find saved content.")
+
+        if inst.__class__ != self.__class__:
+            raise TypeError(
+                f"{self.label} cannot load, as it has type "
+                f"{self.__class__.__name__},  but the saved node has type "
+                f"{inst.__class__.__name__}"
+            )
+        self.__setstate__(inst.__getstate__())
 
     load.__doc__ += _save_load_warnings
 
     def delete_storage(
-        self, backend: Literal["pickle"] | StorageInterface | None = None
-    ):
-        """Remove save files for _all_ available backends."""
-        backends_to_check = [
-            self._storage_interfaces()[backend_class]()
-            for backend_class in self.allowed_backends()
-        ]
-        if isinstance(backend, str):
-            backends_to_check.append(self._storage_interfaces()[backend]())
-        elif isinstance(backend, StorageInterface):
-            backends_to_check.append(backend)
-
-        for backend in backends_to_check:
-            try:
-                backend.delete(self)
-            except FileNotFoundError:
-                pass
-
-    @property
-    def storage_root(self):
-        """The parent-most object that has storage."""
-        parent = self.parent
-        if isinstance(parent, Node):
-            return parent.storage_root
-        else:
-            return self
-
-    def any_storage_has_contents(
-        self, backend: Literal["pickle"] | StorageInterface | None
+        self,
+        backend: Literal["pickle"] | StorageInterface | None = None,
+        only_requested: bool = False,
     ):
-        if isinstance(backend, str) and self._storage_interfaces()[
-            backend
-        ]().has_contents(self):
-            return True
-        elif isinstance(backend, StorageInterface) and backend.has_contents(self):
-            return True
-        else:
-            return any(
-                self._storage_interfaces()[backend]().has_contents(self)
-                for backend in self.allowed_backends()
-            )
+        """Remove save file(s)."""
+        for backend in available_backends(
+            backend=backend, only_requested=only_requested
+        ):
+            backend.delete(self)
+
+    def has_savefile(self, backend: Literal["pickle"] | StorageInterface | None = None):
+        return any(be.has_contents(self) for be in available_backends(backend=backend))
 
     @property
     def import_ready(self) -> bool: