From 802bb60da5d150fd8948ef4875fd9e740e8162ab Mon Sep 17 00:00:00 2001
From: Fabian Zills <46721498+PythonFZ@users.noreply.github.com>
Date: Wed, 16 Feb 2022 14:12:33 +0100
Subject: [PATCH] change serializer (#231)

* change serializer

* move definition out of __init__

* fix typo

* keep `value` key in `zntrack.json`

* add check for backwards compatibility

* use fixture

* review comments
---
 tests/integration_tests/test_zn_deps.py    |  73 +++++++++
 tests/integration_tests/test_zn_methods.py |  72 ++++++++-
 tests/unit_tests/zn/test_zn_options.py     |  78 +++++++++
 zntrack/utils/__init__.py                  |   2 +
 zntrack/utils/utils.py                     |   5 +
 zntrack/zn/__init__.py                     | 179 +--------------------
 zntrack/zn/method.py                       |  57 +++++++
 zntrack/zn/split_option.py                 | 153 ++++++++++++++++++
 8 files changed, 443 insertions(+), 176 deletions(-)
 create mode 100644 tests/integration_tests/test_zn_deps.py
 create mode 100644 zntrack/zn/method.py
 create mode 100644 zntrack/zn/split_option.py

diff --git a/tests/integration_tests/test_zn_deps.py b/tests/integration_tests/test_zn_deps.py
new file mode 100644
index 00000000..9e90e082
--- /dev/null
+++ b/tests/integration_tests/test_zn_deps.py
@@ -0,0 +1,73 @@
+import json
+import os
+import pathlib
+import shutil
+import subprocess
+
+import pytest
+
+from zntrack import zn
+from zntrack.core.base import Node
+
+
+@pytest.fixture
+def proj_path(tmp_path):
+    shutil.copy(__file__, tmp_path)
+    os.chdir(tmp_path)
+    subprocess.check_call(["git", "init"])
+    subprocess.check_call(["dvc", "init"])
+
+    return tmp_path
+
+
+class FirstNode(Node):
+    outs = zn.outs()
+
+    def run(self):
+        self.outs = 42
+
+
+class LastNode(Node):
+    first_node: FirstNode = zn.deps(FirstNode.load())
+    outs = zn.outs()
+
+    def run(self):
+        self.outs = self.first_node.outs / 2
+
+
+def test_base_run(proj_path):
+    FirstNode().write_graph(run=True)
+    LastNode().write_graph(run=True)
+
+    assert LastNode.load().outs == 21
+
+
+@pytest.fixture()
+def zntrack_dict() -> dict:
+    return {
+        "LastNode": {
+            "first_node": {
+                "_type": "ZnTrackType",
+                "value": {
+                    "cls": "FirstNode",
+                    "module": "test_zn_deps",
+                    "name": "FirstNode",
+                },
+            }
+        }
+    }
+
+
+def test_assert_write_file(proj_path, zntrack_dict):
+    FirstNode().write_graph()
+    LastNode().write_graph()
+
+    zntrack_dict_loaded = json.loads(pathlib.Path("zntrack.json").read_text())
+
+    assert zntrack_dict_loaded == zntrack_dict
+
+
+def test_assert_read_file(proj_path, zntrack_dict):
+    pathlib.Path("zntrack.json").write_text(json.dumps(zntrack_dict))
+
+    assert isinstance(LastNode.load().first_node, FirstNode)
diff --git a/tests/integration_tests/test_zn_methods.py b/tests/integration_tests/test_zn_methods.py
index 81f06e74..9fd90126 100644
--- a/tests/integration_tests/test_zn_methods.py
+++ b/tests/integration_tests/test_zn_methods.py
@@ -125,12 +125,13 @@ def test_created_files(proj_path):
 
     assert zntrack_dict["SingleNode"]["data_class"] == {
         "_type": "zn.method",
-        "value": {
-            "module": "test_zn_methods",
-            "cls": "ExampleMethod",
-        },
+        "value": {"module": "test_zn_methods"},
+    }
+    assert params_dict["SingleNode"]["data_class"] == {
+        "param1": 1,
+        "param2": 2,
+        "_cls": "ExampleMethod",
     }
-    assert params_dict["SingleNode"]["data_class"] == {"param1": 1, "param2": 2}
 
 
 class SingleNodeNoParams(Node):
@@ -162,3 +163,64 @@ def test_write_params_no_kwargs(proj_path):
 
     dvc_dict = yaml.safe_load(pathlib.Path("dvc.yaml").read_text())
     assert dvc_dict["stages"]["SingleNodeNoParams"]["params"] == ["SingleNodeNoParams"]
+
+
+@pytest.fixture()
+def zntrack_params_dict() -> (dict, dict):
+    zntrack_dict = {
+        "SingleNodeNoParams": {
+            "data_class": {"_type": "zn.method", "value": {"module": "test_zn_methods"}}
+        }
+    }
+    params_dict = {
+        "SingleNodeNoParams": {
+            "data_class": {"_cls": "ExampleMethod", "param1": 1, "param2": 2}
+        }
+    }
+    return zntrack_dict, params_dict
+
+
+def test_assert_write_files(proj_path, zntrack_params_dict):
+    """Test the written files (without mocking pathlibs write_text)"""
+    SingleNodeNoParams(data_class=ExampleMethod(1, 2)).write_graph()
+
+    zntrack_dict = json.loads(pathlib.Path("zntrack.json").read_text())
+    params_dict = yaml.safe_load(pathlib.Path("params.yaml").read_text())
+
+    assert zntrack_dict == zntrack_params_dict[0]
+    assert params_dict == zntrack_params_dict[1]
+
+
+def test_assert_read_files(proj_path, zntrack_params_dict):
+    """Test the written files (without mocking pathlibs write_text)"""
+    zntrack_dict, params_dict = zntrack_params_dict
+
+    pathlib.Path("zntrack.json").write_text(json.dumps(zntrack_dict))
+    pathlib.Path("params.yaml").write_text(yaml.safe_dump(params_dict))
+
+    node = SingleNodeNoParams.load()
+    assert node.data_class.param1 == 1
+    assert node.data_class.param2 == 2
+
+
+def test_assert_read_files_old1(proj_path):
+    """Test the written files (without mocking pathlibs write_text)
+
+    Test for versions before https://github.com/zincware/ZnTrack/pull/231
+    """
+    zntrack_dict = {
+        "SingleNodeNoParams": {
+            "data_class": {
+                "_type": "zn.method",
+                "value": {"cls": "ExampleMethod", "module": "test_zn_methods"},
+            }
+        }
+    }
+    params_dict = {"SingleNodeNoParams": {"data_class": {"param1": 1, "param2": 2}}}
+
+    pathlib.Path("zntrack.json").write_text(json.dumps(zntrack_dict))
+    pathlib.Path("params.yaml").write_text(yaml.safe_dump(params_dict))
+
+    node = SingleNodeNoParams.load()
+    assert node.data_class.param1 == 1
+    assert node.data_class.param2 == 2
diff --git a/tests/unit_tests/zn/test_zn_options.py b/tests/unit_tests/zn/test_zn_options.py
index bbc0561d..ce813fcf 100644
--- a/tests/unit_tests/zn/test_zn_options.py
+++ b/tests/unit_tests/zn/test_zn_options.py
@@ -1,4 +1,11 @@
+import dataclasses
+import json
+import pathlib
+
+import znjson
+
 from zntrack import zn
+from zntrack.zn.split_option import combine_values, split_value
 
 
 class ExampleClass:
@@ -30,3 +37,74 @@ def test_zn_plots():
     # test save and load if there is nothing to save or load
     assert ExamplePlots.plots.save(example) is None
     assert ExamplePlots.plots.load(example) is None
+
+
+@dataclasses.dataclass
+class ExampleDataClass:
+    a: int = 5
+    b: int = 7
+
+    # make it a zn.Method
+    znjson_zn_method = True
+
+    def __eq__(self, other):
+        return (other.a == self.a) and (other.b == self.b)
+
+
+def test_split_value():
+    serialized_value = json.loads(json.dumps(ExampleDataClass(), cls=znjson.ZnEncoder))
+
+    params_data, zntrack_data = split_value(serialized_value)
+    assert zntrack_data == {"_type": "zn.method", "value": {"module": "test_zn_options"}}
+    assert params_data == {"_cls": "ExampleDataClass", "a": 5, "b": 7}
+
+    # and now test the same thing but serialize a list
+    serialized_value = json.loads(json.dumps([ExampleDataClass()], cls=znjson.ZnEncoder))
+    params_data, zntrack_data = split_value(serialized_value)
+    assert zntrack_data == [
+        {"_type": "zn.method", "value": {"module": "test_zn_options"}}
+    ]
+    assert params_data == ({"_cls": "ExampleDataClass", "a": 5, "b": 7},)
+
+
+def test_combine_values():
+    zntrack_data = {"_type": "zn.method", "value": {"module": "test_zn_options"}}
+    params_data = {"_cls": "ExampleDataClass", "a": 5, "b": 7}
+
+    assert combine_values(zntrack_data, params_data) == ExampleDataClass()
+
+    # try older data structure
+    zntrack_data = {
+        "_type": "zn.method",
+        "value": {
+            "module": "test_zn_options",
+            "cls": "ExampleDataClass",
+        },
+    }
+    params_data = {"a": 5, "b": 7}
+    assert combine_values(zntrack_data, params_data) == ExampleDataClass()
+
+    # try older data structure
+    zntrack_data = {
+        "_type": "zn.method",
+        "value": {
+            "module": "test_zn_options",
+            "name": "ExampleDataClass",
+        },
+    }
+    params_data = {"a": 5, "b": 7}
+    assert combine_values(zntrack_data, params_data) == ExampleDataClass()
+
+
+def test_split_value_path():
+    path = pathlib.Path("my_path")
+    serialized_value = json.loads(json.dumps(path, cls=znjson.ZnEncoder))
+
+    params_data, zntrack_data = split_value(serialized_value)
+
+    assert params_data == "my_path"
+    assert zntrack_data == {"_type": "pathlib.Path"}
+
+    new_path = combine_values(zntrack_data, params_data)
+    # TODO change order to be consistent with split_values
+    assert new_path == path
diff --git a/zntrack/utils/__init__.py b/zntrack/utils/__init__.py
index c69f493d..383fafb4 100644
--- a/zntrack/utils/__init__.py
+++ b/zntrack/utils/__init__.py
@@ -16,6 +16,7 @@
     cwd_temp_dir,
     decode_dict,
     deprecated,
+    encode_dict,
     get_python_interpreter,
     module_handler,
     module_to_path,
@@ -27,6 +28,7 @@
     "config",
     "cwd_temp_dir",
     "decode_dict",
+    "encode_dict",
     "module_handler",
     "update_nb_name",
     "module_to_path",
diff --git a/zntrack/utils/utils.py b/zntrack/utils/utils.py
index 407139ad..3d637377 100644
--- a/zntrack/utils/utils.py
+++ b/zntrack/utils/utils.py
@@ -78,6 +78,11 @@ def decode_dict(value):
     return json.loads(json.dumps(value), cls=znjson.ZnDecoder)
 
 
+def encode_dict(value) -> dict:
+    """Encode value into a dict serialized with ZnJson"""
+    return json.loads(json.dumps(value, cls=znjson.ZnEncoder))
+
+
 def get_auto_init(fields: typing.List[str]):
     """Automatically create a __init__ based on fields
     Parameters
diff --git a/zntrack/zn/__init__.py b/zntrack/zn/__init__.py
index b7038ecb..a14127bf 100644
--- a/zntrack/zn/__init__.py
+++ b/zntrack/zn/__init__.py
@@ -13,21 +13,22 @@
 see https://dvc.org/doc/command-reference/run#options
 
 """
-import json
 import logging
 
-import znjson
-
 from zntrack import utils
-from zntrack.core.parameter import File, ZnTrackOption
+from zntrack.core.parameter import ZnTrackOption
 from zntrack.descriptor import Metadata
+from zntrack.zn.method import Method
+from zntrack.zn.split_option import SplitZnTrackOption
 
 log = logging.getLogger(__name__)
 
+__all__ = [Method.__name__]
+
 try:
     from .plots import plots
 
-    __all__ = [plots.__name__]
+    __all__ += [plots.__name__]
 except ImportError:
     pass
 
@@ -38,121 +39,6 @@
 # for direct file references use dvc.<option> instead.
 
 
-def split_value(input_val):
-    """Split input_val into data for params.yaml and zntrack.json"""
-    try:
-        # zn.Method
-        params_data = input_val["value"].pop("kwargs")
-    except (AttributeError, TypeError):
-        # everything else
-        params_data = input_val.pop("value")
-    return params_data, input_val
-
-
-def combine_values(cls_dict: dict, params_val):
-    """Combine values from params.yaml and zntrack.json
-
-    Parameters
-    ----------
-    cls_dict: dict
-        loaded from zntrack.json
-    params_val:
-        Parameters from params.yaml
-
-    Returns
-    -------
-    Loaded object of type cls_dict[_type]
-
-    """
-    try:
-        # zn.Method
-        cls_dict["value"]["kwargs"] = params_val
-    except KeyError:
-        # everything else
-        cls_dict["value"] = params_val
-
-    return json.loads(json.dumps(cls_dict), cls=znjson.ZnDecoder)
-
-
-class SplitZnTrackOption(ZnTrackOption):
-    """Method to split a value into params.yaml and zntrack.json
-
-    Serialize data into params.yaml if human-readable and the type in zntrack.json
-    """
-
-    def save(self, instance):
-        """Overwrite the save method
-
-        This save method tries to split the value into params.yaml and zntrack.json.
-        This allows e.g. having pathlib.Path() as a zn.params or a dataclass as zn.Method
-        where the path as string / the dataclass as dict is stored in params.yaml
-        """
-        value = self.__get__(instance, self.owner)
-        serialized_value = json.loads(json.dumps(value, cls=znjson.ZnEncoder))
-
-        try:
-            # if znjson was used to serialize the data, it will have a _type key
-            if isinstance(serialized_value, list):
-                data = [split_value(x) for x in serialized_value]
-                params_data, zntrack_data = zip(*data)
-            else:
-                # Check that correctly serialized
-                _ = serialized_value["_type"]
-                params_data, zntrack_data = split_value(serialized_value)
-
-            # Write to params.yaml
-            utils.file_io.update_config_file(
-                file=utils.Files.params,
-                node_name=instance.node_name,
-                value_name=self.name,
-                value=params_data,
-            )
-
-            # write to zntrack.json
-            utils.file_io.update_config_file(
-                file=utils.Files.zntrack,
-                node_name=instance.node_name,
-                value_name=self.name,
-                value=zntrack_data,
-            )
-        except (KeyError, AttributeError, TypeError):
-            # KeyError if serialized_value is a normal dict
-            # AttributeError when serialized_value.pop does not exist
-            # TypeError <..>
-            super().save(instance)
-
-    def load(self, instance):
-        """Overwrite the load method
-
-        Try to load from zntrack.json / params.yaml in a combined approach first,
-        if no entry in zntrack.json is found, load from params.yaml only without
-        deserializing.
-        """
-        file = self.get_filename(instance)
-
-        try:
-            # Check that we can read it
-            _ = utils.file_io.read_file(utils.Files.zntrack)[instance.node_name][
-                self.name
-            ]
-
-            params_values = utils.file_io.read_file(utils.Files.params)
-            cls_dict = utils.file_io.read_file(utils.Files.zntrack)
-            # select <node><attribute> from the full params / zntrack file
-            params_values = params_values[instance.node_name][self.name]
-            cls_dict = cls_dict[instance.node_name][self.name]
-
-            if isinstance(cls_dict, list):
-                value = [combine_values(*x) for x in zip(cls_dict, params_values)]
-            else:
-                value = combine_values(cls_dict, params_values)
-
-            log.debug(f"Loading {file.key} from {file}: ({value})")
-            instance.__dict__.update({self.name: value})
-        except (AttributeError, KeyError, TypeError, FileNotFoundError):
-            super().load(instance)
-
-
 class outs(ZnTrackOption):
     """Identify DVC option
 
@@ -196,7 +82,7 @@ class params(SplitZnTrackOption):
 
 
 class iterable(ZnTrackOption):
-    """Speciel ZnTrack option
+    """Special ZnTrack option
 
     This option defines an iterable parameter for spawning nodes.
     """
@@ -205,7 +91,7 @@ class iterable(ZnTrackOption):
 
 
 class metadata(ZnTrackOption):
-    """Speciel ZnTrack option
+    """Special ZnTrack option
 
     This option defines a <metrics_no_cache> output that is used by ZnTracks metadata
     collectors.
@@ -214,52 +100,3 @@ class metadata(ZnTrackOption):
     metadata = Metadata(
         dvc_option="metrics_no_cache", zntrack_type=utils.ZnTypes.metadata
     )
-
-
-class Method(SplitZnTrackOption):
-    """ZnTrack methods passing descriptor
-
-    This descriptor allows to pass a class instance that is not a ZnTrack Node as a
-    method that can be used later. It requires that all passed class attributes have
-    the same name in the __init__ and via getattr an that they are serializable.
-
-    Example
-    --------
-    >>> class HelloWorld:
-    >>>     def __init__(self, name):
-    >>>         self.name = name
-    >>>
-    >>> class MyNode(zntrack.Node)
-    >>>     my_method = Method()
-    >>> MyNode().my_method = HelloWorld(name="Max")
-
-    """
-
-    metadata = Metadata(dvc_option="params", zntrack_type=utils.ZnTypes.params)
-
-    def get_filename(self, instance) -> File:
-        """Does not really have a single file but params.yaml and zntrack.json"""
-        return File(path=utils.Files.params)
-
-    def __get__(self, instance, owner):
-        """Add some custom attributes to the instance to identify it in znjson"""
-        if instance is None:
-            return self
-        log.debug(f"Get {self} from {instance}")
-        value = instance.__dict__.get(self.name, self.default_value)
-        if value is None:
-            log.warning(
-                "Found NoneType but expected some class instance. Please open an issue on"
-                " github.com/zincware/ZnTrack if this causes unexpected behaviour."
-            )
-            return
-        try:
-            # Set some attribute for the serializer
-            value.znjson_zn_method = True
-            value.znjson_module = instance.module
-        except AttributeError:
-            # could be list / tuple
-            for element in value:
-                element.znjson_zn_method = True
-                element.znjson_module = instance.module
-        return value
diff --git a/zntrack/zn/method.py b/zntrack/zn/method.py
new file mode 100644
index 00000000..f4157377
--- /dev/null
+++ b/zntrack/zn/method.py
@@ -0,0 +1,57 @@
+import logging
+
+from zntrack import utils
+from zntrack.core.parameter import File
+from zntrack.descriptor import Metadata
+from zntrack.zn.split_option import SplitZnTrackOption
+
+log = logging.getLogger(__name__)
+
+
+class Method(SplitZnTrackOption):
+    """ZnTrack methods passing descriptor
+
+    This descriptor allows to pass a class instance that is not a ZnTrack Node as a
+    method that can be used later. It requires that all passed class attributes have
+    the same name in the __init__ and via getattr an that they are serializable.
+
+    Example
+    --------
+    >>> class HelloWorld:
+    >>>     def __init__(self, name):
+    >>>         self.name = name
+    >>>
+    >>> class MyNode(zntrack.Node)
+    >>>     my_method = Method()
+    >>> MyNode().my_method = HelloWorld(name="Max")
+
+    """
+
+    metadata = Metadata(dvc_option="params", zntrack_type=utils.ZnTypes.params)
+
+    def get_filename(self, instance) -> File:
+        """Does not really have a single file but params.yaml and zntrack.json"""
+        return File(path=utils.Files.params)
+
+    def __get__(self, instance, owner):
+        """Add some custom attributes to the instance to identify it in znjson"""
+        if instance is None:
+            return self
+        log.debug(f"Get {self} from {instance}")
+        value = instance.__dict__.get(self.name, self.default_value)
+        if value is None:
+            log.warning(
+                "Found NoneType but expected some class instance. Please open an issue on"
+                " github.com/zincware/ZnTrack if this causes unexpected behaviour."
+            )
+            return
+        try:
+            # Set some attribute for the serializer
+            value.znjson_zn_method = True
+            value.znjson_module = instance.module
+        except AttributeError:
+            # could be list / tuple
+            for element in value:
+                element.znjson_zn_method = True
+                element.znjson_module = instance.module
+        return value
diff --git a/zntrack/zn/split_option.py b/zntrack/zn/split_option.py
new file mode 100644
index 00000000..6da94842
--- /dev/null
+++ b/zntrack/zn/split_option.py
@@ -0,0 +1,153 @@
+"""
+This program and the accompanying materials are made available under the terms of the
+Eclipse Public License v2.0 which accompanies this distribution, and is available at
+https://www.eclipse.org/legal/epl-v20.html
+SPDX-License-Identifier: EPL-2.0
+
+Copyright Contributors to the Zincware Project.
+
+Description: The SplitZnTrackOption is used to for serializing objects and stroring the
+parameters / attributes in one file (params.yaml) and the rest, which is not considered
+a parameter in another (zntrack.json)
+
+"""
+import logging
+import typing
+
+from zntrack import utils
+from zntrack.core.parameter import ZnTrackOption
+
+log = logging.getLogger(__name__)
+
+
+def split_value(input_val) -> (typing.Union[dict, list], typing.Union[dict, list]):
+    """Split input_val into data for params.yaml and zntrack.json
+
+    Parameters
+    ----------
+    input_val: dict
+        A dictionary of shape {_type: str, value: any} from ZnJSON
+
+    Returns
+    -------
+    params_data: dict|list
+        A dictionary containing the data considered a parameter
+    input_val: dict|list
+        A dictionary containing the constant data which is not considered a parameter
+
+
+    """
+    if isinstance(input_val, (list, tuple)):
+        data = [split_value(x) for x in input_val]
+        params_data, zntrack_data = zip(*data)
+    else:
+        if input_val["_type"] in ["zn.method"]:
+            params_data = input_val["value"].pop("kwargs")
+            params_data["_cls"] = input_val["value"].pop("cls")
+        else:
+            # things that are not zn.method and do not have kwargs, such as pathlib, ...
+            params_data = input_val.pop("value")
+    return params_data, input_val
+
+
+def combine_values(cls_dict: dict, params_val):
+    """Combine values from params.yaml and zntrack.json
+
+    Parameters
+    ----------
+    cls_dict: dict
+        loaded from zntrack.json
+    params_val:
+        Parameters from params.yaml
+
+    Returns
+    -------
+    Loaded object of type cls_dict[_type]
+
+    """
+    result = cls_dict
+    if result["_type"] in ["zn.method"]:
+        try:
+            result["value"]["cls"] = params_val.pop("_cls")
+        except KeyError:
+            # using old file where the cls is stored in zntrack.json and not params.yaml
+            pass
+        result["value"]["kwargs"] = params_val
+    else:
+        # things that are not zn.method and do not have kwargs, such as pathlib, ...
+        result["value"] = params_val
+
+    return utils.decode_dict(result)
+
+
+class SplitZnTrackOption(ZnTrackOption):
+    """Method to split a value into params.yaml and zntrack.json
+
+    Serialize data into params.yaml if human-readable and the type in zntrack.json
+    """
+
+    def save(self, instance):
+        """Overwrite the save method
+
+        This save method tries to split the value into params.yaml and zntrack.json.
+        This allows e.g. having pathlib.Path() as a zn.params or a dataclass as zn.Method
+        where the path as string / the dataclass as dict is stored in params.yaml
+        """
+        value = self.__get__(instance, self.owner)
+        serialized_value = utils.encode_dict(value)
+
+        try:
+            # if znjson was used to serialize the data, it will have a _type key
+            params_data, zntrack_data = split_value(serialized_value)
+
+            # Write to params.yaml
+            utils.file_io.update_config_file(
+                file=utils.Files.params,
+                node_name=instance.node_name,
+                value_name=self.name,
+                value=params_data,
+            )
+
+            # write to zntrack.json
+            utils.file_io.update_config_file(
+                file=utils.Files.zntrack,
+                node_name=instance.node_name,
+                value_name=self.name,
+                value=zntrack_data,
+            )
+        except (KeyError, AttributeError, TypeError):
+            # KeyError if serialized_value is a normal dict
+            # AttributeError when serialized_value.pop does not exist
+            # TypeError <..>
+            super().save(instance)
+
+    def load(self, instance):
+        """Overwrite the load method
+
+        Try to load from zntrack.json / params.yaml in a combined approach first,
+        if no entry in zntrack.json is found, load from params.yaml only without
+        deserializing.
+        """
+        file = self.get_filename(instance)
+
+        try:
+            # Check that we can read it
+            _ = utils.file_io.read_file(utils.Files.zntrack)[instance.node_name][
+                self.name
+            ]
+
+            params_values = utils.file_io.read_file(utils.Files.params)
+            cls_dict = utils.file_io.read_file(utils.Files.zntrack)
+            # select <node><attribute> from the full params / zntrack file
+            params_values = params_values[instance.node_name][self.name]
+            cls_dict = cls_dict[instance.node_name][self.name]
+
+            if isinstance(cls_dict, list):
+                value = [combine_values(*x) for x in zip(cls_dict, params_values)]
+            else:
+                value = combine_values(cls_dict, params_values)
+
+            log.debug(f"Loading {file.key} from {file}: ({value})")
+            instance.__dict__.update({self.name: value})
+        except (AttributeError, KeyError, TypeError, FileNotFoundError):
+            super().load(instance)