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

experimaestro/tests/test_objects.py

@@ -3,8 +3,7 @@ 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 TypeConfig
-from experimaestro.core.types import XPMValue
+from experimaestro.core.objects import ConfigMixin
 from experimaestro.generators import pathgenerator
 from experimaestro.scheduler.workspace import RunMode
 from experimaestro.tests.utils import TemporaryExperiment
@@ -27,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):
@@ -39,43 +38,37 @@ 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)
     assert issubclass(C, Config)
 
-    assert not issubclass(OA, TypeConfig)
-    assert not issubclass(OB, TypeConfig)
-    assert not issubclass(OC, TypeConfig)
+    assert not issubclass(OA, ConfigMixin)
+    assert not issubclass(OB, ConfigMixin)
+    assert not issubclass(OC, ConfigMixin)
 
     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")]
@@ -83,7 +76,7 @@ class CopyConfig(Task):
 
 
 def test_copyconfig(xp):
-    b = CopyConfig(x=2)
+    b = CopyConfig.C(x=2)
 
     b.submit()
 

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

@@ -13,14 +13,16 @@ from experimaestro.core.types import DictType, IntType, StrType
 from enum import Enum
 import pytest
 from experimaestro import (
-    config,
     Option,
     Constant,
     Param,
     Task,
     default,
+    Meta,
     Config,
     pathgenerator,
+    PathGenerator,
+    field,
     Annotated,
 )
 import experimaestro.core.types as types
@@ -29,25 +31,24 @@ from experimaestro.xpmutils import DirectoryContext
 # --- Test manual name for configuration
 
 
-@config("annotations.b")
-class B:
+class B(Config):
+    __xpmid__ = "annotations.b"
     pass
 
 
 def test_fullname():
-    assert str(B.__xpmtype__.identifier) == "annotations.b"
+    assert str(B.__getxpmtype__().identifier) == "annotations.b"
 
 
 # --- Automatic name for configuration
 
 
-@config()
-class A:
+class A(Config):
     pass
 
 
 def test_noname():
-    assert str(A.__xpmtype__.identifier) == "experimaestro.tests.test_param.a"
+    assert str(A.__getxpmtype__().identifier) == "experimaestro.tests.test_param.a"
 
 
 def serializeCycle(config: Config):
@@ -69,8 +70,7 @@ def ArgumentValue(default=None, *, help=""):
 def test_type_hinting():
     """Test for type hinting"""
 
