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

experimaestro/tests/test_objects.py

@@ -1,11 +1,9 @@
-import logging
 from pathlib import Path
 
 import pytest
 from experimaestro import Config, Task, Annotated, copyconfig, default
 from experimaestro.core.arguments import Param
 from experimaestro.core.objects import ConfigMixin
-from experimaestro.core.types import XPMValue
 from experimaestro.generators import pathgenerator
 from experimaestro.scheduler.workspace import RunMode
 from experimaestro.tests.utils import TemporaryExperiment
@@ -28,7 +26,7 @@ def test_object_default():
 
 
 class B(Config):
-    a: Param[A] = A(x=3)
+    a: Param[A] = A.C(x=3)
 
 
 class C(B):
@@ -40,27 +38,26 @@ class D(B, A):
 
 
 class DefaultAnnotationConfig(Config):
-    a: Annotated[A, default(A(x=3))]
+    a: Annotated[A, default(A.C(x=3))]
 
 
 def test_object_config_default():
     """Test default configurations as default values"""
-    b = B()
+    b = B.C()
     assert b.a.x == 3
 
-    c = C()
+    c = C.C()
     assert c.a.x == 3
 
-    annotationConfig = DefaultAnnotationConfig()
+    annotationConfig = DefaultAnnotationConfig.C()
     assert annotationConfig.a.x == 3
 
 
 def test_hierarchy():
     """Test if the object hierarchy is OK"""
-    OA = A.__getxpmtype__().objecttype
-    OB = B.__getxpmtype__().objecttype
-    OC = C.__getxpmtype__().objecttype
-    OD = D.__getxpmtype__().objecttype
+    OA = A.__getxpmtype__().value_type
+    OB = B.__getxpmtype__().value_type
+    OC = C.__getxpmtype__().value_type
 
     assert issubclass(A, Config)
     assert issubclass(B, Config)
@@ -72,11 +69,6 @@ def test_hierarchy():
 
     assert issubclass(C, B)
 
-    assert OA.__bases__ == (A, XPMValue)
-    assert OB.__bases__ == (B, XPMValue)
-    assert OC.__bases__ == (C, B.XPMValue)
-    assert OD.__bases__ == (D, B.XPMValue, A.XPMValue)
-
 
 class CopyConfig(Task):
     path: Annotated[Path, pathgenerator("hello.txt")]
@@ -84,7 +76,7 @@ class CopyConfig(Task):
 
 
 def test_copyconfig(xp):
-    b = CopyConfig(x=2)
+    b = CopyConfig.C(x=2)
 
     b.submit()
 
@@ -92,18 +84,3 @@ def test_copyconfig(xp):
 
     assert copy_b.x == b.x
     assert "path" not in copy_b.__xpm__.values
-
-
-def test_direct_config_warns(caplog):
-    """Test that using a building Config directly raises a warning"""
-    message = "Config.__new__ is deprecated"
-
-    with caplog.at_level(logging.WARNING):
-        A(x=3)
-        assert message in caplog.text
-
-    caplog.clear()
-
-    with caplog.at_level(logging.WARNING):
-        A.C(x=3)
-        assert message not in caplog.text

experimaestro/tests/test_outputs.py

@@ -32,17 +32,17 @@ class MainB(Task):
 
 
 def test_output_taskoutput():
-    a = A(b=B())
-    output, ioutput = Main(a=a).submit(run_mode=RunMode.DRY_RUN)
+    a = A.C(b=B.C())
+    output, ioutput = Main.C(a=a).submit(run_mode=RunMode.DRY_RUN)
 
     # Direct
-    Main(a=output)
+    Main.C(a=output)
 
     # Via getattr
-    Main(a=A(b=output.b))
+    Main.C(a=A.C(b=output.b))
 
     # Via getitem
-    Main(a=ioutput["a"])
+    Main.C(a=ioutput["a"])
 
     # Now, submits
-    Main(a=output).submit(run_mode=RunMode.DRY_RUN)
+    Main.C(a=output).submit(run_mode=RunMode.DRY_RUN)

experimaestro/tests/test_param.py

@@ -148,7 +148,7 @@ def test_generatedpath():
         b: Param[B]
 
     basepath = Path("/tmp/testconflict")
-    c = C(b=B(a=A())).instance(DirectoryContext(basepath))
+    c = C.C(b=B.C(a=A.C())).instance(DirectoryContext(basepath))
     assert c.b.a.path.relative_to(basepath) == Path("out/b/a/test.txt")
 
 
