experimaestro 1.11.1__py3-none-any.whl → 2.0.0b4__py3-none-any.whl

experimaestro/tests/test_objects.py

@@ -1,11 +1,9 @@
-import logging
 from pathlib import Path
 
 import pytest
-from experimaestro import Config, Task, Annotated, copyconfig, default
+from experimaestro import Config, Task, Annotated, copyconfig, field
 from experimaestro.core.arguments import Param
 from experimaestro.core.objects import ConfigMixin
-from experimaestro.core.types import XPMValue
 from experimaestro.generators import pathgenerator
 from experimaestro.scheduler.workspace import RunMode
 from experimaestro.tests.utils import TemporaryExperiment
@@ -18,17 +16,17 @@ def xp():
 
 
 class A(Config):
-    x: Param[int] = 3
+    x: Param[int] = field(ignore_default=3)
 
 
 def test_object_default():
     """Test plain default value"""
-    a = A()
+    a = A.C()
     assert a.x == 3
 
 
 class B(Config):
-    a: Param[A] = A(x=3)
+    a: Param[A] = field(ignore_default=A.C(x=3))
 
 
 class C(B):
@@ -40,27 +38,26 @@ class D(B, A):
 
 
 class DefaultAnnotationConfig(Config):
-    a: Annotated[A, default(A(x=3))]
+    a: Param[A] = field(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)
@@ -72,11 +69,6 @@ def test_hierarchy():
 
     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")]
@@ -84,7 +76,7 @@ class CopyConfig(Task):
 
 
 def test_copyconfig(xp):
-    b = CopyConfig(x=2)
+    b = CopyConfig.C(x=2)
 
     b.submit()
 
@@ -94,16 +86,308 @@ def test_copyconfig(xp):
     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"