-    @config()
-    class MyConfig:
+    class MyConfig(Config):
         """A configuration
 
         Attributes:
@@ -89,7 +89,7 @@ def test_type_hinting():
         path: Annotated[Path, pathgenerator("world")]
         option: Option[str]
 
-    ot = MyConfig.__xpmtype__
+    ot = MyConfig.__getxpmtype__()
 
     # Check required parameter
     arg_x = ot.getArgument("x")
@@ -139,7 +139,7 @@ def test_type_hinting():
 
 def test_generatedpath():
     class A(Config):
-        path: Annotated[Path, pathgenerator("test.txt")]
+        path: Meta[Path] = field(default_factory=PathGenerator("test.txt"))
 
     class B(Config):
         a: Param[A]
@@ -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,16 +174,15 @@ 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
 
 
 def test_constant():
-    @config()
-    class A:
+    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
@@ -203,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)
@@ -217,23 +216,21 @@ 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
 
 
 def test_redefined_param():
-    @config()
-    class A:
+    class A(Config):
         x: Param[int]
 
-    @config()
-    class B:
+    class B(Config):
         x: Param[int] = 3
 
-    atx = A.C.__xpmtype__.getArgument("x")
-    btx = B.C.__xpmtype__.getArgument("x")
+    atx = A.C.__getxpmtype__().getArgument("x")
+    btx = B.C.__getxpmtype__().getArgument("x")
 
     assert atx.required
 
@@ -250,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"})
@@ -258,18 +255,59 @@ def test_param_dict():
         A(x={"wrong": 1.2})
 
 
+# --- Default
+
+
+class ConfigWithDefault(Config):
+    x: Param[int] = field(default=1)
+
+
+def test_param_default():
+    assert ConfigWithDefault.C().x == 1
+
+
+class ConfigWithDefaultFactory(Config):
+    x: Param[int] = field(default_factory=lambda: 1)
+
+
+def test_param_default_factory():
+    value = ConfigWithDefaultFactory.C()
+    context = DirectoryContext(Path("/__fakepath__"))
+    value.__xpm__.seal(context)
+    assert value.x == 1
+
+
 # --- Task annotations
 
 
 def test_default_mismatch():
     """Test mismatch between default and type"""
 
-    @config()
-    class A:
+    class A(Config):
         x: Param[int] = 0.2
 
     with pytest.raises(TypeError):
-        A.__xpmtype__.getArgument("x")
+        A.__getxpmtype__().getArgument("x")
+
+
+# --- Handling default with field
+
+
+def test_param_default_set():
+    """Test that the default setting is well set"""
+
+    class A0(Config):
+        x: Param[int] = 2
+
+    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.C().instance().x == 2
+
+    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,70 +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 TypeConfig
-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()
+from experimaestro.core.objects import ConfigMixin
 
 
 class Object1(Config):
@@ -78,17 +20,35 @@ class Object2(Config):
 def test_serializers_serialization():
     context = SerializationContext(save_directory=None)
 
-    obj1 = Object1()
-    obj2 = Object2(object=obj1)
+    obj1 = Object1.C()
+    obj2 = Object2.C(object=obj1)
 
     data = state_dict(context, [obj1, obj2])
 
     [obj1, obj2] = from_state_dict(data)
-    assert isinstance(obj1, Object1) and isinstance(obj1, TypeConfig)
+    assert isinstance(obj1, Object1) and isinstance(obj1, ConfigMixin)
     assert isinstance(obj2, Object2)
     assert obj2.object is obj1
 
     [obj1, obj2] = from_state_dict(data, as_instance=True)
-    assert isinstance(obj1, Object1) and not isinstance(obj1, TypeConfig)
+    assert isinstance(obj1, Object1) and not isinstance(obj1, ConfigMixin)
     assert isinstance(obj2, Object2)
     assert obj2.object is obj1
+
+
+class SubConfig(Config):
+    pass
+
+
+class MultiParamObject(Config):
+    opt_a: Param[Optional[int]]
+
+    x: Param[dict[str, Optional[SubConfig]]]
+
+
+def test_serializers_types():
+    context = SerializationContext(save_directory=None)
+
+    config = MultiParamObject.C(x={"a": None})
+    config.__xpm__.seal(context)
+    state_dict(context, config)

experimaestro/tests/test_ssh.py

@@ -1,14 +1,18 @@
+import sys
+import pytest
 from experimaestro.connectors.ssh import SshPath
 
 # --- Test SSH path and SSH path manipulation
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 12), reason="requires python3.10 or higher")
 def test_absolute():
     path = SshPath("ssh://host//a/path")
     assert path.host == "host"
     assert path.is_absolute()
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 12), reason="requires python3.10 or higher")
 def test_relative():
     path = SshPath("ssh://host")
     assert path.host == "host"
@@ -17,6 +21,7 @@ def test_relative():
     assert not path.is_absolute()
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 12), reason="requires python3.10 or higher")
 def test_relative_withpath():
     path = SshPath("ssh://host/relative/path")
     assert path.host == "host"
@@ -24,6 +29,7 @@ def test_relative_withpath():
     assert not path.is_absolute()
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 12), reason="requires python3.10 or higher")
 def test_relative_absolute():
     path = SshPath("ssh://host") / "/absolute/path"
     assert path.host == "host"
@@ -31,6 +37,7 @@ def test_relative_absolute():
     assert path.is_absolute()
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 12), reason="requires python3.10 or higher")
 def test_relative_compose():
     path = SshPath("ssh://host/abc") / "relative/path"
     assert path.host == "host"

experimaestro/tests/test_tags.py

@@ -2,8 +2,7 @@ from typing import Dict
 from pathlib import Path
 from experimaestro import (
     tag,
-    config,
-    argument,
+    LightweightTask,
     Config,
     Task,
     Param,
@@ -12,34 +11,30 @@ from experimaestro.scheduler.workspace import RunMode
 from experimaestro.xpmutils import DirectoryContext
 
 
-@argument("x", type=int)
-@config()
-class Config1:
-    pass
+class Config1(Config):
+    x: Param[int]
 
 
-@argument("x", type=int)
-@argument("c", type=Config1)
-@config()
-class Config2:
-    pass
+class Config2(Config):
+    x: Param[int]
+    c: Param[Config1]
 
 
 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}
 
@@ -55,20 +50,54 @@ 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"}
 
 
+def test_tags_init_tasks():
+    """Test tags within init tasks"""
+
+    class MyTask(Task):
+        pass
+
+    class InitTask(LightweightTask):
+        pass
+
+    class MyConfig(Config):
+        pass
+
+    class TaskWithOutput(Task):
+        x: Param[MyConfig]
+
+        def task_outputs(self, dep) -> MyConfig:
+            return dep(MyConfig.C())
+
+    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.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.C().submit(run_mode=RunMode.DRY_RUN, init_tasks=[result])
+    assert result.tags() == {"hello": "world"}
+
+
 class TaskDirectoryContext(DirectoryContext):
     def __init__(self, task, path):
         super().__init__(path)
@@ -86,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}