@@ -158,13 +158,13 @@ def test_config_class():
     class A(Config):
         x: Param[int]
 
-    a = A(x=1)
+    a = A.C(x=1)
     assert a.x == 1
 
     class B(A):
         y: Param[int]
 
-    b = B(x=1, y=2)
+    b = B.C(x=1, y=2)
     assert b.x == 1
     assert b.y == 2
 
@@ -174,7 +174,7 @@ def test_config_class():
     class C(Config):
         d: Param[D]
 
-    c = C(d=D(x=1))
+    c = C.C(d=D.C(x=1))
     assert c.d.x == 1
 
 
@@ -182,7 +182,7 @@ def test_constant():
     class A(Config):
         x: Constant[int] = 2
 
-    a = A()
+    a = A.C()
     assert a.x == 2, "Constant value not set"
 
     # We should not be able to change the value
@@ -202,7 +202,7 @@ class EnumConfig(Config):
 def test_param_enum():
     """Test for enum values"""
 
-    a = EnumConfig(x=EnumParam.OTHER)
+    a = EnumConfig.C(x=EnumParam.OTHER)
     _a = serializeCycle(a)
 
     assert isinstance(_a, EnumConfig)
@@ -216,7 +216,7 @@ def test_inheritance():
     class B(A):
         y: Param[int] = 3
 
-    b = B()
+    b = B.C()
     b.x = 2
     assert b.__xpm__.values["y"] == 3
     assert b.__xpm__.values["x"] == 2
@@ -247,7 +247,7 @@ def test_param_dict():
     assert isinstance(xarg.keytype, StrType)
     assert isinstance(xarg.valuetype, IntType)
 
-    A(x={"OK": 1})
+    A.C(x={"OK": 1})
 
     with pytest.raises(TypeError):
         A(x={"wrong": "string"})
@@ -263,7 +263,7 @@ class ConfigWithDefault(Config):
 
 
 def test_param_default():
-    assert ConfigWithDefault().x == 1
+    assert ConfigWithDefault.C().x == 1
 
 
 class ConfigWithDefaultFactory(Config):
@@ -271,7 +271,7 @@ class ConfigWithDefaultFactory(Config):
 
 
 def test_param_default_factory():
-    value = ConfigWithDefaultFactory()
+    value = ConfigWithDefaultFactory.C()
     context = DirectoryContext(Path("/__fakepath__"))
     value.__xpm__.seal(context)
     assert value.x == 1
@@ -299,15 +299,15 @@ def test_param_default_set():
     class A0(Config):
         x: Param[int] = 2
 
-    assert A0().instance().x == 2
-    assert A0(x=3).instance().x == 3
+    assert A0.C().instance().x == 2
+    assert A0.C(x=3).instance().x == 3
 
     class A(Config):
         x: Param[int] = field(default_factory=lambda: 2)
 
-    assert A().instance().x == 2
+    assert A.C().instance().x == 2
 
-    assert A(x=3).instance().x == 3
+    assert A.C(x=3).instance().x == 3
 
 
 # --- Handling help annotations

experimaestro/tests/test_progress.py

@@ -72,7 +72,7 @@ def test_progress_basic():
         listener = ProgressListener()
         xp.scheduler.addlistener(listener)
 
-        out = ProgressingTask().submit()
+        out = ProgressingTask.C().submit()
         path = out.path  # type: Path
         job = out.__xpm__.job
 
@@ -103,7 +103,7 @@ def test_progress_multiple():
         listener1 = ProgressListener()
         xp1.scheduler.addlistener(listener1)
 
-        out = ProgressingTask().submit()
+        out = ProgressingTask.C().submit()
         path = out.path  # type: Path
         job = out.__xpm__.job
 
@@ -122,7 +122,7 @@ def test_progress_multiple():
             listener2 = ProgressListener()
             xp2.scheduler.addlistener(listener2)
 
-            out = ProgressingTask().submit()
+            out = ProgressingTask.C().submit()
             job = out.__xpm__.job  # type: CommandLineJob
             logger.info("Waiting for job to start (2)")
             while job.state.notstarted():
@@ -217,7 +217,7 @@ def test_progress_nested():
         listener = ProgressListener()
         xp.scheduler.addlistener(listener)
 