+# --- Composition operator tests (GH #33) ---
+
+
+class CompositionA(Config):
+    x: Param[int]
+
+
+class CompositionSubA(CompositionA):
+    """Subclass of CompositionA"""
+
+    y: Param[int] = field(ignore_default=0)
+
+
+class CompositionB(Config):
+    a: Param[CompositionA]
+
+
+class CompositionC(Config):
+    """Config with two parameters of same type - should be ambiguous"""
+
+    a1: Param[CompositionA]
+    a2: Param[CompositionA]
+
+
+class CompositionD(Config):
+    """Config with no matching parameter"""
+
+    x: Param[int]
+
+
+class CompositionE(Config):
+    """Config with two parameters, one subclass of the other"""
+
+    base: Param[CompositionA]
+    sub: Param[CompositionSubA]
+
+
+def test_composition_operator():
+    """Test that B() @ A(x=1) is equivalent to B(a=A(x=1))"""
+    a = CompositionA.C(x=42)
+    b = CompositionB.C() @ a
+
+    assert b.a is a
+    assert b.a.x == 42
+
+
+def test_composition_operator_chained():
+    """Test chaining composition operators
+
+    Chaining A @ B @ C adds both B and C to A (same outer config).
+    For nested structures, use parentheses: A @ (B @ C)
+    """
+
+    class MultiParam(Config):
+        a: Param[CompositionA]
+        b: Param[CompositionB]
+
+    # Chaining adds multiple configs to same outer config
+    result = MultiParam.C() @ CompositionA.C(x=10) @ CompositionB.C()
+
+    assert result.a.x == 10
+    assert result.b is not None
+
+
+def test_composition_operator_nested():
+    """Test nested composition with parentheses"""
+
+    class Outer(Config):
+        b: Param[CompositionB]
+
+    # For nested structures, use parentheses
+    result = Outer.C() @ (CompositionB.C() @ CompositionA.C(x=10))
+
+    assert result.b.a.x == 10
+
+
+def test_composition_operator_ambiguous():
+    """Test that ambiguous composition raises ValueError"""
+    a = CompositionA.C(x=1)
+
+    with pytest.raises(ValueError, match="Ambiguous"):
+        CompositionC.C() @ a
+
+
+def test_composition_operator_no_match():
+    """Test that composition with no matching param raises ValueError"""
+    a = CompositionA.C(x=1)
+
+    with pytest.raises(ValueError, match="No parameter"):
+        CompositionD.C() @ a
+
+
+def test_composition_operator_subclass():
+    """Test composition works with subclasses"""
+    sub_a = CompositionSubA.C(x=5, y=10)
+    b = CompositionB.C() @ sub_a
+
+    assert b.a is sub_a
+    assert b.a.x == 5
+
+
+def test_composition_operator_subclass_hierarchy():
+    """Test composition when two params have subclass relationship
+
+    When CompositionSubA is passed, both 'base' (CompositionA) and 'sub'
+    (CompositionSubA) match. This should be ambiguous since both accept it.
+    """
+    sub_a = CompositionSubA.C(x=1, y=2)
+
+    # SubA matches both base (CompositionA) and sub (CompositionSubA)
+    with pytest.raises(ValueError, match="Ambiguous"):
+        CompositionE.C() @ sub_a
+
+
+def test_composition_operator_exact_match():
+    """Test composition when base class instance matches only base param"""
+    # CompositionA matches only 'base', not 'sub' (which requires SubA)
+    a = CompositionA.C(x=1)
+    e = CompositionE.C() @ a
+
+    assert e.base is a
+    assert e.base.x == 1
+
+
+# --- Value class decorator tests (GH #99) ---
+
+# Test 1: Basic value class registration
+
+
+class ValueBasicModel(Config):
+    x: Param[int] = field(ignore_default=1)
+
+
+@ValueBasicModel.value_class()
+class ValueBasicModelImpl(ValueBasicModel):
+    def compute(self):
+        return self.x * 2
+
+
+# Test 2: Subclass without explicit value class
+
+
+class ValueInheritBase(Config):
+    x: Param[int] = field(ignore_default=1)
+
+
+@ValueInheritBase.value_class()
+class ValueInheritBaseImpl(ValueInheritBase):
+    pass
+
+
+class ValueInheritSubNoExplicit(ValueInheritBase):
+    """Subclass without explicit value class"""
+
+    y: Param[int] = field(ignore_default=2)
+
+
+# Test 3: Value class with proper inheritance
+
+
+class ValueInheritParent(Config):
+    x: Param[int] = field(ignore_default=1)
+
+
+@ValueInheritParent.value_class()
+class ValueInheritParentImpl(ValueInheritParent):
+    def compute(self):
+        return self.x * 2
+
+
+class ValueInheritChild(ValueInheritParent):
+    y: Param[int] = field(ignore_default=2)
+
+
+@ValueInheritChild.value_class()
+class ValueInheritChildImpl(ValueInheritChild, ValueInheritParentImpl):
+    def compute_both(self):
+        return self.x + self.y
+
+
+# Test 4: Skip intermediate class (A -> B -> C, only A and C have value classes)
+
+
+class ValueSkipBase(Config):
+    x: Param[int] = field(ignore_default=1)
+
+
+@ValueSkipBase.value_class()
+class ValueSkipBaseImpl(ValueSkipBase):
+    def compute(self):
+        return self.x * 2
+
+
+class ValueSkipIntermediate(ValueSkipBase):
+    """Intermediate class without explicit value class"""
+
+    y: Param[int] = field(ignore_default=2)
+
+
+class ValueSkipDeep(ValueSkipIntermediate):
+    """Deep subclass with value class"""
+
+    z: Param[int] = field(ignore_default=3)
+
+
+@ValueSkipDeep.value_class()
+class ValueSkipDeepImpl(ValueSkipDeep, ValueSkipBaseImpl):
+    def compute_all(self):
+        return self.x + self.y + self.z
+
+
+# --- Value class tests ---
+
+
+def test_value_decorator_basic():
+    """Test basic value class registration"""
+    # XPMValue should return the registered value class
+    assert ValueBasicModel.XPMValue is ValueBasicModelImpl
+
+    # Creating an instance should use the value class
+    config = ValueBasicModel.C(x=5)
+    instance = config.instance()
+
+    assert isinstance(instance, ValueBasicModelImpl)
+    assert instance.x == 5
+    assert instance.compute() == 10
+
+
+def test_value_decorator_inheritance_no_explicit():
+    """Test that subclass without value class uses config class as value"""
+    # SubModel has no explicit value class, XPMValue returns the config class
+    assert ValueInheritSubNoExplicit.XPMValue is ValueInheritSubNoExplicit
+
+    config = ValueInheritSubNoExplicit.C(x=3, y=4)
+    instance = config.instance()
+
+    # Instance is created from the config class (no explicit value type)
+    assert isinstance(instance, ValueInheritSubNoExplicit)
+    assert instance.x == 3
+    assert instance.y == 4
+
+
+def test_value_decorator_inheritance_with_explicit():
+    """Test value class with proper inheritance from parent value class"""
+    assert ValueInheritChild.XPMValue is ValueInheritChildImpl
+
+    config = ValueInheritChild.C(x=3, y=4)
+    instance = config.instance()
+
+    assert isinstance(instance, ValueInheritChildImpl)
+    assert isinstance(instance, ValueInheritParentImpl)
+    assert instance.x == 3
+    assert instance.y == 4
+    assert instance.compute() == 6  # From parent value class
+    assert instance.compute_both() == 7  # From this value class
+
+
+def test_value_decorator_must_be_subclass():
+    """Test that value class must be subclass of config"""
+
+    class LocalModel(Config):
+        x: Param[int]
+
+    class OtherConfig(Config):
+        z: Param[int]
+
+    with pytest.raises(TypeError, match="must be a subclass of"):
+
+        @LocalModel.value_class()
+        class InvalidValue(OtherConfig):  # Not a subclass of LocalModel
+            pass
+
+
+def test_value_decorator_must_inherit_parent_value():
+    """Test that value class must inherit from parent value class"""
+
+    class LocalBase(Config):
+        x: Param[int] = field(ignore_default=1)
+
+    @LocalBase.value_class()
+    class LocalBaseImpl(LocalBase):
+        pass
+
+    class LocalChild(LocalBase):
+        y: Param[int] = field(ignore_default=2)
+
+    with pytest.raises(TypeError, match="must be a subclass of.*parent value class"):
+
+        @LocalChild.value_class()
+        class InvalidChildValue(LocalChild):  # Missing LocalBaseImpl inheritance
+            pass
+
 
