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

experimaestro/tests/test_objects.py

@@ -1,9 +1,10 @@
+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 TypeConfig
+from experimaestro.core.objects import ConfigMixin
 from experimaestro.core.types import XPMValue
 from experimaestro.generators import pathgenerator
 from experimaestro.scheduler.workspace import RunMode
@@ -65,9 +66,9 @@ def test_hierarchy():
     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)
 
@@ -91,3 +92,18 @@ 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_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]
@@ -179,8 +179,7 @@ def test_config_class():
 
 
 def test_constant():
-    @config()
-    class A:
+    class A(Config):
         x: Constant[int] = 2
 
     a = A()
@@ -224,16 +223,14 @@ def test_inheritance():
 
 
 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
 
@@ -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().x == 1
+
+
+class ConfigWithDefaultFactory(Config):
+    x: Param[int] = field(default_factory=lambda: 1)
+
+
+def test_param_default_factory():
+    value = ConfigWithDefaultFactory()
+    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().instance().x == 2
+    assert A0(x=3).instance().x == 3
+
+    class A(Config):
+        x: Param[int] = field(default_factory=lambda: 2)
+
+    assert A().instance().x == 2
+
+    assert A(x=3).instance().x == 3
 
 
 # --- Handling help annotations

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_tags.py

@@ -3,8 +3,6 @@ from pathlib import Path
 from experimaestro import (
     tag,
     LightweightTask,
-    config,
-    argument,
     Config,
     Task,
     Param,
@@ -13,17 +11,13 @@ 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():

experimaestro/tests/test_tasks.py

@@ -123,9 +123,16 @@ 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():
@@ -299,26 +306,6 @@ 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()

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 (
@@ -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
 

experimaestro/tests/test_types.py

@@ -1,37 +1,32 @@
 # --- 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.C.__xpmtype__
         assert issubclass(C, A)
         assert issubclass(C, B)
         assert issubclass(C, B1)
@@ -41,22 +36,30 @@ def test_multiple_inheritance():
         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 not issubclass(C.__xpmtype__.objecttype, ConfigMixin)
 
 
 def test_missing_hierarchy():
-    @config()
-    class A:
+    class A(Config):
         pass
 
     class A1(A):
         pass
 
-    @config()
     class B(A1):
         pass
 
-    B.__xpmtype__
+    B.C.__xpmtype__
 
     assert issubclass(B, A)
     assert issubclass(B, A1)
+
+
+def test_types_union():
+    class A(Config):
+        x: Param[Union[int, str]]
+
+    A(x=1)
+    A(x="hello")
+    with pytest.raises(ValueError):
+        A(x=[])