experimaestro 1.6.1__py3-none-any.whl → 1.15.2__py3-none-any.whl

experimaestro/tests/test_experiment.py

@@ -0,0 +1,73 @@
+from experimaestro import Task, Param, get_experiment, tag
+from experimaestro.tests.utils import TemporaryDirectory, TemporaryExperiment
+
+
+class TaskA(Task):
+    def execute(self):
+        pass
+
+
+class TaskB(Task):
+    task_a: Param[TaskA]
+    x: Param[int]
+
+    def execute(self):
+        pass
+
+
+# xp = get_experiment(id="my-xp-1")
+
+# # Returns a list of tasks which were submitted and successful
+# tasks = xp.get_tasks(myxps.evaluation.Evaluation, status=Job.DONE)
+
+# for task in tasks:
+#     # Look at the tags
+#     print(task.tags)
+
+#     # Get some information
+#     print("Task ran in {task.workdir}")
+
+#     # Look at the parent jobs
+#    print(task.depends_on)
+
+#    # Look at the dependant
+#    print(task.dependents)
+
+
+def test_experiment_history():
+    """Test retrieving experiment history"""
+    with TemporaryDirectory() as workdir:
+        with TemporaryExperiment("experiment", workdir=workdir):
+            task_a = TaskA().submit()
+            TaskB(task_a=task_a, x=tag(1)).submit()
+
+        # Look at the experiment
+        xp = get_experiment("experiment", workdir=workdir)
+
+        (task_a_info,) = xp.get_jobs(TaskA)
+        (task_b_info,) = xp.get_jobs(TaskB)
+        assert task_b_info.tags == {"x": 1}
+        assert task_b_info.depends_on == [task_a_info]
+
+
+class FlagHandler:
+    def __init__(self):
+        self.flag = False
+
+    def set(self):
+        self.flag = True
+
+    def is_set(self):
+        return self.flag
+
+
+def test_experiment_events():
+    """Test handlers"""
+
+    flag = FlagHandler()
+    with TemporaryExperiment("experiment"):
+        task_a = TaskA()
+        task_a.submit()
+        task_a.on_completed(flag.set)
+
+    assert flag.is_set()

experimaestro/tests/test_findlauncher.py

@@ -3,9 +3,9 @@ from experimaestro.launcherfinder.specs import (
     CPUSpecification,
     CudaSpecification,
     HostSpecification,
+    RequirementUnion,
     cpu,
     cuda_gpu,
-    HostSimpleRequirement,
 )
 from experimaestro.launcherfinder import parse
 from humanfriendly import parse_size, parse_timespan
@@ -39,6 +39,11 @@ def test_findlauncher_specs():
     assert m is not None
     assert m.requirement is req2
 