-    with caplog.at_level(logging.WARNING):
-        A(x=3)
-        assert message in caplog.text
+def test_value_decorator_skip_intermediate():
+    """Test value class when intermediate class has no value class"""
+    # ValueSkipBase has impl, ValueSkipIntermediate has none, ValueSkipDeep has impl
+    assert ValueSkipDeep.XPMValue is ValueSkipDeepImpl
 
-    caplog.clear()
+    config = ValueSkipDeep.C(x=1, y=2, z=3)
+    instance = config.instance()
 
-    with caplog.at_level(logging.WARNING):
-        A.C(x=3)
-        assert message not in caplog.text
+    assert isinstance(instance, ValueSkipDeepImpl)
+    assert isinstance(instance, ValueSkipBaseImpl)
+    assert instance.compute() == 2  # From ValueSkipBaseImpl
+    assert instance.compute_all() == 6  # From ValueSkipDeepImpl

experimaestro/tests/test_outputs.py

@@ -1,11 +1,11 @@
 """Test for task outputs"""
 
-from experimaestro import Config, Task, Param
+from experimaestro import field, Config, Task, Param
 from experimaestro.scheduler.workspace import RunMode
 
 
 class B(Config):
-    x: Param[int] = 1
+    x: Param[int] = field(ignore_default=1)
 
 
 class A(Config):
