From 414ac6aa2ee491e1b1a64add9dca3686e32d40f4 Mon Sep 17 00:00:00 2001
From: PythonFZ <fabian.zills@web.de>
Date: Thu, 21 Sep 2023 18:25:48 +0200
Subject: [PATCH 1/4] deprecated zntrack.zn and zntrack.dvc

---
 poetry.lock                    |  2 +-
 pyproject.toml                 |  1 +
 zntrack/fields/dvc/__init__.py | 10 ++++++++++
 zntrack/fields/zn/__init__.py  |  7 +++++++
 4 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/poetry.lock b/poetry.lock
index f1791a5e..3a5d6e1e 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -5534,4 +5534,4 @@ files = [
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.8,<4.0.0"
-content-hash = "7d787bc3f767e051b188aa81732499fce9e294aa0b899e2369cb69dc51c72a0c"
+content-hash = "094010c5f8f6ae2f7fa142031fa5e11f4527d7cb6062a397fb2057bf488a9608"
diff --git a/pyproject.toml b/pyproject.toml
index 1d7e30c8..3b0362ce 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,7 @@ dot4dict = "^0.1.1"
 zninit = "^0.1.11"
 znjson = "^0.2.2"
 znflow = "^0.1.14"
+typing-extensions = "^4.8.0"
 
 
 [tool.poetry.urls]
diff --git a/zntrack/fields/dvc/__init__.py b/zntrack/fields/dvc/__init__.py
index 20ee07f3..1ebb5726 100644
--- a/zntrack/fields/dvc/__init__.py
+++ b/zntrack/fields/dvc/__init__.py
@@ -3,6 +3,7 @@
 import pathlib
 import typing
 
+import typing_extensions as tyex
 import znjson
 
 from zntrack.fields.field import Field, FieldGroup, PlotsMixin
@@ -140,46 +141,55 @@ class PlotsOption(PlotsMixin, DVCOption):
     """Field with DVC plots kwargs."""
 
 
+@tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs(*args, **kwargs) -> DVCOption:
     """Create a outs field."""
     return DVCOption(*args, dvc_option="outs", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.params_path' instead.")
 def params(*args, **kwargs) -> DVCOption:
     """Create a params field."""
     return DVCOption(*args, dvc_option="params", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.deps_path' instead.")
 def deps(*args, **kwargs) -> DVCOption:
     """Create a deps field."""
     return DVCOption(*args, dvc_option="deps", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs_no_cache(*args, **kwargs) -> DVCOption:
     """Create a outs_no_cache field."""
     return DVCOption(*args, dvc_option="outs-no-cache", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs_persistent(*args, **kwargs) -> DVCOption:
     """Create a outs_persistent field."""
     return DVCOption(*args, dvc_option="outs-persistent", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.metrics_path' instead.")
 def metrics(*args, **kwargs) -> DVCOption:
     """Create a metrics field."""
     return DVCOption(*args, dvc_option="metrics", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.metrics_path' instead.")
 def metrics_no_cache(*args, **kwargs) -> DVCOption:
     """Create a metrics_no_cache field."""
     return DVCOption(*args, dvc_option="metrics-no-cache", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.plots_path' instead.")
 def plots(*args, **kwargs) -> DVCOption:
     """Create a plots field."""
     return PlotsOption(*args, dvc_option="plots", **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.plots_path' instead.")
 def plots_no_cache(*args, **kwargs) -> DVCOption:
     """Create a plots_no_cache field."""
     return PlotsOption(*args, dvc_option="plots-no-cache", **kwargs)
diff --git a/zntrack/fields/zn/__init__.py b/zntrack/fields/zn/__init__.py
index 691f284f..f1a3dae2 100644
--- a/zntrack/fields/zn/__init__.py
+++ b/zntrack/fields/zn/__init__.py
@@ -6,6 +6,7 @@
 import typing
 
 import pandas as pd
+import typing_extensions as tyex
 import yaml
 import znflow
 import znflow.utils
@@ -566,31 +567,37 @@ def get_files(self, instance: "Node") -> list:
         ]
 
 
+@tyex.deprecated("Use 'zntrack.params' instead.")
 def params(*args, **kwargs) -> Params:
     """Create a params field."""
     return Params(*args, **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.deps' instead.")
 def deps(*args, **kwargs) -> Dependency:
     """Create a dependency field."""
     return Dependency(*args, **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.outs' instead.")
 def outs() -> Output:
     """Create an output field."""
     return Output(dvc_option="outs", use_repr=False)
 
 
+@tyex.deprecated("Use 'zntrack.metrics' instead.")
 def metrics() -> Output:
     """Create a metrics output field."""
     return Output(dvc_option="metrics-no-cache")
 
 
+@tyex.deprecated("Use 'zntrack.plots' instead.")
 def plots(*args, **kwargs) -> Plots:
     """Create a metrics output field."""
     return Plots(*args, **kwargs)
 
 
+@tyex.deprecated("Use 'zntrack.deps' instead.")
 def nodes(*args, **kwargs) -> NodeField:
     """Create a node field."""
     return NodeField(*args, **kwargs)

From b8ed2ff24a8803349fa83f95d81ec8f1b120c8dd Mon Sep 17 00:00:00 2001
From: PythonFZ <fabian.zills@web.de>
Date: Thu, 21 Sep 2023 18:50:31 +0200
Subject: [PATCH 2/4] deprecate 'zntrack.zn' and 'zntrack.dvc' modules

---
 zntrack/core/node.py           |   5 +-
 zntrack/fields/dependency.py   |   4 +-
 zntrack/fields/dvc/__init__.py | 165 +--------
 zntrack/fields/dvc/options.py  | 141 ++++++++
 zntrack/fields/fields.py       |  65 ++--
 zntrack/fields/zn/__init__.py  | 593 +--------------------------------
 zntrack/fields/zn/options.py   | 567 +++++++++++++++++++++++++++++++
 7 files changed, 788 insertions(+), 752 deletions(-)
 create mode 100644 zntrack/fields/dvc/options.py
 create mode 100644 zntrack/fields/zn/options.py

diff --git a/zntrack/core/node.py b/zntrack/core/node.py
index 40119b39..09c0308a 100644
--- a/zntrack/core/node.py
+++ b/zntrack/core/node.py
@@ -175,10 +175,11 @@ def convert_notebook(cls, nb_name: str = None):
     def _init_descriptors_(self):
         from zntrack import fields
         from zntrack.fields.dependency import Dependency
+        from zntrack.fields.zn import options as zn_options
 
         return [
-            fields.zn.Params,
-            fields.zn.Dependency,
+            zn_options.Params,
+            zn_options.Dependency,
             Dependency,
             fields.meta.Text,
             fields.meta.Environment,
diff --git a/zntrack/fields/dependency.py b/zntrack/fields/dependency.py
index f5183363..fde87ec8 100644
--- a/zntrack/fields/dependency.py
+++ b/zntrack/fields/dependency.py
@@ -11,7 +11,7 @@
 from znflow import handler
 
 from zntrack.fields.field import DataIsLazyError, Field, FieldGroup, LazyField
-from zntrack.fields.zn import (
+from zntrack.fields.zn.options import (
     CombinedConnectionsConverter,
     ConnectionConverter,
     _default,
@@ -458,7 +458,7 @@ def get_stage_add_argument(self, instance) -> t.List[tuple]:
         # TODO this is only for parameters via `zn.params`
         # we need to also handle parameters via `dvc.params`
 
-        from zntrack.fields.zn import Params
+        from zntrack.fields.zn.options import Params
 
         # NO: we have to do this for each value and for instance
 
diff --git a/zntrack/fields/dvc/__init__.py b/zntrack/fields/dvc/__init__.py
index 1ebb5726..ff9724be 100644
--- a/zntrack/fields/dvc/__init__.py
+++ b/zntrack/fields/dvc/__init__.py
@@ -1,195 +1,64 @@
-"""DVC fields without serialization of data / for file paths."""
-import json
-import pathlib
-import typing
+"""Deprecated module for 'zntrack.dvc.<option>' fields.'.
+
+All relevant code has been moved to 'zntrack.fields.dvc.options'
+"""
+
 
 import typing_extensions as tyex
-import znjson
-
-from zntrack.fields.field import Field, FieldGroup, PlotsMixin
-from zntrack.utils import node_wd
-
-if typing.TYPE_CHECKING:
-    from zntrack import Node
-
-
-class DVCOption(Field):
-    """A field that is used as a dvc option.
-
-    The DVCOption field is designed for paths only.
-    """
-
-    group = FieldGroup.PARAMETER
-
-    def __init__(self, *args, **kwargs):
-        """Create a DVCOption field."""
-        if node_wd.nwd in args or node_wd.nwd in kwargs.values():
-            raise ValueError(
-                "Can not set `zntrack.nwd` as value for {self}. Please use"
-                " `zntrack.nwd/...` to create a path relative to the node working"
-                " directory."
-            )
-        self.dvc_option = kwargs.pop("dvc_option")
-        super().__init__(*args, **kwargs)
-
-    def get_files(self, instance: "Node") -> list:
-        """Get the files affected by this field.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance to get the files for.
-
-        Returns
-        -------
-        list of str
-            A list of file paths affected by this field.
-
-        """
-        value = getattr(instance, self.name)
-        if not isinstance(value, list):
-            value = [value]
-        return [pathlib.Path(file).as_posix() for file in value if file is not None]
-
-    def get_stage_add_argument(self, instance: "Node") -> typing.List[tuple]:
-        """Get the dvc command for this field.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance to get the command for.
-
-        Returns
-        -------
-        list of tuple of str
-            A list of command-line arguments to use when adding
-            this field to the DVC stage.
-
-        """
-        if self.dvc_option == "params":
-            return [
-                (f"--{self.dvc_option}", f"{file}:") for file in self.get_files(instance)
-            ]
-        else:
-            return [(f"--{self.dvc_option}", file) for file in self.get_files(instance)]
-
-    def get_data(self, instance: "Node") -> any:
-        """Get the value of the field from the configuration file.
-
-        Parameters
-        ----------
-        instance : Node
-            The Node instance to get the field value for.
-        decoder : Any, optional
-            The decoder to use when parsing the configuration file, by default None.
-
-        Returns
-        -------
-        any
-            The value of the field from the configuration file.
-        """
-        zntrack_dict = json.loads(
-            instance.state.fs.read_text("zntrack.json"),
-        )
-        return json.loads(
-            json.dumps(zntrack_dict[instance.name][self.name]), cls=znjson.ZnDecoder
-        )
-
-    def save(self, instance: "Node"):
-        """Save the field to config file.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance to save the field for.
-
-        """
-        try:
-            value = instance.__dict__[self.name]
-        except KeyError:
-            try:
-                # default value is not stored in __dict__
-                # TODO: not sure if I like this
-                value = getattr(instance, self.name)
-            except AttributeError:
-                return
-        self._write_value_to_config(value, instance, encoder=znjson.ZnEncoder)
-
-    def __get__(self, instance: "Node", owner=None):
-        """Add replacement of the nwd to the get method.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance to get the value for.
-        owner : type, optional
-            The owner class of the descriptor, by default None
-
-        Returns
-        -------
-        Any
-            The value of the attribute.
-
-        """
-        if instance is None:
-            return self
-        value = super().__get__(instance, owner)
-        return node_wd.ReplaceNWD()(value, nwd=instance.nwd)
-
-
-class PlotsOption(PlotsMixin, DVCOption):
-    """Field with DVC plots kwargs."""
+
+from zntrack.fields import fields
+from zntrack.fields.dvc.options import DVCOption
 
 
 @tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs(*args, **kwargs) -> DVCOption:
     """Create a outs field."""
-    return DVCOption(*args, dvc_option="outs", **kwargs)
+    return fields.outs_path(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.params_path' instead.")
 def params(*args, **kwargs) -> DVCOption:
     """Create a params field."""
-    return DVCOption(*args, dvc_option="params", **kwargs)
+    return fields.params_path(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.deps_path' instead.")
 def deps(*args, **kwargs) -> DVCOption:
     """Create a deps field."""
-    return DVCOption(*args, dvc_option="deps", **kwargs)
+    return fields.deps_path(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs_no_cache(*args, **kwargs) -> DVCOption:
     """Create a outs_no_cache field."""
-    return DVCOption(*args, dvc_option="outs-no-cache", **kwargs)
+    return fields.outs_path(*args, dvc_option="outs-no-cache", **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.outs_path' instead.")
 def outs_persistent(*args, **kwargs) -> DVCOption:
     """Create a outs_persistent field."""
-    return DVCOption(*args, dvc_option="outs-persistent", **kwargs)
+    return fields.outs_path(*args, dvc_option="outs-persistent", **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.metrics_path' instead.")
 def metrics(*args, **kwargs) -> DVCOption:
     """Create a metrics field."""
-    return DVCOption(*args, dvc_option="metrics", **kwargs)
+    return fields.metrics_path(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.metrics_path' instead.")
 def metrics_no_cache(*args, **kwargs) -> DVCOption:
     """Create a metrics_no_cache field."""
-    return DVCOption(*args, dvc_option="metrics-no-cache", **kwargs)
+    return fields.metrics_path(*args, dvc_option="metrics-no-cache", **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.plots_path' instead.")
 def plots(*args, **kwargs) -> DVCOption:
     """Create a plots field."""
-    return PlotsOption(*args, dvc_option="plots", **kwargs)
+    return fields.plots_path(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.plots_path' instead.")
 def plots_no_cache(*args, **kwargs) -> DVCOption:
     """Create a plots_no_cache field."""
-    return PlotsOption(*args, dvc_option="plots-no-cache", **kwargs)
+    return fields.plots_path(*args, dvc_option="plots-no-cache", **kwargs)
diff --git a/zntrack/fields/dvc/options.py b/zntrack/fields/dvc/options.py
new file mode 100644
index 00000000..8e985a0d
--- /dev/null
+++ b/zntrack/fields/dvc/options.py
@@ -0,0 +1,141 @@
+"""Base classes for 'zntrack.<field>_path' fields."""
+
+import json
+import pathlib
+import typing
+
+import znjson
+
+from zntrack.fields.field import Field, FieldGroup, PlotsMixin
+from zntrack.utils import node_wd
+
+if typing.TYPE_CHECKING:
+    from zntrack import Node
+
+
+class DVCOption(Field):
+    """A field that is used as a dvc option.
+
+    The DVCOption field is designed for paths only.
+    """
+
+    group = FieldGroup.PARAMETER
+
+    def __init__(self, *args, **kwargs):
+        """Create a DVCOption field."""
+        if node_wd.nwd in args or node_wd.nwd in kwargs.values():
+            raise ValueError(
+                "Can not set `zntrack.nwd` as value for {self}. Please use"
+                " `zntrack.nwd/...` to create a path relative to the node working"
+                " directory."
+            )
+        self.dvc_option = kwargs.pop("dvc_option")
+        super().__init__(*args, **kwargs)
+
+    def get_files(self, instance: "Node") -> list:
+        """Get the files affected by this field.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance to get the files for.
+
+        Returns
+        -------
+        list of str
+            A list of file paths affected by this field.
+
+        """
+        value = getattr(instance, self.name)
+        if not isinstance(value, list):
+            value = [value]
+        return [pathlib.Path(file).as_posix() for file in value if file is not None]
+
+    def get_stage_add_argument(self, instance: "Node") -> typing.List[tuple]:
+        """Get the dvc command for this field.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance to get the command for.
+
+        Returns
+        -------
+        list of tuple of str
+            A list of command-line arguments to use when adding
+            this field to the DVC stage.
+
+        """
+        if self.dvc_option == "params":
+            return [
+                (f"--{self.dvc_option}", f"{file}:") for file in self.get_files(instance)
+            ]
+        else:
+            return [(f"--{self.dvc_option}", file) for file in self.get_files(instance)]
+
+    def get_data(self, instance: "Node") -> any:
+        """Get the value of the field from the configuration file.
+
+        Parameters
+        ----------
+        instance : Node
+            The Node instance to get the field value for.
+        decoder : Any, optional
+            The decoder to use when parsing the configuration file, by default None.
+
+        Returns
+        -------
+        any
+            The value of the field from the configuration file.
+        """
+        zntrack_dict = json.loads(
+            instance.state.fs.read_text("zntrack.json"),
+        )
+        return json.loads(
+            json.dumps(zntrack_dict[instance.name][self.name]), cls=znjson.ZnDecoder
+        )
+
+    def save(self, instance: "Node"):
+        """Save the field to config file.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance to save the field for.
+
+        """
+        try:
+            value = instance.__dict__[self.name]
+        except KeyError:
+            try:
+                # default value is not stored in __dict__
+                # TODO: not sure if I like this
+                value = getattr(instance, self.name)
+            except AttributeError:
+                return
+        self._write_value_to_config(value, instance, encoder=znjson.ZnEncoder)
+
+    def __get__(self, instance: "Node", owner=None):
+        """Add replacement of the nwd to the get method.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance to get the value for.
+        owner : type, optional
+            The owner class of the descriptor, by default None
+
+        Returns
+        -------
+        Any
+            The value of the attribute.
+
+        """
+        if instance is None:
+            return self
+        value = super().__get__(instance, owner)
+        return node_wd.ReplaceNWD()(value, nwd=instance.nwd)
+
+
+class PlotsOption(PlotsMixin, DVCOption):
+    """Field with DVC plots kwargs."""
diff --git a/zntrack/fields/fields.py b/zntrack/fields/fields.py
index 19d92e2e..6d35a9f1 100644
--- a/zntrack/fields/fields.py
+++ b/zntrack/fields/fields.py
@@ -1,6 +1,7 @@
 """Fields that are used to define Nodes."""
-from zntrack.fields import dvc, zn
 from zntrack.fields.dependency import Dependency
+from zntrack.fields.dvc.options import DVCOption, PlotsOption
+from zntrack.fields.zn.options import Output, Params, Plots
 
 # Serialized Fields
 
@@ -16,7 +17,7 @@ def outs():
             and stored in the node working directory.
             see https://dvc.org/doc/command-reference/stage/add#-o
     """
-    return zn.outs()
+    return Output(dvc_option="outs", use_repr=False)
 
 
 def metrics():
@@ -31,22 +32,24 @@ def metrics():
             see https://dvc.org/doc/command-reference/stage/add#-M
 
     """
-    return zn.metrics()
+    return Output(dvc_option="metrics-no-cache")
 
 
-def params(*data):
+def params(*args, **kwargs):
     """Define a Node Parameter.
 
     Parameters
     ----------
-    data: any
+    args: any
         A data object that is used as a parameter.
         Typically, this should be a string or number.
         The object is serialized and deserialized by ZnTrack
         and stored in params.yaml.
         see https://dvc.org/doc/command-reference/stage/add#-p
+    kwargs: dict
+        Additional keyword arguments.
     """
-    return zn.params(*data)
+    return Params(*args, **kwargs)
 
 
 def deps(*data):
@@ -63,12 +66,12 @@ def deps(*data):
     return Dependency(*data)
 
 
-def plots(*data, **kwargs):
+def plots(*args, **kwargs):
     """Define a Node Plot.
 
     Parameters
     ----------
-    data: pd.DataFrame
+    args: pd.DataFrame
         A pandas DataFrame that is used as a plot.
         The object is serialized and deserialized by ZnTrack
         and stored in the node working directory.
@@ -77,73 +80,87 @@ def plots(*data, **kwargs):
         Additional keyword arguments that are used for plotting.
 
     """
-    return zn.plots(*data, **kwargs)
+    return Plots(*args, **kwargs)
 
 
 # Path Fields
 
 
-def outs_path(*path):
+def outs_path(*args, dvc_option="outs", **kwargs):
     """Define a Node Output.
 
     Parameters
     ----------
-    path: str|Path
+    args: str|Path
         A file or directory that is generated by the Node.
         see https://dvc.org/doc/command-reference/stage/add#-o
+    dvc_option: str, default="outs"
+        The DVC option to use for this field.
+    kwargs: dict
+        Additional keyword arguments.
 
     """
-    return dvc.outs(*path)
+    return DVCOption(*args, dvc_option=dvc_option, **kwargs)
 
 
-def metrics_path(*path):
+def metrics_path(*args, dvc_option="metrics", **kwargs):
     """Define a Node Metric.
 
     Parameters
     ----------
-    path : str|Path
+    args : str|Path
         A file that is used by DVC as a metric, such as *.json
         see https://dvc.org/doc/command-reference/stage/add#-M
+    dvc_option: str, default="metrics"
+        The DVC option to use for this field.
+    kwargs: dict
+        Additional keyword arguments.
 
     """
-    return dvc.metrics(*path)
+    return DVCOption(*args, dvc_option=dvc_option, **kwargs)
 
 
-def params_path(*path):
+def params_path(*args, **kwargs):
     """Define a Node Parameter.
 
     Parameters
     ----------
-    path : str|Path
+    args : str|Path
         A file that is used by DVC for reading parameters.
         This includes typically json or yaml files.
         see https://dvc.org/doc/command-reference/stage/add#-p
+    kwargs: dict
+        Additional keyword arguments.
     """
-    return dvc.params(*path)
+    return DVCOption(*args, dvc_option="params", **kwargs)
 
 
-def deps_path(*path):
+def deps_path(*args, **kwargs):
     """Define a Node Dependency.
 
     Parameters
     ----------
-    path : str|Path
+    args : str|Path
         A file or directory that is defined as a dependency to the Node.
         see https://dvc.org/doc/command-reference/stage/add#-d
+    kwargs: dict
+        Additional keyword arguments.
 
     """
-    return dvc.deps(*path)
+    return DVCOption(*args, dvc_option="deps", **kwargs)
 
 
-def plots_path(*path, **kwargs):
+def plots_path(*args, dvc_option="plots", **kwargs):
     """Define a Node Plot.
 
     Parameters
     ----------
-    path : str|Path
+    args : str|Path
         A file or directory that is defined as a plot to the Node.
         see https://dvc.org/doc/command-reference/stage/add#--plots
+    dvc_option: str, default="plots"
+        The DVC option to use for this field.
     kwargs: dict
         Additional keyword arguments that are used for plotting.
     """
-    return dvc.plots(*path, **kwargs)
+    return PlotsOption(*args, dvc_option=dvc_option, **kwargs)
diff --git a/zntrack/fields/zn/__init__.py b/zntrack/fields/zn/__init__.py
index f1a3dae2..db0bed77 100644
--- a/zntrack/fields/zn/__init__.py
+++ b/zntrack/fields/zn/__init__.py
@@ -1,603 +1,44 @@
-"""Field with automatic serialization and deserialization."""
-import dataclasses
-import json
-import logging
-import pathlib
-import typing
+"""Deprecated module for 'zntrack.zn.<option>' fields.'.
 
-import pandas as pd
-import typing_extensions as tyex
-import yaml
-import znflow
-import znflow.utils
-import zninit
-import znjson
-from znflow import handler
-
-from zntrack import exceptions
-from zntrack.fields.field import (
-    DataIsLazyError,
-    Field,
-    FieldGroup,
-    LazyField,
-    PlotsMixin,
-)
-from zntrack.utils import config, module_handler, update_key_val
-
-if typing.TYPE_CHECKING:
-    from zntrack import Node
-log = logging.getLogger(__name__)
-
-
-class ConnectionConverter(znjson.ConverterBase):
-    """Convert a znflow.Connection object to dict and back."""
-
-    level = 100
-    representation = "znflow.Connection"
-    instance = znflow.Connection
-
-    def encode(self, obj: znflow.Connection) -> dict:
-        """Convert the znflow.Connection object to dict."""
-        if obj.item is not None:
-            raise NotImplementedError("znflow.Connection getitem is not supported yet.")
-        return dataclasses.asdict(obj)
-
-    def decode(self, value: str) -> znflow.Connection:
-        """Create znflow.Connection object from dict."""
-        return znflow.Connection(**value)
-
-
-class CombinedConnectionsConverter(znjson.ConverterBase):
-    """Convert a znflow.Connection object to dict and back."""
-
-    level = 100
-    representation = "znflow.CombinedConnections"
-    instance = znflow.CombinedConnections
-
-    def encode(self, obj: znflow.CombinedConnections) -> dict:
-        """Convert the znflow.Connection object to dict."""
-        if obj.item is not None:
-            raise NotImplementedError(
-                "znflow.CombinedConnections getitem is not supported yet."
-            )
-        return dataclasses.asdict(obj)
-
-    def decode(self, value: str) -> znflow.CombinedConnections:
-        """Create znflow.Connection object from dict."""
-        connections = []
-        for item in value["connections"]:
-            if isinstance(item, dict):
-                # @nodify functions aren't support as 'zn.deps'
-                # Nodes directly aren't supported because they aren't lists
-                connections.append(znflow.Connection(**item))
-            else:
-                # For the case that item is already a znflow.Connection
-                connections.append(item)
-        value["connections"] = connections
-        return znflow.CombinedConnections(**value)
-
-
-class SliceConverter(znjson.ConverterBase):
-    """Convert a znflow.Connection object to dict and back."""
-
-    level = 100
-    representation = "slice"
-    instance = slice
-
-    def encode(self, obj: slice) -> dict:
-        """Convert the znflow.Connection object to dict."""
-        return {"start": obj.start, "stop": obj.stop, "step": obj.step}
-
-    def decode(self, value: dict) -> znflow.Connection:
-        """Create znflow.Connection object from dict."""
-        return slice(value["start"], value["stop"], value["step"])
-
-
-znjson.config.register(SliceConverter)
-
-
-class Params(Field):
-    """A parameter field.
-
-    Parameters
-    ----------
-    dvc_option: str
-        The DVC option to use. Default is "params".
-    """
-
-    dvc_option: str = "params"
-    group = FieldGroup.PARAMETER
-
-    def get_files(self, instance: "Node") -> list:
-        """Get the list of files affected by this field.
-
-        Returns
-        -------
-        list
-            A list of file paths.
-        """
-        return [config.files.params]
-
-    def save(self, instance: "Node"):
-        """Save the field to disk.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance associated with this field.
-        """
-        file = self.get_files(instance)[0]
-
-        try:
-            params_dict = yaml.safe_load(pathlib.Path(file).read_text())
-        except FileNotFoundError:
-            params_dict = {instance.name: {}}
-
-        if instance.name not in params_dict:
-            params_dict[instance.name] = {}
-
-        params_dict[instance.name][self.name] = getattr(instance, self.name)
-        params_dict = json.loads(json.dumps(params_dict, cls=znjson.ZnEncoder))
-
-        with open(file, "w") as f:
-            yaml.safe_dump(params_dict, f, indent=4)
-
-    def get_data(self, instance: "Node") -> any:
-        """Get the value of the field from the file."""
-        file = self.get_files(instance)[0]
-        params_dict = yaml.safe_load(instance.state.fs.read_text(file))
-        value = params_dict[instance.name][self.name]
-        return json.loads(json.dumps(value), cls=znjson.ZnDecoder)
-
-    def get_stage_add_argument(self, instance: "Node") -> typing.List[tuple]:
-        """Get the DVC stage add argument for this field.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance associated with this field.
-
-        Returns
-        -------
-        list
-            A list of tuples containing the DVC option and the file path.
-        """
-        file = self.get_files(instance)[0]
-        return [(f"--{self.dvc_option}", f"{file}:{instance.name}")]
-
-
-class Output(LazyField):
-    """A field that is saved to disk."""
-
-    group = FieldGroup.RESULT
-
-    def __init__(self, dvc_option: str, **kwargs):
-        """Create a new Output field.
-
-        Parameters
-        ----------
-        dvc_option : str
-            The DVC option used to specify the output file.
-        **kwargs
-            Additional arguments to pass to the parent constructor.
-        """
-        self.dvc_option = dvc_option
-        super().__init__(**kwargs)
-
-    def get_files(self, instance) -> list:
-        """Get the path of the file in the node directory.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance.
-
-        Returns
-        -------
-        list
-            A list containing the path of the file.
-        """
-        return [instance.nwd / f"{self.name}.json"]
-
-    def save(self, instance: "Node"):
-        """Save the field to disk.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance.
-        """
-        try:
-            value = self.get_value_except_lazy(instance)
-        except DataIsLazyError:
-            return
-
-        instance.nwd.mkdir(exist_ok=True, parents=True)
-        file = self.get_files(instance)[0]
-        file.write_text(json.dumps(value, cls=znjson.ZnEncoder, indent=4))
-
-    def get_data(self, instance: "Node") -> any:
-        """Get the value of the field from the file."""
-        file = self.get_files(instance)[0]
-        return json.loads(
-            instance.state.fs.read_text(file.as_posix()),
-            cls=znjson.ZnDecoder,
-        )
-
-    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
-        """Get the DVC command for this field.
-
-        Parameters
-        ----------
-        instance : Node
-            The node instance.
-
-        Returns
-        -------
-        list
-            A list containing the DVC command for this field.
-        """
-        file = self.get_files(instance)[0]
-        return [(f"--{self.dvc_option}", file.as_posix())]
-
-
-class Plots(PlotsMixin, LazyField):
-    """A field that is saved to disk."""
-
-    dvc_option: str = "plots"
-    group = FieldGroup.RESULT
-
-    def get_files(self, instance) -> list:
-        """Get the path of the file in the node directory."""
-        return [instance.nwd / f"{self.name}.csv"]
+All relevant code has been moved to 'zntrack.fields.zn.options'
+"""
 
-    def save(self, instance: "Node"):
-        """Save the field to disk."""
-        super().save(instance)
-        try:
-            value = self.get_value_except_lazy(instance)
-        except DataIsLazyError:
-            return
-        if value is None:
-            return
-
-        instance.nwd.mkdir(exist_ok=True, parents=True)
-        file = self.get_files(instance)[0]
-        value.to_csv(file)
-
-    def get_data(self, instance: "Node") -> any:
-        """Get the value of the field from the file."""
-        file = self.get_files(instance)[0]
-        return pd.read_csv(instance.state.fs.open(file.as_posix()), index_col=0)
-
-    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
-        """Get the dvc command for this field."""
-        file = self.get_files(instance)[0]
-        return [(f"--{self.dvc_option}", file.as_posix())]
-
-
-_default = object()
-
-
-def _get_all_connections_and_instances(value) -> list["Node"]:
-    """Get Nodes from Connections and CombinedConnections."""
-    connections = []
-    stack = [value]
-    while stack:
-        node = stack.pop()
-        if isinstance(node, znflow.CombinedConnections):
-            stack.extend(node.connections)
-        elif isinstance(node, znflow.Connection):
-            instance = node.instance
-            while isinstance(instance, znflow.Connection):
-                instance = instance.instance
-            connections.append(instance)
-    return connections
-
-
-class Dependency(LazyField):
-    """A dependency field."""
-
-    dvc_option = "deps"
-    group = FieldGroup.PARAMETER
-
-    def __init__(self, default=_default):
-        """Create a new dependency field.
-
-        A `zn.deps` does not support default values.
-        To build a dependency graph, the values must be passed at runtime.
-        """
-        if default is _default:
-            super().__init__()
-        elif default is None:
-            super().__init__(default=default)
-        else:
-            raise ValueError(
-                "A dependency field does not support default dependencies. You can only"
-                " use 'None' to declare this an optional dependency"
-                f"and not {default}."
-            )
-
-    def get_files(self, instance) -> list:
-        """Get the affected files of the respective Nodes."""
-        files = []
-
-        value = getattr(instance, self.name)
-        # TODO use IterableHandler?
-
-        if isinstance(value, dict):
-            value = list(value.values())
-        if not isinstance(value, (list, tuple)):
-            value = [value]
-        if isinstance(value, tuple):
-            value = list(value)
-
-        others = []
-        for node in value:
-            if isinstance(node, (znflow.CombinedConnections, znflow.Connection)):
-                others.extend(_get_all_connections_and_instances(node))
-            else:
-                others.append(node)
-
-        value = others
-
-        for node in value:
-            node: Node
-            if node is None:
-                continue
-            if node._external_:
-                from zntrack.utils import run_dvc_cmd
-
-                # TODO save these files in a specific directory called `external`
-                # TODO the `dvc import cmd` should not run here but rather be a stage?
-
-                deps_file = pathlib.Path("external", f"{node.uuid}.json")
-                deps_file.parent.mkdir(exist_ok=True, parents=True)
-
-                # zntrack run node.name --external \
-                # --remote node.state.remote --rev node.state.rev
-
-                # when combining with zn.nodes this should be used
-                # dvc stage add <name> --params params.yaml:<name>
-                # --outs nodes/<name>/node-meta.json zntrack run <name> --external
-
-                cmd = [
-                    "import",
-                    node.state.remote if node.state.remote is not None else ".",
-                    (node.nwd / "node-meta.json").as_posix(),
-                    "-o",
-                    deps_file.as_posix(),
-                ]
-                if node.state.rev is not None:
-                    cmd.extend(["--rev", node.state.rev])
-                # TODO how can we test, that the loaded file truly is the correct one?
-                if not deps_file.exists():
-                    run_dvc_cmd(cmd)
-                files.append(deps_file.as_posix())
-                # dvc import node-meta.json + add as dependency file
-                continue
-            # if node.state.rev is not None or node.state.remote is not None:
-            #     # TODO if the Node has a `rev` or `remote` attribute, we need to
-            #     #  get the UUID file of the respective Node through node.state.fs.open
-            #     # save that somewhere (can't use NWD, because we can now have multiple
-            #     # nodes with the same name...)
-            #     # and make the uuid a dependency of the node.
-            #     continue
-            files.append(node.nwd / "node-meta.json")
-            for field in zninit.get_descriptors(Field, self=node):
-                if field.dvc_option in ["params", "deps"]:
-                    # We do not want to depend on parameter files or
-                    # recursively on dependencies.
-                    continue
-                files.extend(field.get_files(node))
-                log.debug(f"Found field {field} and extended files to {files}")
-        return files
-
-    def save(self, instance: "Node"):
-        """Save the field to disk."""
-        try:
-            value = self.get_value_except_lazy(instance)
-        except DataIsLazyError:
-            return
-
-        self._write_value_to_config(
-            value,
-            instance,
-            encoder=znjson.ZnEncoder.from_converters(
-                [ConnectionConverter, CombinedConnectionsConverter], add_default=True
-            ),
-        )
-
-    def get_data(self, instance: "Node") -> any:
-        """Get the value of the field from the file."""
-        zntrack_dict = json.loads(
-            instance.state.fs.read_text(config.files.zntrack),
-        )
-        value = zntrack_dict[instance.name][self.name]
-
-        value = update_key_val(value, instance=instance)
-
-        value = json.loads(
-            json.dumps(value),
-            cls=znjson.ZnDecoder.from_converters(
-                [ConnectionConverter, CombinedConnectionsConverter], add_default=True
-            ),
-        )
-
-        # Up until here we have connection objects. Now we need
-        # to resolve them to Nodes. The Nodes, as in 'connection.instance'
-        #  are already loaded by the ZnDecoder.
-        return handler.UpdateConnectors()(value)
-
-    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
-        """Get the dvc command for this field."""
-        return [
-            (f"--{self.dvc_option}", pathlib.Path(file).as_posix())
-            for file in self.get_files(instance)
-        ]
-
-
-class _SaveNodes(znflow.utils.IterableHandler):
-    def default(self, value, **kwargs):
-        name = kwargs["name"]
-        if isinstance(value, znflow.Node):
-            value.name = name
-            value.save(results=False)
-        return value
-
-
-class NodeField(Dependency):
-    """Add another Node as a field.
-
-    The other Node will provide its parameters and methods to be used.
-    From a graph standpoint, it will add these parameters and methods to the Node
-    it is attached to.
-    The Node will not execute its run method or save any results to disk.
-    """
-
-    def __set__(self, instance, value):
-        """Disable the _graph_ in the value 'Node'."""
-        if value is None:
-            return super().__set__(instance, value)
-
-        for entry in value if isinstance(value, (list, tuple)) else [value]:
-            if hasattr(entry, "_graph_"):
-                entry._graph_ = None
-                if entry.uuid in instance._graph_:
-                    raise exceptions.ZnNodesOnGraphError(
-                        node=entry, field=self, instance=instance
-                    )
-            else:
-                raise TypeError(f"The value must be a Node and not {entry}.")
-        return super().__set__(instance, value)
-
-    def get_node_names(self, instance) -> list:
-        """Get the name of the other Node."""
-        try:
-            value = self.get_value_except_lazy(instance)
-        except DataIsLazyError:
-            return []
-
-        if value is None:  # the zn.nodes(None) case
-            return []
-        if isinstance(value, (list, tuple)):
-            return [f"{instance.name}_{self.name}_{idx}" for idx in range(len(value))]
-        return [f"{instance.name}_{self.name}"]
-
-    def save(self, instance: "Node"):
-        """Save the Node parameters to disk."""
-        try:
-            value = self.get_value_except_lazy(instance)
-        except DataIsLazyError:
-            return
-
-        if value is not None:
-            if not isinstance(value, (list, tuple)):
-                value = [value]
-
-            for node, name in zip(value, self.get_node_names(instance)):
-                _SaveNodes()(node, name=name)
-        super().save(instance)
-
-    def _get_nwd(self, instance: "Node", name: str) -> pathlib.Path:
-        """Get the node working directory."""
-        # get the name of the parent directory as string
-        # e.g. we have nodes/AL_0/AL_0_ASEMD_checker_list_0
-        # but want nodes/AL_0/ASEMD_checker_list_0
-        if name.startswith(instance.nwd.parent.name):
-            return instance.nwd.parent / name[len(instance.nwd.parent.name) + 1 :]
-        else:
-            return instance.nwd.parent / name
-
-    def get_optional_dvc_cmd(
-        self, instance: "Node", git_only_repo: bool
-    ) -> typing.List[list]:
-        """Get the dvc command for this field."""
-        nodes = getattr(instance, self.name)
-        if nodes is None:
-            return []
-
-        names = self.get_node_names(instance)
-        if not isinstance(nodes, (list, tuple)):
-            nodes = [nodes]
-
-        cmd = []
-
-        for node, name in zip(nodes, names):
-            if not isinstance(node, znflow.Node):
-                raise TypeError(f"The value must be a Node and not {node}.")
-            node.name = name
-            module = module_handler(node.__class__)
-
-            nwd = self._get_nwd(instance, name)
-            node.__dict__["nwd"] = nwd
-
-            _cmd = [
-                "stage",
-                "add",
-                "--name",
-                name,
-                "--force",
-                "--metrics-no-cache" if git_only_repo else "--outs",
-                (nwd / "node-meta.json").as_posix(),  # HOW DO I MOVE THIS TO GROUP ?
-                "--params",
-                f"{config.files.zntrack}:{instance.name}.{self.name}",
-            ]
-            field_cmds = []
-            for attr in zninit.get_descriptors(Params, self=node):
-                field_cmds += attr.get_stage_add_argument(node)
-
-            for field_cmd in set(field_cmds):
-                _cmd += list(field_cmd)
-
-            _cmd += [
-                f"zntrack run {module}.{node.__class__.__name__} --name"
-                f" {name} --meta-only"
-            ]
-
-            cmd.append(_cmd)
-
-        return cmd
+import typing_extensions as tyex
 
-    def get_files(self, instance: "Node") -> list:
-        """Get the files affected by this field."""
-        return [
-            self._get_nwd(instance, name) / "node-meta.json"
-            for name in self.get_node_names(instance)
-        ]
+from zntrack.fields import fields
 
 
 @tyex.deprecated("Use 'zntrack.params' instead.")
-def params(*args, **kwargs) -> Params:
+def params(*args, **kwargs):
     """Create a params field."""
-    return Params(*args, **kwargs)
+    return fields.params(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.deps' instead.")
-def deps(*args, **kwargs) -> Dependency:
+def deps(*args, **kwargs):
     """Create a dependency field."""
-    return Dependency(*args, **kwargs)
+    return fields.deps(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.outs' instead.")
-def outs() -> Output:
+def outs():
     """Create an output field."""
-    return Output(dvc_option="outs", use_repr=False)
+    return fields.outs()
 
 
 @tyex.deprecated("Use 'zntrack.metrics' instead.")
-def metrics() -> Output:
+def metrics():
     """Create a metrics output field."""
-    return Output(dvc_option="metrics-no-cache")
+    return fields.metrics()
 
 
 @tyex.deprecated("Use 'zntrack.plots' instead.")
-def plots(*args, **kwargs) -> Plots:
+def plots(*args, **kwargs):
     """Create a metrics output field."""
-    return Plots(*args, **kwargs)
+    return fields.plots(*args, **kwargs)
 
 
 @tyex.deprecated("Use 'zntrack.deps' instead.")
-def nodes(*args, **kwargs) -> NodeField:
+def nodes(*args, **kwargs):
     """Create a node field."""
-    return NodeField(*args, **kwargs)
+    return fields.deps(*args, **kwargs)
diff --git a/zntrack/fields/zn/options.py b/zntrack/fields/zn/options.py
new file mode 100644
index 00000000..94c299c4
--- /dev/null
+++ b/zntrack/fields/zn/options.py
@@ -0,0 +1,567 @@
+"""Base classes for 'zntrack.<field>' fields."""
+
+import dataclasses
+import json
+import logging
+import pathlib
+import typing
+
+import pandas as pd
+import yaml
+import znflow
+import znflow.utils
+import zninit
+import znjson
+from znflow import handler
+
+from zntrack import exceptions
+from zntrack.fields.field import (
+    DataIsLazyError,
+    Field,
+    FieldGroup,
+    LazyField,
+    PlotsMixin,
+)
+from zntrack.utils import config, module_handler, update_key_val
+
+if typing.TYPE_CHECKING:
+    from zntrack import Node
+log = logging.getLogger(__name__)
+
+
+class ConnectionConverter(znjson.ConverterBase):
+    """Convert a znflow.Connection object to dict and back."""
+
+    level = 100
+    representation = "znflow.Connection"
+    instance = znflow.Connection
+
+    def encode(self, obj: znflow.Connection) -> dict:
+        """Convert the znflow.Connection object to dict."""
+        if obj.item is not None:
+            raise NotImplementedError("znflow.Connection getitem is not supported yet.")
+        return dataclasses.asdict(obj)
+
+    def decode(self, value: str) -> znflow.Connection:
+        """Create znflow.Connection object from dict."""
+        return znflow.Connection(**value)
+
+
+class CombinedConnectionsConverter(znjson.ConverterBase):
+    """Convert a znflow.Connection object to dict and back."""
+
+    level = 100
+    representation = "znflow.CombinedConnections"
+    instance = znflow.CombinedConnections
+
+    def encode(self, obj: znflow.CombinedConnections) -> dict:
+        """Convert the znflow.Connection object to dict."""
+        if obj.item is not None:
+            raise NotImplementedError(
+                "znflow.CombinedConnections getitem is not supported yet."
+            )
+        return dataclasses.asdict(obj)
+
+    def decode(self, value: str) -> znflow.CombinedConnections:
+        """Create znflow.Connection object from dict."""
+        connections = []
+        for item in value["connections"]:
+            if isinstance(item, dict):
+                # @nodify functions aren't support as 'zn.deps'
+                # Nodes directly aren't supported because they aren't lists
+                connections.append(znflow.Connection(**item))
+            else:
+                # For the case that item is already a znflow.Connection
+                connections.append(item)
+        value["connections"] = connections
+        return znflow.CombinedConnections(**value)
+
+
+class SliceConverter(znjson.ConverterBase):
+    """Convert a znflow.Connection object to dict and back."""
+
+    level = 100
+    representation = "slice"
+    instance = slice
+
+    def encode(self, obj: slice) -> dict:
+        """Convert the znflow.Connection object to dict."""
+        return {"start": obj.start, "stop": obj.stop, "step": obj.step}
+
+    def decode(self, value: dict) -> znflow.Connection:
+        """Create znflow.Connection object from dict."""
+        return slice(value["start"], value["stop"], value["step"])
+
+
+znjson.config.register(SliceConverter)
+
+
+class Params(Field):
+    """A parameter field.
+
+    Parameters
+    ----------
+    dvc_option: str
+        The DVC option to use. Default is "params".
+    """
+
+    dvc_option: str = "params"
+    group = FieldGroup.PARAMETER
+
+    def get_files(self, instance: "Node") -> list:
+        """Get the list of files affected by this field.
+
+        Returns
+        -------
+        list
+            A list of file paths.
+        """
+        return [config.files.params]
+
+    def save(self, instance: "Node"):
+        """Save the field to disk.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance associated with this field.
+        """
+        file = self.get_files(instance)[0]
+
+        try:
+            params_dict = yaml.safe_load(pathlib.Path(file).read_text())
+        except FileNotFoundError:
+            params_dict = {instance.name: {}}
+
+        if instance.name not in params_dict:
+            params_dict[instance.name] = {}
+
+        params_dict[instance.name][self.name] = getattr(instance, self.name)
+        params_dict = json.loads(json.dumps(params_dict, cls=znjson.ZnEncoder))
+
+        with open(file, "w") as f:
+            yaml.safe_dump(params_dict, f, indent=4)
+
+    def get_data(self, instance: "Node") -> any:
+        """Get the value of the field from the file."""
+        file = self.get_files(instance)[0]
+        params_dict = yaml.safe_load(instance.state.fs.read_text(file))
+        value = params_dict[instance.name][self.name]
+        return json.loads(json.dumps(value), cls=znjson.ZnDecoder)
+
+    def get_stage_add_argument(self, instance: "Node") -> typing.List[tuple]:
+        """Get the DVC stage add argument for this field.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance associated with this field.
+
+        Returns
+        -------
+        list
+            A list of tuples containing the DVC option and the file path.
+        """
+        file = self.get_files(instance)[0]
+        return [(f"--{self.dvc_option}", f"{file}:{instance.name}")]
+
+
+class Output(LazyField):
+    """A field that is saved to disk."""
+
+    group = FieldGroup.RESULT
+
+    def __init__(self, dvc_option: str, **kwargs):
+        """Create a new Output field.
+
+        Parameters
+        ----------
+        dvc_option : str
+            The DVC option used to specify the output file.
+        **kwargs
+            Additional arguments to pass to the parent constructor.
+        """
+        self.dvc_option = dvc_option
+        super().__init__(**kwargs)
+
+    def get_files(self, instance) -> list:
+        """Get the path of the file in the node directory.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance.
+
+        Returns
+        -------
+        list
+            A list containing the path of the file.
+        """
+        return [instance.nwd / f"{self.name}.json"]
+
+    def save(self, instance: "Node"):
+        """Save the field to disk.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance.
+        """
+        try:
+            value = self.get_value_except_lazy(instance)
+        except DataIsLazyError:
+            return
+
+        instance.nwd.mkdir(exist_ok=True, parents=True)
+        file = self.get_files(instance)[0]
+        file.write_text(json.dumps(value, cls=znjson.ZnEncoder, indent=4))
+
+    def get_data(self, instance: "Node") -> any:
+        """Get the value of the field from the file."""
+        file = self.get_files(instance)[0]
+        return json.loads(
+            instance.state.fs.read_text(file.as_posix()),
+            cls=znjson.ZnDecoder,
+        )
+
+    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
+        """Get the DVC command for this field.
+
+        Parameters
+        ----------
+        instance : Node
+            The node instance.
+
+        Returns
+        -------
+        list
+            A list containing the DVC command for this field.
+        """
+        file = self.get_files(instance)[0]
+        return [(f"--{self.dvc_option}", file.as_posix())]
+
+
+class Plots(PlotsMixin, LazyField):
+    """A field that is saved to disk."""
+
+    dvc_option: str = "plots"
+    group = FieldGroup.RESULT
+
+    def get_files(self, instance) -> list:
+        """Get the path of the file in the node directory."""
+        return [instance.nwd / f"{self.name}.csv"]
+
+    def save(self, instance: "Node"):
+        """Save the field to disk."""
+        super().save(instance)
+        try:
+            value = self.get_value_except_lazy(instance)
+        except DataIsLazyError:
+            return
+        if value is None:
+            return
+
+        instance.nwd.mkdir(exist_ok=True, parents=True)
+        file = self.get_files(instance)[0]
+        value.to_csv(file)
+
+    def get_data(self, instance: "Node") -> any:
+        """Get the value of the field from the file."""
+        file = self.get_files(instance)[0]
+        return pd.read_csv(instance.state.fs.open(file.as_posix()), index_col=0)
+
+    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
+        """Get the dvc command for this field."""
+        file = self.get_files(instance)[0]
+        return [(f"--{self.dvc_option}", file.as_posix())]
+
+
+_default = object()
+
+
+def _get_all_connections_and_instances(value) -> list["Node"]:
+    """Get Nodes from Connections and CombinedConnections."""
+    connections = []
+    stack = [value]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, znflow.CombinedConnections):
+            stack.extend(node.connections)
+        elif isinstance(node, znflow.Connection):
+            instance = node.instance
+            while isinstance(instance, znflow.Connection):
+                instance = instance.instance
+            connections.append(instance)
+    return connections
+
+
+class Dependency(LazyField):
+    """A dependency field."""
+
+    dvc_option = "deps"
+    group = FieldGroup.PARAMETER
+
+    def __init__(self, default=_default):
+        """Create a new dependency field.
+
+        A `zn.deps` does not support default values.
+        To build a dependency graph, the values must be passed at runtime.
+        """
+        if default is _default:
+            super().__init__()
+        elif default is None:
+            super().__init__(default=default)
+        else:
+            raise ValueError(
+                "A dependency field does not support default dependencies. You can only"
+                " use 'None' to declare this an optional dependency"
+                f"and not {default}."
+            )
+
+    def get_files(self, instance) -> list:
+        """Get the affected files of the respective Nodes."""
+        files = []
+
+        value = getattr(instance, self.name)
+        # TODO use IterableHandler?
+
+        if isinstance(value, dict):
+            value = list(value.values())
+        if not isinstance(value, (list, tuple)):
+            value = [value]
+        if isinstance(value, tuple):
+            value = list(value)
+
+        others = []
+        for node in value:
+            if isinstance(node, (znflow.CombinedConnections, znflow.Connection)):
+                others.extend(_get_all_connections_and_instances(node))
+            else:
+                others.append(node)
+
+        value = others
+
+        for node in value:
+            node: Node
+            if node is None:
+                continue
+            if node._external_:
+                from zntrack.utils import run_dvc_cmd
+
+                # TODO save these files in a specific directory called `external`
+                # TODO the `dvc import cmd` should not run here but rather be a stage?
+
+                deps_file = pathlib.Path("external", f"{node.uuid}.json")
+                deps_file.parent.mkdir(exist_ok=True, parents=True)
+
+                # zntrack run node.name --external \
+                # --remote node.state.remote --rev node.state.rev
+
+                # when combining with zn.nodes this should be used
+                # dvc stage add <name> --params params.yaml:<name>
+                # --outs nodes/<name>/node-meta.json zntrack run <name> --external
+
+                cmd = [
+                    "import",
+                    node.state.remote if node.state.remote is not None else ".",
+                    (node.nwd / "node-meta.json").as_posix(),
+                    "-o",
+                    deps_file.as_posix(),
+                ]
+                if node.state.rev is not None:
+                    cmd.extend(["--rev", node.state.rev])
+                # TODO how can we test, that the loaded file truly is the correct one?
+                if not deps_file.exists():
+                    run_dvc_cmd(cmd)
+                files.append(deps_file.as_posix())
+                # dvc import node-meta.json + add as dependency file
+                continue
+            # if node.state.rev is not None or node.state.remote is not None:
+            #     # TODO if the Node has a `rev` or `remote` attribute, we need to
+            #     #  get the UUID file of the respective Node through node.state.fs.open
+            #     # save that somewhere (can't use NWD, because we can now have multiple
+            #     # nodes with the same name...)
+            #     # and make the uuid a dependency of the node.
+            #     continue
+            files.append(node.nwd / "node-meta.json")
+            for field in zninit.get_descriptors(Field, self=node):
+                if field.dvc_option in ["params", "deps"]:
+                    # We do not want to depend on parameter files or
+                    # recursively on dependencies.
+                    continue
+                files.extend(field.get_files(node))
+                log.debug(f"Found field {field} and extended files to {files}")
+        return files
+
+    def save(self, instance: "Node"):
+        """Save the field to disk."""
+        try:
+            value = self.get_value_except_lazy(instance)
+        except DataIsLazyError:
+            return
+
+        self._write_value_to_config(
+            value,
+            instance,
+            encoder=znjson.ZnEncoder.from_converters(
+                [ConnectionConverter, CombinedConnectionsConverter], add_default=True
+            ),
+        )
+
+    def get_data(self, instance: "Node") -> any:
+        """Get the value of the field from the file."""
+        zntrack_dict = json.loads(
+            instance.state.fs.read_text(config.files.zntrack),
+        )
+        value = zntrack_dict[instance.name][self.name]
+
+        value = update_key_val(value, instance=instance)
+
+        value = json.loads(
+            json.dumps(value),
+            cls=znjson.ZnDecoder.from_converters(
+                [ConnectionConverter, CombinedConnectionsConverter], add_default=True
+            ),
+        )
+
+        # Up until here we have connection objects. Now we need
+        # to resolve them to Nodes. The Nodes, as in 'connection.instance'
+        #  are already loaded by the ZnDecoder.
+        return handler.UpdateConnectors()(value)
+
+    def get_stage_add_argument(self, instance) -> typing.List[tuple]:
+        """Get the dvc command for this field."""
+        return [
+            (f"--{self.dvc_option}", pathlib.Path(file).as_posix())
+            for file in self.get_files(instance)
+        ]
+
+
+class _SaveNodes(znflow.utils.IterableHandler):
+    def default(self, value, **kwargs):
+        name = kwargs["name"]
+        if isinstance(value, znflow.Node):
+            value.name = name
+            value.save(results=False)
+        return value
+
+
+class NodeField(Dependency):
+    """Add another Node as a field.
+
+    The other Node will provide its parameters and methods to be used.
+    From a graph standpoint, it will add these parameters and methods to the Node
+    it is attached to.
+    The Node will not execute its run method or save any results to disk.
+    """
+
+    def __set__(self, instance, value):
+        """Disable the _graph_ in the value 'Node'."""
+        if value is None:
+            return super().__set__(instance, value)
+
+        for entry in value if isinstance(value, (list, tuple)) else [value]:
+            if hasattr(entry, "_graph_"):
+                entry._graph_ = None
+                if entry.uuid in instance._graph_:
+                    raise exceptions.ZnNodesOnGraphError(
+                        node=entry, field=self, instance=instance
+                    )
+            else:
+                raise TypeError(f"The value must be a Node and not {entry}.")
+        return super().__set__(instance, value)
+
+    def get_node_names(self, instance) -> list:
+        """Get the name of the other Node."""
+        try:
+            value = self.get_value_except_lazy(instance)
+        except DataIsLazyError:
+            return []
+
+        if value is None:  # the zn.nodes(None) case
+            return []
+        if isinstance(value, (list, tuple)):
+            return [f"{instance.name}_{self.name}_{idx}" for idx in range(len(value))]
+        return [f"{instance.name}_{self.name}"]
+
+    def save(self, instance: "Node"):
+        """Save the Node parameters to disk."""
+        try:
+            value = self.get_value_except_lazy(instance)
+        except DataIsLazyError:
+            return
+
+        if value is not None:
+            if not isinstance(value, (list, tuple)):
+                value = [value]
+
+            for node, name in zip(value, self.get_node_names(instance)):
+                _SaveNodes()(node, name=name)
+        super().save(instance)
+
+    def _get_nwd(self, instance: "Node", name: str) -> pathlib.Path:
+        """Get the node working directory."""
+        # get the name of the parent directory as string
+        # e.g. we have nodes/AL_0/AL_0_ASEMD_checker_list_0
+        # but want nodes/AL_0/ASEMD_checker_list_0
+        if name.startswith(instance.nwd.parent.name):
+            return instance.nwd.parent / name[len(instance.nwd.parent.name) + 1 :]
+        else:
+            return instance.nwd.parent / name
+
+    def get_optional_dvc_cmd(
+        self, instance: "Node", git_only_repo: bool
+    ) -> typing.List[list]:
+        """Get the dvc command for this field."""
+        nodes = getattr(instance, self.name)
+        if nodes is None:
+            return []
+
+        names = self.get_node_names(instance)
+        if not isinstance(nodes, (list, tuple)):
+            nodes = [nodes]
+
+        cmd = []
+
+        for node, name in zip(nodes, names):
+            if not isinstance(node, znflow.Node):
+                raise TypeError(f"The value must be a Node and not {node}.")
+            node.name = name
+            module = module_handler(node.__class__)
+
+            nwd = self._get_nwd(instance, name)
+            node.__dict__["nwd"] = nwd
+
+            _cmd = [
+                "stage",
+                "add",
+                "--name",
+                name,
+                "--force",
+                "--metrics-no-cache" if git_only_repo else "--outs",
+                (nwd / "node-meta.json").as_posix(),  # HOW DO I MOVE THIS TO GROUP ?
+                "--params",
+                f"{config.files.zntrack}:{instance.name}.{self.name}",
+            ]
+            field_cmds = []
+            for attr in zninit.get_descriptors(Params, self=node):
+                field_cmds += attr.get_stage_add_argument(node)
+
+            for field_cmd in set(field_cmds):
+                _cmd += list(field_cmd)
+
+            _cmd += [
+                f"zntrack run {module}.{node.__class__.__name__} --name"
+                f" {name} --meta-only"
+            ]
+
+            cmd.append(_cmd)
+
+        return cmd
+
+    def get_files(self, instance: "Node") -> list:
+        """Get the files affected by this field."""
+        return [
+            self._get_nwd(instance, name) / "node-meta.json"
+            for name in self.get_node_names(instance)
+        ]

From d0b80f2cea108c7dfb29cb7a2d40870dc679c32f Mon Sep 17 00:00:00 2001
From: PythonFZ <fabian.zills@web.de>
Date: Thu, 21 Sep 2023 18:50:57 +0200
Subject: [PATCH 3/4] bump zntrack version to 0.7.0

---
 pyproject.toml        | 2 +-
 tests/test_zntrack.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 3b0362ce..c2572fb3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ZnTrack"
-version = "0.6.3"
+version = "0.7.0"
 description = "Create, Run and Benchmark DVC Pipelines in Python"
 authors = ["zincwarecode <zincwarecode@gmail.com>"]
 license = "Apache-2.0"
diff --git a/tests/test_zntrack.py b/tests/test_zntrack.py
index 2a4edeb9..a09aac2f 100644
--- a/tests/test_zntrack.py
+++ b/tests/test_zntrack.py
@@ -4,4 +4,4 @@
 
 def test_version():
     """Test 'ZnTrack' version."""
-    assert __version__ == "0.6.3"
+    assert __version__ == "0.7.0"

From ed4b99642ac667b80b812c5b709fd25d72abd126 Mon Sep 17 00:00:00 2001
From: PythonFZ <fabian.zills@web.de>
Date: Thu, 21 Sep 2023 19:23:37 +0200
Subject: [PATCH 4/4] update imports

---
 examples/docs/09_lazy.ipynb | 576 +++---------------------------------
 1 file changed, 38 insertions(+), 538 deletions(-)

diff --git a/examples/docs/09_lazy.ipynb b/examples/docs/09_lazy.ipynb
index 18a7ce85..96afa550 100644
--- a/examples/docs/09_lazy.ipynb
+++ b/examples/docs/09_lazy.ipynb
@@ -20,7 +20,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "nbsphinx": "hidden",
     "tags": []
@@ -48,43 +48,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "nbsphinx": "hidden",
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initialized empty Git repository in /tmp/tmp9xwenc20/.git/\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initialized DVC repository.\n",
-      "\n",
-      "You can now commit the changes to git.\n",
-      "\n",
-      "+---------------------------------------------------------------------+\n",
-      "|                                                                     |\n",
-      "|        DVC has enabled anonymous aggregate usage analytics.         |\n",
-      "|     Read the analytics documentation (and how to opt-out) here:     |\n",
-      "|             <https://dvc.org/doc/user-guide/analytics>              |\n",
-      "|                                                                     |\n",
-      "+---------------------------------------------------------------------+\n",
-      "\n",
-      "What's next?\n",
-      "------------\n",
-      "- Check out the documentation: <https://dvc.org/doc>\n",
-      "- Get help and share ideas: <https://dvc.org/chat>\n",
-      "- Star us on GitHub: <https://github.com/iterative/dvc>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!git init\n",
     "!dvc init"
@@ -99,7 +68,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -120,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -132,7 +101,10 @@
    },
    "outputs": [],
    "source": [
-    "class PrintOption(zntrack.zn.Output):\n",
+    "from zntrack.fields.zn.options import Output\n",
+    "\n",
+    "\n",
+    "class PrintOption(Output):\n",
     "    def __init__(self):\n",
     "        super().__init__(dvc_option=\"outs\", use_repr=False)\n",
     "        # zntrack will try dvc --PrintOption outs.json\n",
@@ -145,7 +117,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -179,7 +151,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -189,46 +161,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name RandomNumber --force ...'\n",
-      "Jupyter support is an experimental feature! Please save your notebook before running this command!\n",
-      "Submit issues to https://github.com/zincware/ZnTrack.\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'repro'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "with zntrack.Project() as project:\n",
     "    random_number = RandomNumber(start=1, stop=1000)\n",
@@ -237,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -261,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -271,18 +204,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "710"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "random_number.number"
    ]
@@ -300,7 +222,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -310,15 +232,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'zntrack.utils.LazyOption'>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "lazy_random_number = RandomNumber.from_rev(lazy=True)\n",
     "print(lazy_random_number.__dict__[\"number\"])"
@@ -337,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -347,18 +261,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "710"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "lazy_random_number.number"
    ]
@@ -376,7 +279,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -398,7 +301,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -408,208 +311,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name RandomNumber --force ...'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000Running DVC command: 'stage add --name AddOne_0 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_1 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_2 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_3 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_4 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_5 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_6 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_7 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_8 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_9 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name AddOne_10 --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'repro'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "with zntrack.Project() as project:\n",
     "    random_number = RandomNumber(start=1, stop=100)\n",
@@ -623,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -633,83 +335,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "+--------------+ \n",
-      "| RandomNumber | \n",
-      "+--------------+ \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_0 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_1 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_2 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_3 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_4 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_5 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_6 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_7 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_8 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +----------+   \n",
-      "  | AddOne_9 |   \n",
-      "  +----------+   \n",
-      "        *        \n",
-      "        *        \n",
-      "        *        \n",
-      "  +-----------+  \n",
-      "  | AddOne_10 |  \n",
-      "  +-----------+  \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!dvc dag"
    ]
@@ -727,7 +353,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -755,7 +381,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -783,7 +409,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -793,25 +419,14 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "36"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "add_one_lazy.deps.deps.deps.deps.deps.deps.deps.number"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -821,18 +436,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "36"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "add_one.deps.deps.deps.deps.deps.deps.deps.number"
    ]
@@ -852,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -862,88 +466,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'stage add --name RandomNumber --force ...'\n",
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'repro'\n",
-      "\u0000Running DVC command: 'stage add --name RandomNumber --force ...'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Running DVC command: 'repro'\n",
-      "\u0000Running DVC command: 'stage add --name RandomNumber --force ...'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000Running DVC command: 'repro'\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u0000"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "with zntrack.Project() as project:\n",
     "    node = RandomNumber(start=0, stop=5000)\n",
@@ -968,7 +491,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -978,15 +501,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "585 == 585 == 585\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# with lazy we get the same number for every run which is not what we expect.\n",
     "print(\n",
@@ -999,7 +514,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -1009,15 +524,7 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1365 != 1783 != 585\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# With lazy=False we get the results we expect.\n",
     "# (Except for some random scenarios, where two random numbers are the same.)\n",
@@ -1035,7 +542,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -1049,13 +556,6 @@
    "source": [
     "temp_dir.cleanup()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {