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

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

@@ -7,7 +7,7 @@ import time
 from pathlib import Path
 
 import subprocess
-from experimaestro import Task, param
+from experimaestro import Task, Param
 from experimaestro.tokens import CounterToken, TokenFile
 from experimaestro.scheduler import JobState
 from .utils import (
@@ -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())
@@ -74,8 +74,9 @@ def test_token_ok():
     logging.info("Finished token_ok test")
 
 
-@param("x", type=int)
 class dummy_task(Task):
+    x: Param[int]
+
     def execute(self):
         pass
 
@@ -85,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
@@ -97,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()
 
@@ -117,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"
@@ -135,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(
@@ -240,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

@@ -1,62 +1,65 @@
 # --- Task and types definitions
 
 import logging
-from experimaestro import Config, config
-from experimaestro.core.objects import TypeConfig
+from experimaestro import Config, Param
+from typing import Union
 
-from .utils import TemporaryExperiment
-from experimaestro.scheduler import JobState
+import pytest
+from experimaestro.core.objects import ConfigMixin
 
 
 def test_multiple_inheritance():
-    @config()
-    class A:
+    class A(Config):
         pass
 
-    @config()
-    class B:
+    class B(Config):
         pass
 
-    @config()
     class B1(B):
         pass
 
-    @config()
     class C1(B1, A):
         pass
 
-    @config()
     class C2(A, B1):
         pass
 
     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, TypeConfig)
+        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():
-    @config()
-    class A:
+    class A(Config):
         pass
 
     class A1(A):
         pass
 
-    @config()
     class B(A1):
         pass
 
-    B.__xpmtype__
+    B.__getxpmtype__()
 
     assert issubclass(B, A)
     assert issubclass(B, A1)
+
+
+def test_types_union():
+    class A(Config):
+        x: Param[Union[int, str]]
+
+    A.C(x=1)
+    A.C(x="hello")
+    with pytest.raises(ValueError):
+        A.C(x=[])

experimaestro/tests/test_validation.py

@@ -2,18 +2,9 @@
 
 import pytest
 from pathlib import Path
-from experimaestro import (
-    config,
-    Task,
-    Identifier,
-    argument,
-    pathoption,
-    ConstantParam,
-    Param,
-    Config,
-)
+from experimaestro import Task, field, Identifier, Constant, Param, Config, Meta
 from enum import Enum
-import experimaestro.core.types as types
+from experimaestro.generators import PathGenerator
 from experimaestro.scheduler import Job, JobContext
 from experimaestro.scheduler.workspace import RunMode
 from .utils import TemporaryExperiment
@@ -31,92 +22,81 @@ def expect_notvalidate(value):
         value.__xpm__.validate()
 
 
-@argument("value", type=int)
-@config()
-class A:
-    pass
+class A(Config):
+    value: Param[int]
 
 
-@argument("a", type=A)
-@config()
-class B:
-    pass
+class B(Config):
+    a: Param[A]
 
 
-@pathoption("path", "outdir")
-@config()
-class C:
+class C(Config):
+    path: Meta[Path] = field(default_factory=PathGenerator("outdir"))
     pass
 
 
-def test_simple():
-    expect_validate(A(value=1))
+def test_validation_simple():
+    expect_validate(A.C(value=1))
 
 
-def test_missing():
-    expect_notvalidate(A())
+def test_validation_missing():
+    expect_notvalidate(A.C())
 
 
-def test_simple_nested():
-    b = B()
-    b.a = A(value=1)
+def test_validation_simple_nested():
+    b = B.C()
+    b.a = A.C(value=1)
     expect_validate(b)
 
 
-def test_missing_nested():
-    b = B()
-    b.a = A()
+def test_validation_missing_nested():
+    b = B.C()
+    b.a = A.C()
     expect_notvalidate(b)
 
 
-def test_type():
-    @config(valns.type.a)
-    class A:
+def test_validation_type():
+    class A(Config):
+        __xpmid__ = valns.type.a
         pass
 