-        out = NestedProgressingTask().submit()
+        out = NestedProgressingTask.C().submit()
         job = out.__xpm__.job
         path = out.path  # type: Path
 

experimaestro/tests/test_serializers.py

@@ -1,71 +1,12 @@
 from typing import Optional
 from experimaestro import (
     Config,
-    Task,
     Param,
-    SerializationLWTask,
-    copyconfig,
     state_dict,
     from_state_dict,
 )
 from experimaestro.core.context import SerializationContext
 from experimaestro.core.objects import ConfigMixin
-from experimaestro.tests.utils import TemporaryExperiment
-
-
-class SubModel(Config):
-    pass
-
-
-class Model(Config):
-    submodel: Param[SubModel]
-
-    def __post_init__(self):
-        self.initialized = False
-        self.submodel.initialized = False
-
-
-class LoadModel(SerializationLWTask):
-    def execute(self):
-        self.value.initialized = True
-        self.value.submodel.initialized = True
-
-
-class Trainer(Task):
-    model: Param[Config]
-
-    def task_outputs(self, dep):
-        model = copyconfig(self.model)
-        return model.add_pretasks(dep(LoadModel(value=model)))
-
-    def execute(self):
-        assert not self.model.initialized, "Model not initialized"
-
-
-class Evaluate(Task):
-    model: Param[Config]
-    is_submodel: Param[bool] = False
-
-    def execute(self):
-        assert self.model.initialized, "Model not initialized"
-        if self.is_submodel:
-            assert isinstance(self.model, SubModel)
-        else:
-            assert isinstance(self.model, Model)
-
-
-def test_serializers_xp():
-    with TemporaryExperiment("serializers", maxwait=20, port=0):
-        model = Model(submodel=SubModel())
-        trained_model: Model = Trainer(model=model).submit()
-
-        # Use the model itself
-        Evaluate(model=trained_model).submit()
-
-        # Use a submodel
-        Evaluate(model=trained_model.submodel, is_submodel=True).add_pretasks_from(
-            trained_model
-        ).submit()
 
 
 class Object1(Config):

experimaestro/tests/test_tags.py

@@ -21,20 +21,20 @@ class Config2(Config):
 
 
 def test_tag():
-    c = Config1(x=5)
+    c = Config1.C(x=5)
     c.tag("x", 5)
     assert c.tags() == {"x": 5}
 
 
 def test_taggedvalue():
-    c = Config1(x=tag(5))
+    c = Config1.C(x=tag(5))
     assert c.tags() == {"x": 5}
 
 
 def test_tagcontain():
     """Test that tags are not propagated to the upper configurations"""
-    c1 = Config1(x=5)
-    c2 = Config2(c=c1, x=tag(3)).tag("out", 1)
+    c1 = Config1.C(x=5)
+    c2 = Config2.C(c=c1, x=tag(3)).tag("out", 1)
     assert c1.tags() == {}
     assert c2.tags() == {"x": 3, "out": 1}
 
@@ -50,17 +50,17 @@ def test_inneroutput():
     class Evaluate(Task):
         task: Param[MyTask]
 
-    output = Output().tag("hello", "world")
-    task = MyTask(outputs={}, mainoutput=output)
+    output = Output.C().tag("hello", "world")
+    task = MyTask.C(outputs={}, mainoutput=output)
     task.submit(run_mode=RunMode.DRY_RUN)
     assert output.tags() == {"hello": "world"}
 
-    output = Output().tag("hello", "world")
-    task = MyTask(outputs={"a": output}, mainoutput=Output())
+    output = Output.C().tag("hello", "world")
+    task = MyTask.C(outputs={"a": output}, mainoutput=Output.C())
     task.submit(run_mode=RunMode.DRY_RUN)
     assert output.tags() == {"hello": "world"}
 
-    evaluate = Evaluate(task=task).submit(run_mode=RunMode.DRY_RUN)
+    evaluate = Evaluate.C(task=task).submit(run_mode=RunMode.DRY_RUN)
     assert evaluate.__xpm__.tags() == {"hello": "world"}
 
 
@@ -80,21 +80,21 @@ def test_tags_init_tasks():
         x: Param[MyConfig]
 
         def task_outputs(self, dep) -> MyConfig:
-            return dep(MyConfig())
+            return dep(MyConfig.C())
 
