experimaestro 1.11.1__py3-none-any.whl → 2.0.0a8__py3-none-any.whl

experimaestro/tests/test_identifier.py

@@ -68,42 +68,42 @@ def assert_notequal(a, b, message=""):
     assert getidentifier(a) != getidentifier(b), message
 
 
-def test_param_int():
-    assert_equal(A(a=1), A(a=1))
+def test_identifier_int():
+    assert_equal(A.C(a=1), A.C(a=1))
 
 
-def test_param_different_type():
-    assert_notequal(A(a=1), B(a=1))
+def test_identifier_different_type():
+    assert_notequal(A.C(a=1), B.C(a=1))
 
 
-def test_param_order():
-    assert_equal(Values(value1=1, value2=2), Values(value2=2, value1=1))
+def test_identifier_order():
+    assert_equal(Values.C(value1=1, value2=2), Values.C(value2=2, value1=1))
 
 
-def test_param_default():
-    assert_equal(C(a=1, b=2), C(b=2))
+def test_identifier_default():
+    assert_equal(C.C(a=1, b=2), C.C(b=2))
 
 
 def test_identifier_default_field():
-    assert_equal(CField(a=1, b=2), CField(b=2))
+    assert_equal(CField.C(a=1, b=2), CField.C(b=2))
 
 
-def test_param_inner_eq():
-    assert_equal(D(a=A(a=1)), D(a=A(a=1)))
+def test_identifier_inner_eq():
+    assert_equal(D.C(a=A.C(a=1)), D.C(a=A.C(a=1)))
 
 
-def test_param_float():
-    assert_equal(Float(value=1), Float(value=1))
+def test_identifier_float():
+    assert_equal(Float.C(value=1), Float.C(value=1))
 
 
-def test_param_float2():
-    assert_equal(Float(value=1.0), Float(value=1))
+def test_identifier_float2():
+    assert_equal(Float.C(value=1.0), Float.C(value=1))
 
 
 # --- Argument name
 
 
-def test_param_name():
+def test_identifier_name():
     """The identifier fully determines the hash code"""
 
     class Config0(Config):
@@ -118,28 +118,28 @@ def test_param_name():
         __xpmid__ = "test.identifier.argumentname"
         a: Param[int]
 
-    assert_notequal(Config0(a=2), Config1(b=2))
-    assert_equal(Config0(a=2), Config3(a=2))
+    assert_notequal(Config0.C(a=2), Config1.C(b=2))
+    assert_equal(Config0.C(a=2), Config3.C(a=2))
 
 
 # --- Test option
 
 
-def test_param_option():
+def test_identifier_option():
     class OptionConfig(Config):
         __xpmid__ = "test.identifier.option"
         a: Param[int]
         b: Option[int] = 1
 
-    assert_notequal(OptionConfig(a=2), OptionConfig(a=1))
-    assert_equal(OptionConfig(a=1, b=2), OptionConfig(a=1))
-    assert_equal(OptionConfig(a=1, b=2), OptionConfig(a=1, b=2))
+    assert_notequal(OptionConfig.C(a=2), OptionConfig.C(a=1))
+    assert_equal(OptionConfig.C(a=1, b=2), OptionConfig.C(a=1))
+    assert_equal(OptionConfig.C(a=1, b=2), OptionConfig.C(a=1, b=2))
 
 
 # --- Dictionnary
 
 
-def test_param_identifier_dict():
+def test_identifier_dict():
     """Test identifiers of dictionary structures"""
 
     class B(Config):
@@ -148,11 +148,14 @@ def test_param_identifier_dict():
     class A(Config):
         bs: Param[Dict[str, B]]
 
-    assert_equal(A(bs={"b1": B(x=1)}), A(bs={"b1": B(x=1)}))
-    assert_equal(A(bs={"b1": B(x=1), "b2": B(x=2)}), A(bs={"b2": B(x=2), "b1": B(x=1)}))
+    assert_equal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b1": B.C(x=1)}))
+    assert_equal(
+        A.C(bs={"b1": B.C(x=1), "b2": B.C(x=2)}),
+        A.C(bs={"b2": B.C(x=2), "b1": B.C(x=1)}),
+    )
 
-    assert_notequal(A(bs={"b1": B(x=1)}), A(bs={"b1": B(x=2)}))
-    assert_notequal(A(bs={"b1": B(x=1)}), A(bs={"b2": B(x=1)}))
+    assert_notequal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b1": B.C(x=2)}))
+    assert_notequal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b2": B.C(x=1)}))
 
 
 # --- Ignore paths
