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

experimaestro/tests/test_identifier.py

@@ -4,16 +4,14 @@ import json
 from pathlib import Path
 from typing import Dict, List, Optional
 from experimaestro import (
-    config,
     Param,
-    param,
     deprecate,
     Config,
     Constant,
     Meta,
     Option,
-    pathgenerator,
-    Annotated,
+    PathGenerator,
+    field,
     Task,
     LightweightTask,
 )
@@ -40,6 +38,11 @@ class C(Config):
     b: Param[int]
 
 
+class CField(Config):
+    a: Param[int] = field(default_factory=lambda: 1)
+    b: Param[int]
+
+
 class D(Config):
     a: Param[A]
 
@@ -48,8 +51,7 @@ class Float(Config):
     value: Param[float]
 
 
-@config()
-class Values:
+class Values(Config):
     value1: Param[float]
     value2: Param[float]
 
@@ -66,68 +68,72 @@ def assert_notequal(a, b, message=""):
     assert getidentifier(a) != getidentifier(b), message
 
 
-def test_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_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_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_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_inner_eq():
-    assert_equal(D(a=A(a=1)), D(a=A(a=1)))
+def test_identifier_default_field():
+    assert_equal(CField.C(a=1, b=2), CField.C(b=2))
 
 
-def test_float():
-    assert_equal(Float(value=1), Float(value=1))
+def test_identifier_inner_eq():
+    assert_equal(D.C(a=A.C(a=1)), D.C(a=A.C(a=1)))
 
 
-def test_float2():
-    assert_equal(Float(value=1.0), Float(value=1))
+def test_identifier_float():
+    assert_equal(Float.C(value=1), Float.C(value=1))
+
+
+def test_identifier_float2():
+    assert_equal(Float.C(value=1.0), Float.C(value=1))
 
 
 # --- Argument name
 
 
-def test_name():
+def test_identifier_name():
     """The identifier fully determines the hash code"""
 
-    @config("test.identifier.argumentname")
-    class Config0:
+    class Config0(Config):
+        __xpmid__ = "test.identifier.argumentname"
         a: Param[int]
 
-    @config("test.identifier.argumentname")
-    class Config1:
+    class Config1(Config):
+        __xpmid__ = "test.identifier.argumentname"
         b: Param[int]
 
-    @config("test.identifier.argumentname")
-    class Config3:
+    class Config3(Config):
+        __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_option():
-    @config("test.identifier.option")
-    class OptionConfig:
+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
@@ -142,48 +148,50 @@ def test_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
 
 
-@config()
-class TypeWithPath:
+class TypeWithPath(Config):
     a: Param[int]
     path: Param[Path]
 
 
-def test_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_pathoption():
+def test_identifier_pathoption():
     """Path arguments should be ignored"""
 
-    @config("pathoption_test")
-    class A_with_path:
+    class A_with_path(Config):
+        __xpmid__ = "pathoption_test"
         a: Param[int]
-        path: Annotated[Path, pathgenerator("path")]
+        path: Meta[Path] = field(default_factory=PathGenerator("path"))
 
-    @config("pathoption_test")
-    class A_without_path:
+    class A_without_path(Config):
+        __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_identifier_enum():
-    """Path arguments should be ignored"""
+    """test enum parameters"""
     from enum import Enum
 
     class EnumParam(Enum):
@@ -193,8 +201,8 @@ def test_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_identifier_addnone():
@@ -210,29 +218,28 @@ def test_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_defaultnew():
+def test_identifier_defaultnew():
     """Path arguments should be ignored"""
 
-    @param("b", type=int, default=1)
-    @param(name="a", type=int)
-    @config("defaultnew")
-    class A_with_b:
-        pass
+    class A_with_b(Config):
+        __xpmid__ = "defaultnew"
 
-    @param(name="a", type=int)
-    @config("defaultnew")
-    class A:
-        pass
+        a: Param[int]
+        b: Param[int] = 1
 
-    assert_equal(A_with_b(a=1, b=1), A(a=1))
-    assert_equal(A_with_b(a=1), A(a=1))
+    class A(Config):
+        __xpmid__ = "defaultnew"
+        a: Param[int]
+
+    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_taskconfigidentifier():
+def test_identifier_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -242,36 +249,36 @@ def test_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_constant():
+def test_identifier_constant():
     """Test if constants are taken into account for signature computation"""
 
-    @config("test.constant")
-    class A1:
+    class A1(Config):
+        __xpmid__ = "test.constant"
         version: Constant[int] = 1
 