-    init_task = InitTask().tag("hello", "world")
-    task = MyTask()
+    init_task = InitTask.C().tag("hello", "world")
+    task = MyTask.C()
     result = task.submit(run_mode=RunMode.DRY_RUN, init_tasks=[init_task])
     assert result.tags() == {"hello": "world"}
 
-    other_task = TaskWithOutput(x=MyConfig().tag("hello", "world"))
+    other_task = TaskWithOutput.C(x=MyConfig.C().tag("hello", "world"))
     assert other_task.tags() == {"hello": "world"}
 
     result = other_task.submit(run_mode=RunMode.DRY_RUN)
     assert isinstance(result, MyConfig)
     assert result.tags() == {"hello": "world"}
 
-    result = MyTask().submit(run_mode=RunMode.DRY_RUN, init_tasks=[result])
+    result = MyTask.C().submit(run_mode=RunMode.DRY_RUN, init_tasks=[result])
     assert result.tags() == {"hello": "world"}
 
 
@@ -115,6 +115,6 @@ def test_objects_tags():
         x: Param[int]
 
     context = DirectoryContext(Path("/__fakepath__"))
-    a = A(x=tag(1))
+    a = A.C(x=tag(1))
     a.__xpm__.seal(context)
     assert a.__xpm__.tags() == {"x": 1}

experimaestro/tests/test_tasks.py

@@ -29,8 +29,8 @@ from .definitions_types import IntegerTask, FloatTask
 
 def test_task_types():
     with TemporaryExperiment("simple"):
-        assert IntegerTask(value=5).submit().__xpm__.job.wait() == JobState.DONE
-        assert FloatTask(value=5.1).submit().__xpm__.job.wait() == JobState.DONE
+        assert IntegerTask.C(value=5).submit().__xpm__.job.wait() == JobState.DONE
+        assert FloatTask.C(value=5.1).submit().__xpm__.job.wait() == JobState.DONE
 
 
 def test_simple_task():
@@ -38,11 +38,11 @@ def test_simple_task():
         assert isinstance(workdir, Path)
         with TemporaryExperiment("helloworld", workdir=workdir, maxwait=20):
             # Submit the tasks
-            hello = Say(word="hello").submit()
-            world = Say(word="world").submit()
+            hello = Say.C(word="hello").submit()
+            world = Say.C(word="world").submit()
 
             # Concat will depend on the two first tasks
-            concat = Concat(strings=[hello, world]).submit()
+            concat = Concat.C(strings=[hello, world]).submit()
 
         assert concat.__xpm__.job.state == JobState.DONE
         assert Path(concat.stdout()).read_text() == "HELLO WORLD\n"
@@ -51,16 +51,16 @@ def test_simple_task():
 def test_not_submitted():
     """A not submitted task should not be accepted as an argument"""
     with TemporaryExperiment("helloworld", maxwait=2):
-        hello = Say(word="hello")
+        hello = Say.C(word="hello")
         with pytest.raises(ValueError):
-            Concat(strings=[hello])
+            Concat.C(strings=[hello])
 
 
 def test_fail_simple():
     """Failing task... should fail"""
     with pytest.raises(FailedExperiment):
         with TemporaryExperiment("failing", maxwait=20):
-            fail = Fail().submit()
+            fail = Fail.C().submit()
             fail.touch()
 
 
@@ -70,8 +70,8 @@ def test_foreign_type():
         # Submit the tasks
         from .tasks.foreign import ForeignClassB2
 
-        b = ForeignClassB2(x=1, y=2)
-        a = ForeignTaskA(b=b).submit()
+        b = ForeignClassB2.C(x=1, y=2)
+        a = ForeignTaskA.C(b=b).submit()
 
         assert a.__xpm__.job.wait() == JobState.DONE
         assert a.stdout().read_text().strip() == "1"
@@ -81,8 +81,8 @@ def test_fail_dep():
     """Failing task... should cancel dependent"""
     with pytest.raises(FailedExperiment):
         with TemporaryExperiment("failingdep"):
-            fail = Fail().submit()
-            dep = FailConsumer(fail=fail).submit()
+            fail = Fail.C().submit()
+            dep = FailConsumer.C(fail=fail).submit()
             fail.touch()
 
     assert fail.__xpm__.job.state == JobState.ERROR
@@ -92,14 +92,14 @@ def test_fail_dep():
 def test_unknown_attribute():
     """No check when setting attributes while executing"""
     with TemporaryExperiment("unknown"):