@@ -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

@@ -5,7 +5,6 @@ Test annotation handling for configurations and tasks
 
 # Annotation specific tests
 
-import sys
 from pathlib import Path
 from typing import Dict, Optional, List
 from experimaestro.core.context import SerializationContext
@@ -17,7 +16,6 @@ from experimaestro import (
     Constant,
     Param,
     Task,
-    default,
     Meta,
     Config,
     pathgenerator,
@@ -80,8 +78,8 @@ def test_type_hinting():
         __xpmid__ = "annotations.class_variable.config"
 
         x: Param[int]
-        y: Param[float] = 2.3
-        y2: Annotated[float, default(2.3)]
+        y: Param[float] = field(ignore_default=2.3)
+        y2: Param[float] = field(ignore_default=2.3)
         z: Param[Optional[float]]
         t: Param[List[float]]
         w: Param[int]
@@ -148,7 +146,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 +156,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,15 +172,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():
     class A(Config):
-        x: Constant[int] = 2
+        x: Constant[int] = field(ignore_default=2)
 
-    a = A()
+    a = A.C()
     assert a.x == 2, "Constant value not set"
 
     # We should not be able to change the value
@@ -202,7 +200,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)
@@ -214,9 +212,9 @@ def test_inheritance():
         x: Param[int]
 
     class B(A):
-        y: Param[int] = 3
+        y: Param[int] = field(ignore_default=3)
 
-    b = B()
+    b = B.C()
     b.x = 2
     assert b.__xpm__.values["y"] == 3
     assert b.__xpm__.values["x"] == 2
@@ -227,7 +225,7 @@ def test_redefined_param():
         x: Param[int]
 
     class B(Config):
-        x: Param[int] = 3
+        x: Param[int] = field(ignore_default=3)
 
     atx = A.C.__getxpmtype__().getArgument("x")
     btx = B.C.__getxpmtype__().getArgument("x")
@@ -247,7 +245,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"})
@@ -263,7 +261,7 @@ class ConfigWithDefault(Config):
 
 
 def test_param_default():
-    assert ConfigWithDefault().x == 1
+    assert ConfigWithDefault.C().x == 1
 
 
 class ConfigWithDefaultFactory(Config):
@@ -271,7 +269,7 @@ class ConfigWithDefaultFactory(Config):
 
 
 def test_param_default_factory():
-    value = ConfigWithDefaultFactory()
+    value = ConfigWithDefaultFactory.C()
     context = DirectoryContext(Path("/__fakepath__"))
     value.__xpm__.seal(context)
     assert value.x == 1
@@ -284,7 +282,7 @@ def test_default_mismatch():
     """Test mismatch between default and type"""
 
     class A(Config):
-        x: Param[int] = 0.2
+        x: Param[int] = field(ignore_default=0.2)
 
     with pytest.raises(TypeError):
         A.__getxpmtype__().getArgument("x")
@@ -297,17 +295,17 @@ def test_param_default_set():
     """Test that the default setting is well set"""
 
     class A0(Config):
-        x: Param[int] = 2
+        x: Param[int] = field(ignore_default=2)
 
-    assert A0().instance().x == 2
-    assert A0(x=3).instance().x == 3
+    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().instance().x == 2
+    assert A.C().instance().x == 2
 
-    assert A(x=3).instance().x == 3
+    assert A.C(x=3).instance().x == 3
 
 
 # --- Handling help annotations
@@ -336,6 +334,4 @@ def test_help():
     assert xpmtype.description.strip() == "Long description of A."
     assert xpmtype.arguments["y"].help == "Parameter y"
 
-    # Only python >= 3.9
-    if sys.version_info.major == 3 and sys.version_info.minor > 8:
-        assert xpmtype.arguments["x"].help == "Parameter x"
+    assert xpmtype.arguments["x"].help == "Parameter x"