experimaestro 1.10.1__py3-none-any.whl → 2.0.0rc0__py3-none-any.whl

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

@@ -36,7 +36,7 @@ class Trainer(Task):
 
     def task_outputs(self, dep):
         model = copyconfig(self.model)
-        return model.add_pretasks(dep(LoadModel(value=model)))
+        return model.add_pretasks(dep(LoadModel.C(value=model)))
 
     def execute(self):
         assert not self.model.initialized, "Model not initialized"
@@ -56,14 +56,14 @@ class Evaluate(Task):
 
 def test_serializers_xp():
     with TemporaryExperiment("serializers", maxwait=20, port=0):
-        model = Model(submodel=SubModel())
-        trained_model: Model = Trainer(model=model).submit()
+        model = Model.C(submodel=SubModel.C())
+        trained_model: Model = Trainer.C(model=model).submit()
 
         # Use the model itself
-        Evaluate(model=trained_model).submit()
+        Evaluate.C(model=trained_model).submit()
 
         # Use a submodel
-        Evaluate(model=trained_model.submodel, is_submodel=True).add_pretasks_from(
+        Evaluate.C(model=trained_model.submodel, is_submodel=True).add_pretasks_from(
             trained_model
         ).submit()
 

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,8 +123,8 @@ 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()
+        task1 = SimpleTask.C(x=1).submit()
+        task2 = SimpleTask.C(x=1).submit()
         assert task1 is task2, f"{id(task1)} != {id(task2)}"
 
 
@@ -132,7 +132,7 @@ 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 +174,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 +201,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 +233,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 +245,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 +274,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"
@@ -301,17 +305,17 @@ class MyLightweightTask(Task):
 
 def test_task_lightweight():
     with TemporaryExperiment("lightweight", maxwait=20):
-        x = LightweightConfig()
-        lwtask = LightweightTask(x=x)
+        x = LightweightConfig.C()
+        lwtask = LightweightTask.C(x=x)
         assert (
-            MyLightweightTask(x=x).add_pretasks(lwtask).submit().__xpm__.job.wait()
+            MyLightweightTask.C(x=x).add_pretasks(lwtask).submit().__xpm__.job.wait()
             == JobState.DONE
         ), "Pre-tasks should be executed"
 
-        x_2 = LightweightConfig()
-        lwtask_2 = LightweightTask(x=x)
+        x_2 = LightweightConfig.C()
+        lwtask_2 = LightweightTask.C(x=x)
         assert (
-            MyLightweightTask(x=x_2.add_pretasks(lwtask_2))
+            MyLightweightTask.C(x=x_2.add_pretasks(lwtask_2))
             .add_pretasks(lwtask_2)
             .submit()
             .__xpm__.job.wait()
@@ -321,9 +325,9 @@ def test_task_lightweight():
 
 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)

experimaestro/tests/test_types.py

@@ -26,17 +26,17 @@ def test_multiple_inheritance():
 
     for C in (C1, C2):
         logging.info("Testing %s", C)
-        ctype = C.__xpmtype__
+        ctype = C.__getxpmtype__()
         assert issubclass(C, A)
         assert issubclass(C, B)
         assert issubclass(C, B1)
 
-        assert ctype.objecttype == C.__xpmtype__.objecttype
+        assert ctype.value_type == C.__getxpmtype__().value_type
 
-        assert issubclass(C.__xpmtype__.objecttype, B1.__xpmtype__.basetype)
-        assert issubclass(C.__xpmtype__.objecttype, B.__xpmtype__.basetype)
-        assert issubclass(C.__xpmtype__.objecttype, A.__xpmtype__.basetype)
-        assert not issubclass(C.__xpmtype__.objecttype, ConfigMixin)
+        assert issubclass(C.__getxpmtype__().value_type, B1.__getxpmtype__().value_type)
+        assert issubclass(C.__getxpmtype__().value_type, B.__getxpmtype__().value_type)
+        assert issubclass(C.__getxpmtype__().value_type, A.__getxpmtype__().value_type)
+        assert not issubclass(C.__getxpmtype__().value_type, ConfigMixin)
 
 
 def test_missing_hierarchy():
@@ -49,7 +49,7 @@ def test_missing_hierarchy():
     class B(A1):
         pass
 
-    B.__xpmtype__
+    B.__getxpmtype__()
 
     assert issubclass(B, A)
     assert issubclass(B, A1)
@@ -59,7 +59,7 @@ def test_types_union():
     class A(Config):
         x: Param[Union[int, str]]
 
-    A(x=1)
-    A(x="hello")
+    A.C(x=1)
+    A.C(x="hello")
     with pytest.raises(ValueError):
-        A(x=[])
+        A.C(x=[])

experimaestro/tests/test_validation.py

@@ -36,22 +36,22 @@ class C(Config):
 
 
 def test_validation_simple():
-    expect_validate(A(value=1))
+    expect_validate(A.C(value=1))
 
 
 def test_validation_missing():
-    expect_notvalidate(A())
+    expect_notvalidate(A.C())
 
 
 def test_validation_simple_nested():
-    b = B()
-    b.a = A(value=1)
+    b = B.C()
+    b.a = A.C(value=1)
     expect_validate(b)
 
 
 def test_validation_missing_nested():
-    b = B()
-    b.a = A()
+    b = B.C()
+    b.a = A.C()
     expect_notvalidate(b)
 
 
@@ -68,11 +68,11 @@ def test_validation_type():
         __xpmid__ = valns.type.c
 
     with pytest.raises(ValueError):
-        C(a=B())
+        C.C(a=B.C())
 
     with pytest.raises(ValueError):
-        c = C()
-        c.a = B()
+        c = C.C()
+        c.a = B.C()
 
 
 def test_validation_subtype():
@@ -86,7 +86,7 @@ def test_validation_subtype():
         __xpmid__ = valns.subtype.b
         a: Param[A]
 
-    expect_validate(B(a=A1()))
+    expect_validate(B.C(a=A1.C()))
 
 
 def test_validation_path_generator():
@@ -96,7 +96,7 @@ def test_validation_path_generator():
         __xpmid__ = valns.path.a
         value: Meta[Path] = field(default_factory=PathGenerator("file.txt"))
 
-    a = A()
+    a = A.C()
     a.__xpm__.validate()
     with TemporaryExperiment("constant") as xp:
         jobcontext = Job(a)
@@ -116,7 +116,7 @@ def test_validation_constant():
         __xpmid__ = valns.constant.a
         value: Constant[int] = 1
 
-    a = A()
+    a = A.C()
     a.__xpm__.validate()
     with TemporaryExperiment("constant"):
         joba = Job(a)
@@ -133,7 +133,7 @@ class Child(Parent):
 
 
 def test_validation_child():
-    expect_validate(Child(x=1))
+    expect_validate(Child.C(x=1))
 
 
 # --- Path argument checks
@@ -144,7 +144,7 @@ class PathParent(Config):
 
 
 def test_validation_path_option():
-    c = PathParent()
+    c = PathParent.C()
     expect_validate(c)
 
 
@@ -157,7 +157,7 @@ def test_validation_seal():
     class A(Config):
         a: Param[int]
 
-    a = A(a=2)
+    a = A.C(a=2)
     a.__xpm__.seal(EmptyContext())
 
     with pytest.raises(AttributeError):
@@ -174,10 +174,10 @@ def test_validation_validation_enum():
     class EnumConfig(Config):
         a: Param[EnumParam]
 
-    expect_validate(EnumConfig(a=EnumParam.FIRST))
+    expect_validate(EnumConfig.C(a=EnumParam.FIRST))
 
     try:
-        EnumConfig(a=1)
+        EnumConfig.C(a=1)
         assert False, "Enum value should be rejected"
     except AssertionError:
         pass
@@ -199,7 +199,7 @@ class TaskConfigConsumer(Config):
 
 
 def test_validation_taskargument():
-    x = taskconfig()
+    x = taskconfig.C()
     with TemporaryExperiment("fake"):
         x.submit(run_mode=RunMode.DRY_RUN)
-        expect_validate(TaskConfigConsumer(x=x))
+        expect_validate(TaskConfigConsumer.C(x=x))

experimaestro/tests/token_reschedule.py

@@ -31,7 +31,7 @@ if __name__ == "__main__":
         logging.info("Reschedule with token [%s]: starting task in %s", x, workdir)
         token = xp.workspace.connector.createtoken("test-token-reschedule", 1)
         task = (
-            TokenTask(path=lockingpath, x=int(x))
+            TokenTask.C(path=lockingpath, x=int(x))
             .add_dependencies(token.dependency(1))
             .submit()
         )

experimaestro/utils/multiprocessing.py

@@ -0,0 +1,44 @@
+import logging
+import multiprocessing as mp
+import time
+import os
+import signal
+import threading
+
+
+def delayed_shutdown(delay=60, *, exit_code=1, grace_period=5):
+    """After *delay*'s try a graceful stop, then SIGKILL anything left.
+
+    :param delay: Delay in seconds before killing
+    :param grace_period: Delay in seconds before force-killing a child process
+    :param exit_code: The exit code to use
+    """
+
+    def _killer():
+        time.sleep(delay)
+
+        logging.info("Stall dectected – killing all subprocesses")
+
+        # 1️⃣ Try graceful termination
+        for p in mp.active_children():
+            # sends SIGTERM / TerminateProcess
+            p.terminate()
+
+        alive = mp.active_children()
+        deadline = time.time() + grace_period
+        while alive and time.time() < deadline:
+            alive = [p for p in alive if p.is_alive()]
+            time.sleep(0.1)
+
+        # 2️⃣ Anything still alive? Nuke it.
+        for p in alive:
+            try:
+                os.kill(p.pid, signal.SIGKILL)
+            except OSError:
+                pass
+
+        # 3️⃣ Finally kill the parent
+        os.kill(os.getpid(), signal.SIGKILL)
+
+    # Start the thread (non blocking)
+    threading.Thread(target=_killer, daemon=True).start()

{experimaestro-1.10.1.dist-info → experimaestro-2.0.0rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: experimaestro
-Version: 1.10.1
+Version: 2.0.0rc0
 Summary: "Experimaestro is a computer science experiment manager"
 License: GPL-3
 Keywords: experiment manager