-        method = SetUnknown().submit()
+        method = SetUnknown.C().submit()
 
     assert method.__xpm__.job.wait() == JobState.DONE
 
 
 def test_function():
     with TemporaryExperiment("function"):
-        method = Method(a=1).submit()
+        method = Method.C(a=1).submit()
 
     assert method.__xpm__.job.wait() == JobState.DONE
 
@@ -111,7 +111,7 @@ def test_done():
 
 
 def restart_function(xp):
-    restart.Restart().submit()
+    restart.Restart.C().submit()
 
 
 @pytest.mark.parametrize("terminate", restart.TERMINATES_FUNC)
@@ -123,16 +123,23 @@ def test_restart(terminate):
 def test_submitted_twice():
     """Check that a job cannot be submitted twice within the same experiment"""
     with TemporaryExperiment("duplicate", maxwait=20):
-        task1 = SimpleTask(x=1).submit()
-        task2 = SimpleTask(x=1).submit()
-        assert task1 is task2, f"{id(task1)} != {id(task2)}"
+
+        task1 = SimpleTask.C(x=1)
+        o1 = task1.submit()
+
+        task2 = SimpleTask.C(x=1)
+        o2 = task2.submit()
+
+        print(o1)
+        assert o1.task is not o2.task
+        assert task1.__xpm__.job is task2.__xpm__.job, f"{id(task1)} != {id(task2)}"
 
 
 def test_configcache():
     """Test a configuration cache"""
 
     with TemporaryExperiment("configcache", maxwait=20):
-        task = CacheConfigTask(data=CacheConfig()).submit()
+        task = CacheConfigTask.C(data=CacheConfig.C()).submit()
 
     assert task.__xpm__.job.wait() == JobState.DONE
 
@@ -174,9 +181,13 @@ def test_tasks_deprecated_inner():
     the new class"""
     with TemporaryExperiment("deprecated", maxwait=0) as xp:
         # --- Check that paths are really different first
-        task_new = TaskWithDeprecated(p=NewConfig()).submit(run_mode=RunMode.DRY_RUN)
-        task_old = TaskWithDeprecated(p=OldConfig()).submit(run_mode=RunMode.DRY_RUN)
-        task_deprecated = TaskWithDeprecated(p=DeprecatedConfig()).submit(
+        task_new = TaskWithDeprecated.C(p=NewConfig.C()).submit(
+            run_mode=RunMode.DRY_RUN
+        )
+        task_old = TaskWithDeprecated.C(p=OldConfig.C()).submit(
+            run_mode=RunMode.DRY_RUN
+        )
+        task_deprecated = TaskWithDeprecated.C(p=DeprecatedConfig.C()).submit(
             run_mode=RunMode.DRY_RUN
         )
 
@@ -197,7 +208,7 @@ def test_tasks_deprecated_inner():
         # --- Now check that automatic linking is performed
 
         # Run old task with deprecated configuration
-        task_old = TaskWithDeprecated(p=OldConfig()).submit()
+        task_old = TaskWithDeprecated.C(p=OldConfig.C()).submit()
         task_old.wait()
         task_old_path = task_old.stdout().parent
 
@@ -229,9 +240,9 @@ def test_tasks_deprecated():
     the new class"""
     with TemporaryExperiment("deprecated", maxwait=20) as xp:
         # Check that paths are really different first
-        task_new = NewTask(x=1).submit(run_mode=RunMode.DRY_RUN)
-        task_old = OldTask(x=1).submit(run_mode=RunMode.DRY_RUN)
-        task_deprecated = DeprecatedTask(x=1).submit(run_mode=RunMode.DRY_RUN)
+        task_new = NewTask.C(x=1).submit(run_mode=RunMode.DRY_RUN)
+        task_old = OldTask.C(x=1).submit(run_mode=RunMode.DRY_RUN)
+        task_deprecated = DeprecatedTask.C(x=1).submit(run_mode=RunMode.DRY_RUN)
 
         assert (
             task_new.stdout() != task_old.stdout()
@@ -241,7 +252,7 @@ def test_tasks_deprecated():
         ), "Deprecated path should be the same as non deprecated"
 
         # OK, now check that automatic linking is performed
-        task_old = OldTask(x=1).submit()
+        task_old = OldTask.C(x=1).submit()
         task_old.wait()
         task_old_path = task_old.stdout().parent
 