-    @config("test.constant")
-    class A1bis:
+    class A1bis(Config):
+        __xpmid__ = "test.constant"
         version: Constant[int] = 1
 
-    assert_equal(A1(), A1bis())
+    assert_equal(A1.C(), A1bis.C())
 
-    @config("test.constant")
-    class A2:
+    class A2(Config):
+        __xpmid__ = "test.constant"
         version: Constant[int] = 2
 
-    assert_notequal(A1(), A2())
+    assert_notequal(A1.C(), A2.C())
 
 
 def test_identifier_deprecated_class():
@@ -289,10 +296,12 @@ def test_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",
     )
 
 
@@ -304,7 +313,7 @@ def test_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):
@@ -327,26 +336,30 @@ def test_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)}),
     )
 
 
@@ -355,14 +368,14 @@ def test_identifier_meta_default_dict():
         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)}),
     )
 
 
@@ -372,44 +385,14 @@ def test_identifier_meta_default_array():
 
     # 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)]),
-    )
-
-
-def test_identifier_pre_task():
-    class MyConfig(Config):
-        pass
-
-    class IdentifierPreLightTask(LightweightTask):
-        pass
-
-    class IdentifierPreTask(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)
+        ArrayConfigWithDefault.C(array=[]),
+        ArrayConfigWithDefault.C(array=[setmeta(MetaA.C(x=2), True)]),
     )
-    task_with_pre_2 = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
-    )
-    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_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_equal(task_with_pre, task_with_pre_3, "Pre-tasks are order-less")
 
 
 def test_identifier_init_task():
@@ -422,26 +405,67 @@ def test_identifier_init_task():
     class IdentifierInitTask2(Task):
         pass
 
-    class IdentierTask(Task):
+    class IdentifierTask(Task):
         x: Param[MyConfig]
 
-    task = IdentierTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = IdentierTask(x=MyConfig()).submit(
+    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(), IdentifierInitTask2()],
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_2 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_2 = IdentifierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_3 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_3 = IdentifierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask2(), IdentifierInitTask()],
+        init_tasks=[IdentifierInitTask2.C(), IdentifierInitTask.C()],
     )
 
-    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_notequal(task_with_pre, task_with_pre_3, "Same parameters")
+    assert_notequal(task_with_pre, task_with_pre_3, "Other parameters")
+
+
+def test_identifier_init_task_dep():
+    class Loader(LightweightTask):
+        param1: Param[float]
+
+        def execute(self):
+            pass
+
+    class FirstTask(Task):
+        def task_outputs(self, dep):
+            return dep(Loader.C(param1=1))
+
+        def execute(self):
+            pass
+
+    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
+    )
+    loader_2 = task_a_2.submit(
+        init_tasks=[Loader.C(param1=5)], run_mode=RunMode.DRY_RUN
+    )
+    assert_notequal(loader_1, loader_2)
+
+    # 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
@@ -459,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
@@ -471,14 +495,14 @@ class IdentifierReloadConfig(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):
@@ -489,8 +513,8 @@ 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,9 +535,9 @@ 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)
 
@@ -521,9 +545,9 @@ def test_identifier_reload_task_direct():
 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)
 
@@ -542,9 +566,9 @@ class LoopC(Config):
 
 
 def test_identifier_loop():
-    c = LoopC()
-    b = LoopB(param_c=c)
-    a = LoopA(param_b=b)
+    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

@@ -1,35 +1,32 @@
 from typing import Optional
-from experimaestro import config, Param, Config
-from experimaestro.core.objects import TypeConfig
+from experimaestro import Param, Config
+from experimaestro.core.objects import ConfigMixin
 from experimaestro.core.serializers import SerializationLWTask
 
 
-@config()
-class A:
+class A(Config):
     x: Param[int] = 1
 
 
-@config()
 class A1(A):
     pass
 
 
-@config()
-class B:
+class B(Config):
     a: Param[A]
 
 
 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, TypeConfig)
-    assert isinstance(b, B.__xpmtype__.objecttype)
+    assert not isinstance(b, ConfigMixin)
+    assert isinstance(b, B.__xpmtype__.value_type)
 
-    assert not isinstance(b.a, TypeConfig)
-    assert isinstance(b.a, A1.__xpmtype__.objecttype)
-    assert isinstance(b.a, A.__xpmtype__.basetype)
+    assert not isinstance(b.a, ConfigMixin)
+    assert isinstance(b.a, A1.__xpmtype__.value_type)
+    assert isinstance(b.a, A.__xpmtype__.value_type)
 
 
 # --- Test pre tasks
@@ -49,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]]
@@ -68,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