+    # Multiply
+    req2 = req.multiply_duration(2)
+    for i in range(2):
+        assert req2.requirements[i].duration == req.requirements[i].duration * 2
+
 
 def test_findlauncher_specs_gpu_mem():
     host = HostSpecification(
@@ -60,8 +65,10 @@ def test_findlauncher_specs_gpu_mem():
 
 
 def test_findlauncher_parse():
-    (r,) = parse("""duration=4 d & cuda(mem=4G) * 2 & cpu(mem=400M, cores=4)""")
-    assert isinstance(r, HostSimpleRequirement)
+    r = parse("""duration=4 d & cuda(mem=4G) * 2 & cpu(mem=400M, cores=4)""")
+    assert isinstance(r, RequirementUnion)
+
+    r = r.requirements[0]
 
     assert len(r.cuda_gpus) == 2
     assert r.cuda_gpus[0].memory == parse_size("4G")
@@ -79,7 +86,7 @@ def slurm_constraint_split(constraint: str):
 
 
 def test_findlauncher_slurm():
-    path = ResourcePathWrapper.create(f"{__package__ }.launchers", "config_slurm")
+    path = ResourcePathWrapper.create(f"{__package__}.launchers", "config_slurm")
 
     assert (path / "launchers.py").is_file()
 

experimaestro/tests/test_forward.py

@@ -1,12 +1,12 @@
-from experimaestro import argument, Config
+from experimaestro import Param, Config
 from experimaestro.click import forwardoption
 import click
 
 
 def test_main():
-    @argument("epochs", type=int, default=100, help="Number of learning epochs")
     class MyModel(Config):
-        pass
+        epochs: Param[int] = 100
+        """Number of learning epochs"""
 
     @forwardoption.epochs(MyModel)
     @click.command()
@@ -18,9 +18,9 @@ def test_main():
 
 
 def test_rename():
-    @argument("epochs", type=int, default=100, help="Number of learning epochs")
     class MyModel(Config):
-        pass
+        epochs: Param[int] = 100
+        """Number of learning epochs"""
 
     @forwardoption.epochs(MyModel, "my-epochs")
     @click.command()

experimaestro/tests/test_generators.py

@@ -0,0 +1,93 @@
+from experimaestro import Config, Task, Param, Meta, Path, field, PathGenerator
+from experimaestro.scheduler.workspace import Workspace
+from experimaestro.settings import Settings, WorkspaceSettings
+import pytest
+from experimaestro.scheduler import RunMode
+
+
+class Validation(Config):
+    best_checkpoint: Meta[Path] = field(default_factory=PathGenerator("index"))
+
+
+class Learner(Task):
+    validation: Param[Validation]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return Learner.C(x=x, validation=validation)
+
+
+class LearnerList(Task):
+    validation: Param[list[Validation]]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return LearnerList.C(x=x, validation=[validation])
+
+
+class LearnerDict(Task):
+    validation: Param[dict[str, Validation]]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return LearnerDict.C(x=x, validation={"key": validation})
+
+
+class ModuleLoader(Task):
+    validation: Param[Validation] = field(ignore_generated=True)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_reuse_on_submit(cls):
+    # We have one way to select the best model
+    validation = Validation.C()
+
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_reuse", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+
+    # OK, the path is generated depending on Learner with x=1
+    cls.create(1, validation).submit(workspace=workspace)
+
+    with pytest.raises((AttributeError)):
+        # Here we have a problem...
+        # the path is still the previous one
+        cls.create(2, validation).submit(workspace=workspace)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_delayed_submit(cls):
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_simple", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+    validation = Validation.C()
+    task1 = cls.create(1, validation)
+    task2 = cls.create(2, validation)
+    task1.submit(workspace=workspace)
+    with pytest.raises((AttributeError)):
+        task2.submit(workspace=workspace)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_reuse_on_set(cls):
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_simple", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+    validation = Validation.C()
+    cls.create(1, validation).submit(workspace=workspace)
+    with pytest.raises((AttributeError)):
+        # We should not be able to *create* a second task with the same validation,
+        # even without submitting it
+        cls.create(2, validation)
+
+    # This should run OK
+    ModuleLoader.C(validation=validation)

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,50 +68,54 @@ 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_identifier_different_type():
+    assert_notequal(A.C(a=1), B.C(a=1))
 
 
-def test_different_type():
-    assert_notequal(A(a=1), B(a=1))
+def test_identifier_order():
+    assert_equal(Values.C(value1=1, value2=2), Values.C(value2=2, value1=1))
 
 
-def test_order():
-    assert_equal(Values(value1=1, value2=2), Values(value2=2, value1=1))
+def test_identifier_default():
+    assert_equal(C.C(a=1, b=2), C.C(b=2))
 
 
-def test_default():
-    assert_equal(C(a=1, b=2), C(b=2))
+def test_identifier_default_field():
+    assert_equal(CField(a=1, b=2), CField(b=2))
 
 
-def test_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_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_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_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))
@@ -119,9 +125,9 @@ def test_name():
 # --- 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
 
@@ -152,13 +158,12 @@ def test_identifier_dict():
 # --- 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"))
@@ -167,23 +172,23 @@ def test_path():
 # --- 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))
 
 
 def test_identifier_enum():
-    """Path arguments should be ignored"""
+    """test enum parameters"""
     from enum import Enum
 
     class EnumParam(Enum):
@@ -214,25 +219,24 @@ def test_identifier_addnone():
     assert_notequal(A_with_b(b=B(x=1)), A())
 
 
-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
+
+    class A(Config):
+        __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))
 
 
-def test_taskconfigidentifier():
+def test_identifier_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -254,21 +258,21 @@ def test_taskconfigidentifier():
     )
 
 
-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())
 
-    @config("test.constant")
-    class A2:
+    class A2(Config):
+        __xpmid__ = "test.constant"
         version: Constant[int] = 2
 
     assert_notequal(A1(), A2())
@@ -382,36 +386,6 @@ def test_identifier_meta_default_array():
     )
 
 
-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)
-    )
-    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():
     class MyConfig(Config):
         pass
@@ -422,26 +396,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()],
     )
-    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()],
     )
-    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()],
     )
 
-    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 +474,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
@@ -542,9 +557,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,21 +1,18 @@
 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]
 
 
@@ -24,10 +21,10 @@ def test_simple_instance():
     b = B(a=a)
     b = b.instance()
 
-    assert not isinstance(b, TypeConfig)
+    assert not isinstance(b, ConfigMixin)
     assert isinstance(b, B.__xpmtype__.objecttype)
 
-    assert not isinstance(b.a, TypeConfig)
+    assert not isinstance(b.a, ConfigMixin)
     assert isinstance(b.a, A1.__xpmtype__.objecttype)
     assert isinstance(b.a, A.__xpmtype__.basetype)
 
@@ -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]]