@@ -270,7 +281,7 @@ class HookedTask(Task):
 
 
 def test_task_submit_hook():
-    result = HookedTask().submit(run_mode=RunMode.DRY_RUN)
+    result = HookedTask.C().submit(run_mode=RunMode.DRY_RUN)
     assert (
         result.__xpm__.task.__xpm__.job.environ.get("JAVA_HOME", None)
         == "THE_JAVA_HOME"
@@ -299,31 +310,11 @@ class MyLightweightTask(Task):
         assert self.x.data == 1
 
 
-def test_task_lightweight():
-    with TemporaryExperiment("lightweight", maxwait=20):
-        x = LightweightConfig()
-        lwtask = LightweightTask(x=x)
-        assert (
-            MyLightweightTask(x=x).add_pretasks(lwtask).submit().__xpm__.job.wait()
-            == JobState.DONE
-        ), "Pre-tasks should be executed"
-
-        x_2 = LightweightConfig()
-        lwtask_2 = LightweightTask(x=x)
-        assert (
-            MyLightweightTask(x=x_2.add_pretasks(lwtask_2))
-            .add_pretasks(lwtask_2)
-            .submit()
-            .__xpm__.job.wait()
-            == JobState.DONE
-        ), "Pre-tasks should be run just once"
-
-
 def test_task_lightweight_init():
     with TemporaryExperiment("lightweight_init", maxwait=20):
-        x = LightweightConfig()
-        lwtask = LightweightTask(x=x)
+        x = LightweightConfig.C()
+        lwtask = LightweightTask.C(x=x)
         assert (
-            MyLightweightTask(x=x).submit(init_tasks=[lwtask]).__xpm__.job.wait()
+            MyLightweightTask.C(x=x).submit(init_tasks=[lwtask]).__xpm__.job.wait()
             == JobState.DONE
         ), "Init tasks should be executed"

experimaestro/tests/test_tokens.py

@@ -32,7 +32,7 @@ def token_experiment(xp, token, ntasks=3):
 
     tasks = []
     for it in range(ntasks):
-        task = TokenTask(path=path, x=it)
+        task = TokenTask.C(path=path, x=it)
         if token:
             task.add_dependencies(token.dependency(1))
         tasks.append(task.submit())
@@ -86,7 +86,7 @@ def test_token_cleanup():
     with TemporaryExperiment("token_cleanup", maxwait=20) as xp:
         token = CounterToken("token-cleanup", xp.workdir / "token-cleanup", 1)
 
-        task = dummy_task(x=1)
+        task = dummy_task.C(x=1)
         dependency = token.dependency(1)
         task.add_dependencies(dependency)
         # Just to create the directory
@@ -98,7 +98,7 @@ def test_token_cleanup():
         # The absence of process should be detected right away
         logging.info("Lock without process")
         TokenFile.create(dependency)
-        task2 = dummy_task(x=2)
+        task2 = dummy_task.C(x=2)
         task2.add_dependencies(token.dependency(1)).submit()
         xp.wait()
 
@@ -118,7 +118,7 @@ def test_token_cleanup():
             p1 = subprocess.Popen(command)
             job.pidpath.write_text(json.dumps({"pid": p1.pid, "type": "local"}))
 
-            task3 = dummy_task(x=3)
+            task3 = dummy_task.C(x=3)
             task3.add_dependencies(token.dependency(1)).submit()
 
             # Ends the script "waitforfile.py"
@@ -136,7 +136,9 @@ def test_token_monitor():
 
     def run(xp, x, path):
         token = xp.workspace.connector.createtoken("test-token-monitor", 1)
-        task = TokenTask(path=path, x=x).add_dependencies(token.dependency(1)).submit()
+        task = (
+            TokenTask.C(path=path, x=x).add_dependencies(token.dependency(1)).submit()
+        )
         return task
 
     with TemporaryExperiment("tokens1", maxwait=20, port=0) as xp1, TemporaryExperiment(
@@ -241,7 +243,7 @@ def test_token_process():
 
 def restart_function(xp):
     token = CounterToken("restart-token", xp.workdir / "token", 1)
-    token(1, restart.Restart()).submit()
+    token(1, restart.Restart.C()).submit()
 
 
 @pytest.mark.parametrize("terminate", restart.TERMINATES_FUNC)