@@ -163,16 +166,16 @@ class TypeWithPath(Config):
     path: Param[Path]
 
 
-def test_param_identifier_path():
+def test_identifier_path():
     """Path should be ignored"""
-    assert_equal(TypeWithPath(a=1, path="/a/b"), TypeWithPath(a=1, path="/c/d"))
-    assert_notequal(TypeWithPath(a=2, path="/a/b"), TypeWithPath(a=1, path="/c/d"))
+    assert_equal(TypeWithPath.C(a=1, path="/a/b"), TypeWithPath.C(a=1, path="/c/d"))
+    assert_notequal(TypeWithPath.C(a=2, path="/a/b"), TypeWithPath.C(a=1, path="/c/d"))
 
 
 # --- Test with added arguments
 
 
-def test_param_identifier_pathoption():
+def test_identifier_pathoption():
     """Path arguments should be ignored"""
 
     class A_with_path(Config):
@@ -184,10 +187,10 @@ def test_param_identifier_pathoption():
         __xpmid__ = "pathoption_test"
         a: Param[int]
 
-    assert_equal(A_with_path(a=1), A_without_path(a=1))
+    assert_equal(A_with_path.C(a=1), A_without_path.C(a=1))
 
 
-def test_param_identifier_enum():
+def test_identifier_enum():
     """test enum parameters"""
     from enum import Enum
 
@@ -198,11 +201,11 @@ def test_param_identifier_enum():
     class EnumConfig(Config):
         a: Param[EnumParam]
 
-    assert_notequal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.SECOND))
-    assert_equal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.FIRST))
+    assert_notequal(EnumConfig.C(a=EnumParam.FIRST), EnumConfig.C(a=EnumParam.SECOND))
+    assert_equal(EnumConfig.C(a=EnumParam.FIRST), EnumConfig.C(a=EnumParam.FIRST))
 
 
-def test_param_identifier_addnone():
+def test_identifier_addnone():
     """Test the case of new parameter (with None default)"""
 
     class B(Config):
@@ -215,11 +218,11 @@ def test_param_identifier_addnone():
     class A(Config):
         __xpmid__ = "defaultnone"
 
-    assert_equal(A_with_b(), A())
-    assert_notequal(A_with_b(b=B(x=1)), A())
+    assert_equal(A_with_b.C(), A.C())
+    assert_notequal(A_with_b.C(b=B.C(x=1)), A.C())
 
 
-def test_param_defaultnew():
+def test_identifier_defaultnew():
     """Path arguments should be ignored"""
 
     class A_with_b(Config):
@@ -232,11 +235,11 @@ def test_param_defaultnew():
         __xpmid__ = "defaultnew"
         a: Param[int]
 
-    assert_equal(A_with_b(a=1, b=1), A(a=1))
-    assert_equal(A_with_b(a=1), A(a=1))
+    assert_equal(A_with_b.C(a=1, b=1), A.C(a=1))
+    assert_equal(A_with_b.C(a=1), A.C(a=1))
 
 
-def test_param_taskconfigidentifier():
+def test_identifier_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -246,19 +249,19 @@ def test_param_taskconfigidentifier():
         x: Param[int]
 
         def task_outputs(self, dep):
-            return dep(MyConfig(a=1))
+            return dep(MyConfig.C(a=1))
 
     assert_equal(
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
     )
     assert_notequal(
-        MyTask(x=2).submit(run_mode=RunMode.DRY_RUN),
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=2).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
     )
 
 
-def test_param_constant():
+def test_identifier_constant():
     """Test if constants are taken into account for signature computation"""
 
     class A1(Config):
@@ -269,16 +272,16 @@ def test_param_constant():
         __xpmid__ = "test.constant"
         version: Constant[int] = 1
 
-    assert_equal(A1(), A1bis())
+    assert_equal(A1.C(), A1bis.C())
 
     class A2(Config):
         __xpmid__ = "test.constant"
         version: Constant[int] = 2
 
-    assert_notequal(A1(), A2())
+    assert_notequal(A1.C(), A2.C())
 
 
-def test_param_identifier_deprecated_class():
+def test_identifier_deprecated_class():
     """Test that when submitting the task, the computed identifier is the one of
     the new class"""
 