-    @config(valns.type.b)
-    class B:
-        pass
+    class B(Config):
+        __xpmid__ = valns.type.b
 
-    @argument("a", A)
-    @config(valns.type.c)
-    class C:
-        pass
+    class C(Config):
+        a: Param[A]
+        __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_subtype():
-    @config(valns.subtype.a)
-    class A:
-        pass
+def test_validation_subtype():
+    class A(Config):
+        __xpmid__ = valns.subtype.a
 
-    @config(valns.subtype.a1)
     class A1(A):
-        pass
+        __xpmid__ = valns.subtype.a1
 
-    @argument("a", A)
-    @config(valns.subtype.b)
-    class B:
-        pass
+    class B(Config):
+        __xpmid__ = valns.subtype.b
+        a: Param[A]
 
-    expect_validate(B(a=A1()))
+    expect_validate(B.C(a=A1.C()))
 
 
-def test_path():
-    """Test of @pathoption"""
+def test_validation_path_generator():
+    """Test of path generator"""
 
-    @pathoption("value", "file.txt")
-    @config(valns.path.a)
-    class A:
-        pass
+    class A(Config):
+        __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)
@@ -129,15 +109,14 @@ def test_path():
         assert a.value.parents[3] == xp.workspace.path
 
 
-def test_constant():
-    """Test of @ConstantParam"""
+def test_validation_constant():
+    """Test of constant"""
 
-    @ConstantParam("value", 1)
-    @config(valns.constant.a)
-    class A:
-        pass
+    class A(Config):
+        __xpmid__ = valns.constant.a
+        value: Constant[int] = 1
 
-    a = A()
+    a = A.C()
     a.__xpm__.validate()
     with TemporaryExperiment("constant"):
         joba = Job(a)
@@ -145,69 +124,47 @@ def test_constant():
         assert a.value == 1
 
 
-@argument("x", type=int)
-@config()
-class Parent:
-    pass
+class Parent(Config):
+    x: Param[int]
 
 
-@config()
 class Child(Parent):
     pass
 
 
-def test_child():
-    expect_validate(Child(x=1))
+def test_validation_child():
+    expect_validate(Child.C(x=1))
 
 
 # --- Path argument checks
 
 
-@pathoption("x", "x")
-@config()
-class PathParent:
-    pass
+class PathParent(Config):
+    x: Meta[Path] = field(default_factory=PathGenerator("x"))
 
 
-def test_path_option():
-    c = PathParent()
+def test_validation_path_option():
+    c = PathParent.C()
     expect_validate(c)
 
 
 # --- Default value
 
 
-@pytest.mark.parametrize(
-    "value,apitype",
-    [(1.5, types.FloatType), (1, types.IntType), (False, types.BoolType)],
-)
-def test_default(value, apitype):
-    @argument("default", default=value)
-    @config(valns.default[str(type(value))])
-    class Default:
-        pass
-
-    value = Default()
-    expect_validate(value)
-    assert Default.__xpmtype__.arguments["default"].type.__class__ == apitype
-
-
-def test_seal():
+def test_validation_seal():
     """Test value sealing"""
 
-    @argument("a", int)
-    @config()
-    class A:
-        pass
+    class A(Config):
+        a: Param[int]
 
-    a = A(a=2)
+    a = A.C(a=2)
     a.__xpm__.seal(EmptyContext())
 
     with pytest.raises(AttributeError):
         a.a = 1
 
 
-def test_validation_enum():
+def test_validation_validation_enum():
     """Path arguments should be ignored"""
 
     class EnumParam(Enum):
@@ -217,10 +174,10 @@ def test_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
@@ -241,8 +198,8 @@ class TaskConfigConsumer(Config):
     x: Param[TaskParentConfig]
 
 
-def test_taskargument():
-    x = taskconfig()
+def test_validation_taskargument():
+    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()
         )