@@ -293,14 +296,16 @@ def test_param_identifier_deprecated_class():
         __xpmid__ = "derived"
 
     assert_notequal(
-        NewConfig(), DerivedConfig(), "A derived configuration has another ID"
+        NewConfig.C(), DerivedConfig.C(), "A derived configuration has another ID"
     )
     assert_equal(
-        NewConfig(), OldConfig(), "Deprecated and new configuration have the same ID"
+        NewConfig.C(),
+        OldConfig.C(),
+        "Deprecated and new configuration have the same ID",
     )
 
 
-def test_param_identifier_deprecated_attribute():
+def test_identifier_deprecated_attribute():
     class Values(Config):
         values: Param[List[int]] = []
 
@@ -308,14 +313,14 @@ def test_param_identifier_deprecated_attribute():
         def value(self, x):
             self.values = [x]
 
-    assert_equal(Values(values=[1]), Values(value=1))
+    assert_equal(Values.C(values=[1]), Values.C(value=1))
 
 
 class MetaA(Config):
     x: Param[int]
 
 
-def test_param_identifier_meta():
+def test_identifier_meta():
     """Test forced meta-parameter"""
 
     class B(Config):
@@ -331,121 +336,136 @@ def test_param_identifier_meta():
         params: Param[Dict[str, MetaA]]
 
     # As meta
-    assert_notequal(B(a=MetaA(x=1)), B(a=MetaA(x=2)))
-    assert_equal(B(a=setmeta(MetaA(x=1), True)), B(a=setmeta(MetaA(x=2), True)))
+    assert_notequal(B.C(a=MetaA.C(x=1)), B.C(a=MetaA.C(x=2)))
+    assert_equal(B.C(a=setmeta(MetaA.C(x=1), True)), B.C(a=setmeta(MetaA.C(x=2), True)))
 
     # As parameter
-    assert_equal(C(a=MetaA(x=1)), C(a=MetaA(x=2)))
-    assert_notequal(C(a=setmeta(MetaA(x=1), False)), C(a=setmeta(MetaA(x=2), False)))
+    assert_equal(C.C(a=MetaA.C(x=1)), C.C(a=MetaA.C(x=2)))
+    assert_notequal(
+        C.C(a=setmeta(MetaA.C(x=1), False)), C.C(a=setmeta(MetaA.C(x=2), False))
+    )
 
     # Array with mixed
     assert_equal(
-        ArrayConfig(array=[MetaA(x=1)]),
-        ArrayConfig(array=[MetaA(x=1), setmeta(MetaA(x=2), True)]),
+        ArrayConfig.C(array=[MetaA.C(x=1)]),
+        ArrayConfig.C(array=[MetaA.C(x=1), setmeta(MetaA.C(x=2), True)]),
     )
 
     # Array with empty list
-    assert_equal(ArrayConfig(array=[]), ArrayConfig(array=[setmeta(MetaA(x=2), True)]))
+    assert_equal(
+        ArrayConfig.C(array=[]), ArrayConfig.C(array=[setmeta(MetaA.C(x=2), True)])
+    )
 
     # Dict with mixed
     assert_equal(
-        DictConfig(params={"a": MetaA(x=1)}),
-        DictConfig(params={"a": MetaA(x=1), "b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={"a": MetaA.C(x=1)}),
+        DictConfig.C(params={"a": MetaA.C(x=1), "b": setmeta(MetaA.C(x=2), True)}),
     )
 
 
-def test_param_identifier_meta_default_dict():
+def test_identifier_meta_default_dict():
     class DictConfig(Config):
         params: Param[Dict[str, MetaA]] = {}
 
     assert_equal(
-        DictConfig(params={}),
-        DictConfig(params={"b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={}),
+        DictConfig.C(params={"b": setmeta(MetaA.C(x=2), True)}),
     )
 
     # Dict with mixed
     assert_equal(
-        DictConfig(params={"a": MetaA(x=1)}),
-        DictConfig(params={"a": MetaA(x=1), "b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={"a": MetaA.C(x=1)}),
+        DictConfig.C(params={"a": MetaA.C(x=1), "b": setmeta(MetaA.C(x=2), True)}),
     )
 
 
-def test_param_identifier_meta_default_array():
+def test_identifier_meta_default_array():
     class ArrayConfigWithDefault(Config):
         array: Param[List[MetaA]] = []
 
     # Array (with default) with mixed
     assert_equal(
-        ArrayConfigWithDefault(array=[MetaA(x=1)]),
-        ArrayConfigWithDefault(array=[MetaA(x=1), setmeta(MetaA(x=2), True)]),
+        ArrayConfigWithDefault.C(array=[MetaA.C(x=1)]),
+        ArrayConfigWithDefault.C(array=[MetaA.C(x=1), setmeta(MetaA.C(x=2), True)]),
     )
     # Array (with default) with empty list
     assert_equal(
-        ArrayConfigWithDefault(array=[]),
-        ArrayConfigWithDefault(array=[setmeta(MetaA(x=2), True)]),
+        ArrayConfigWithDefault.C(array=[]),
+        ArrayConfigWithDefault.C(array=[setmeta(MetaA.C(x=2), True)]),
     )
 
 
-def test_param_identifier_pre_task():
+def test_identifier_init_task():
     class MyConfig(Config):
         pass
 
-    class IdentifierPreLightTask(LightweightTask):
+    class IdentifierInitTask(LightweightTask):
+        pass
+
+    class IdentifierInitTask2(Task):
         pass
 
-    class IdentifierPreTask(Task):
+    class IdentifierTask(Task):
         x: Param[MyConfig]
 
-    task = IdentifierPreTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
+    task = IdentifierTask.C(x=MyConfig.C()).submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
+    )
+    task_with_pre_2 = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_2 = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre_3 = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask2.C(), IdentifierInitTask.C()],
     )
-    task_with_pre_3 = IdentifierPreTask(
-        x=MyConfig().add_pretasks(IdentifierPreLightTask())
-    ).submit(run_mode=RunMode.DRY_RUN)
 
-    assert_notequal(task, task_with_pre, "No pre-task")
+    assert_notequal(task, task_with_pre, "Should be different with init-task")
     assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_equal(task_with_pre, task_with_pre_3, "Pre-tasks are order-less")
+    assert_notequal(task_with_pre, task_with_pre_3, "Other parameters")
 
 
-def test_param_identifier_init_task():
-    class MyConfig(Config):
-        pass
+def test_identifier_init_task_dep():
+    class Loader(LightweightTask):
+        param1: Param[float]
 
-    class IdentifierInitTask(LightweightTask):
-        pass
+        def execute(self):
+            pass
 
-    class IdentifierInitTask2(Task):
-        pass
+    class FirstTask(Task):
+        def task_outputs(self, dep):
+            return dep(Loader.C(param1=1))
 
-    class IdentierTask(Task):
-        x: Param[MyConfig]
+        def execute(self):
+            pass
 
-    task = IdentierTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
-    )
-    task_with_pre_2 = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
+    class SecondTask(Task):
+        param3: Param[int]
+
+        def execute(self):
+            pass
+
+    # Two identical tasks
+    task_a_1 = FirstTask.C()
+    task_a_2 = FirstTask.C()
+    assert_equal(task_a_1, task_a_2)
+
+    # We process them with two different init tasks
+    loader_1 = task_a_1.submit(
+        init_tasks=[Loader.C(param1=0.5)], run_mode=RunMode.DRY_RUN
     )
-    task_with_pre_3 = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask2(), IdentifierInitTask()],
+    loader_2 = task_a_2.submit(
+        init_tasks=[Loader.C(param1=5)], run_mode=RunMode.DRY_RUN
     )
+    assert_notequal(loader_1, loader_2)
 
-    assert_notequal(task, task_with_pre, "No pre-task")
-    assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_notequal(task_with_pre, task_with_pre_3, "Same parameters")
+    # Now, we process
+    c_1 = SecondTask.C(param3=2).submit(init_tasks=[loader_1], run_mode=RunMode.DRY_RUN)
+
+    c_2 = SecondTask.C(param3=2).submit(init_tasks=[loader_2], run_mode=RunMode.DRY_RUN)
+    assert_notequal(c_1, c_2)
 
 
 # --- Check configuration reloads
@@ -463,7 +483,7 @@ def check_reload(config):
     new_config = ConfigInformation.fromParameters(
         data, as_instance=False, discard_id=True
     )
-    assert new_config.__xpm__._full_identifier is None
+    assert new_config.__xpm__._identifier is None
     new_identifier = new_config.__xpm__.identifier.all
 
     assert new_identifier == old_identifier
@@ -473,28 +493,28 @@ class IdentifierReloadConfig(Config):
     id: Param[str]
 
 
-def test_param_identifier_reload_config():
+def test_identifier_reload_config():
     # Creates the configuration
-    check_reload(IdentifierReloadConfig(id="123"))
+    check_reload(IdentifierReloadConfig.C(id="123"))
 
 
 class IdentifierReload(Task):
     id: Param[str]
 
-    def task_outputs(self, dep):
-        return IdentifierReloadConfig(id=self.id)
+    def task_outputs(self, dep) -> IdentifierReloadConfig.C:
+        return IdentifierReloadConfig.C(id=self.id)
 
 
 class IdentifierReloadDerived(Config):
     task: Param[IdentifierReloadConfig]
 
 
-def test_param_identifier_reload_taskoutput():
+def test_identifier_reload_taskoutput():
     """When using a task output, the identifier should not be different"""
 
     # Creates the configuration
-    task = IdentifierReload(id="123").submit(run_mode=RunMode.DRY_RUN)
-    config = IdentifierReloadDerived(task=task)
+    task = IdentifierReload.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadDerived.C(task=task)
     check_reload(config)
 
 
@@ -511,23 +531,23 @@ class IdentifierReloadTaskDerived(Config):
     other: Param[IdentifierReloadTaskConfig]
 
 
-def test_param_identifier_reload_task_direct():
+def test_identifier_reload_task_direct():
     """When using a direct task output, the identifier should not be different"""
 
     # Creates the configuration
-    task = IdentifierReloadTask(id="123").submit(run_mode=RunMode.DRY_RUN)
-    config = IdentifierReloadTaskDerived(
-        task=task, other=IdentifierReloadTaskConfig(x=2)
+    task = IdentifierReloadTask.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadTaskDerived.C(
+        task=task, other=IdentifierReloadTaskConfig.C(x=2)
     )
     check_reload(config)
 
 
-def test_param_identifier_reload_meta():
+def test_identifier_reload_meta():
     """Test identifier don't change when using meta"""
     # Creates the configuration
-    task = IdentifierReloadTask(id="123").submit(run_mode=RunMode.DRY_RUN)
-    config = IdentifierReloadTaskDerived(
-        task=task, other=setmeta(IdentifierReloadTaskConfig(x=2), True)
+    task = IdentifierReloadTask.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadTaskDerived.C(
+        task=task, other=setmeta(IdentifierReloadTaskConfig.C(x=2), True)
     )
     check_reload(config)
 
@@ -545,10 +565,10 @@ class LoopC(Config):
     param_b: Param["LoopB"]
 
 
-def test_param_identifier_loop():
-    c = LoopC()
-    b = LoopB(param_c=c)
-    a = LoopA(param_b=b)
+def test_identifier_loop():
+    c = LoopC.C()
+    b = LoopB.C(param_c=c)
+    a = LoopA.C(param_b=b)
     c.param_a = a
     c.param_b = b
 

experimaestro/tests/test_instance.py

@@ -17,16 +17,16 @@ class B(Config):
 
 
 def test_simple_instance():
-    a = A1(x=1)
-    b = B(a=a)
+    a = A1.C(x=1)
+    b = B.C(a=a)
     b = b.instance()
 
     assert not isinstance(b, ConfigMixin)
-    assert isinstance(b, B.__xpmtype__.objecttype)
+    assert isinstance(b, B.__xpmtype__.value_type)
 
     assert not isinstance(b.a, ConfigMixin)
-    assert isinstance(b.a, A1.__xpmtype__.objecttype)
-    assert isinstance(b.a, A.__xpmtype__.basetype)
+    assert isinstance(b.a, A1.__xpmtype__.value_type)
+    assert isinstance(b.a, A.__xpmtype__.value_type)
 
 
 # --- Test pre tasks
@@ -46,18 +46,6 @@ class LoadModel(SerializationLWTask):
         self.value.initialized = True
 
 
-def test_instance_serialized():
-    model = Model()
-    model.add_pretasks(LoadModel(value=model))
-    trainer = Evaluator(model=model)
-    instance = trainer.instance()
-
-    assert isinstance(
-        instance.model, Model
-    ), f"The model is not a Model but a {type(instance.model).__qualname__}"
-    assert instance.model.initialized, "The model was not initialized"
-
-
 class ConfigWithOptional(Config):
     x: Param[int] = 1
     y: Param[Optional[int]]
@@ -65,6 +53,13 @@ class ConfigWithOptional(Config):
 
 def test_instance_optional():
     """Test that optional parameters are set to None when calling instance"""
-    c = ConfigWithOptional().instance()
+    c = ConfigWithOptional.C().instance()
     assert c.x == 1
     assert c.y is None
+
+
+def test_instance_keep_config():
+    evaluator = Evaluator.C(model=Model.C())
+    instance = evaluator.instance(keep=True)
+
+    assert instance.__config__ is evaluator