experimaestro 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

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,
 )
@@ -48,8 +46,7 @@ class Float(Config):
     value: Param[float]
 
 
-@config()
-class Values:
+class Values(Config):
     value1: Param[float]
     value2: Param[float]
 
@@ -66,50 +63,50 @@ def assert_notequal(a, b, message=""):
     assert getidentifier(a) != getidentifier(b), message
 
 
-def test_int():
+def test_param_int():
     assert_equal(A(a=1), A(a=1))
 
 
-def test_different_type():
+def test_param_different_type():
     assert_notequal(A(a=1), B(a=1))
 
 
-def test_order():
+def test_param_order():
     assert_equal(Values(value1=1, value2=2), Values(value2=2, value1=1))
 
 
-def test_default():
+def test_param_default():
     assert_equal(C(a=1, b=2), C(b=2))
 
 
-def test_inner_eq():
+def test_param_inner_eq():
     assert_equal(D(a=A(a=1)), D(a=A(a=1)))
 
 
-def test_float():
+def test_param_float():
     assert_equal(Float(value=1), Float(value=1))
 
 
-def test_float2():
+def test_param_float2():
     assert_equal(Float(value=1.0), Float(value=1))
 
 
 # --- Argument name
 
 
-def test_name():
+def test_param_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 +116,9 @@ def test_name():
 # --- Test option
 
 
-def test_option():
-    @config("test.identifier.option")
-    class OptionConfig:
+def test_param_option():
+    class OptionConfig(Config):
+        __xpmid__ = "test.identifier.option"
         a: Param[int]
         b: Option[int] = 1
 
@@ -133,7 +130,7 @@ def test_option():
 # --- Dictionnary
 
 
-def test_identifier_dict():
+def test_param_identifier_dict():
     """Test identifiers of dictionary structures"""
 
     class B(Config):
@@ -152,13 +149,12 @@ def test_identifier_dict():
 # --- Ignore paths
 
 
-@config()
-class TypeWithPath:
+class TypeWithPath(Config):
     a: Param[int]
     path: Param[Path]
 
 
-def test_path():
+def test_param_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 +163,23 @@ def test_path():
 # --- Test with added arguments
 
 
-def test_pathoption():
+def test_param_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"""
+def test_param_identifier_enum():
+    """test enum parameters"""
     from enum import Enum
 
     class EnumParam(Enum):
@@ -197,7 +193,7 @@ def test_identifier_enum():
     assert_equal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.FIRST))
 
 
-def test_identifier_addnone():
+def test_param_identifier_addnone():
     """Test the case of new parameter (with None default)"""
 
     class B(Config):
@@ -214,25 +210,24 @@ def test_identifier_addnone():
     assert_notequal(A_with_b(b=B(x=1)), A())
 
 
-def test_defaultnew():
+def test_param_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_param_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -254,27 +249,27 @@ def test_taskconfigidentifier():
     )
 
 
-def test_constant():
+def test_param_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())
 
 
-def test_identifier_deprecated_class():
+def test_param_identifier_deprecated_class():
     """Test that when submitting the task, the computed identifier is the one of
     the new class"""
 
@@ -296,7 +291,7 @@ def test_identifier_deprecated_class():
     )
 
 
-def test_identifier_deprecated_attribute():
+def test_param_identifier_deprecated_attribute():
     class Values(Config):
         values: Param[List[int]] = []
 
@@ -311,7 +306,7 @@ class MetaA(Config):
     x: Param[int]
 
 
-def test_identifier_meta():
+def test_param_identifier_meta():
     """Test forced meta-parameter"""
 
     class B(Config):
@@ -350,7 +345,7 @@ def test_identifier_meta():
     )
 
 
-def test_identifier_meta_default_dict():
+def test_param_identifier_meta_default_dict():
     class DictConfig(Config):
         params: Param[Dict[str, MetaA]] = {}
 
@@ -366,7 +361,7 @@ def test_identifier_meta_default_dict():
     )
 
 
-def test_identifier_meta_default_array():
+def test_param_identifier_meta_default_array():
     class ArrayConfigWithDefault(Config):
         array: Param[List[MetaA]] = []
 
@@ -382,7 +377,7 @@ def test_identifier_meta_default_array():
     )
 
 
-def test_identifier_pre_task():
+def test_param_identifier_pre_task():
     class MyConfig(Config):
         pass
 
@@ -412,7 +407,7 @@ def test_identifier_pre_task():
     assert_equal(task_with_pre, task_with_pre_3, "Pre-tasks are order-less")
 
 
-def test_identifier_init_task():
+def test_param_identifier_init_task():
     class MyConfig(Config):
         pass
 
@@ -469,7 +464,7 @@ class IdentifierReloadConfig(Config):
     id: Param[str]
 
 
-def test_identifier_reload_config():
+def test_param_identifier_reload_config():
     # Creates the configuration
     check_reload(IdentifierReloadConfig(id="123"))
 
@@ -485,7 +480,7 @@ class IdentifierReloadDerived(Config):
     task: Param[IdentifierReloadConfig]
 
 
-def test_identifier_reload_taskoutput():
+def test_param_identifier_reload_taskoutput():
     """When using a task output, the identifier should not be different"""
 
     # Creates the configuration
@@ -507,7 +502,7 @@ class IdentifierReloadTaskDerived(Config):
     other: Param[IdentifierReloadTaskConfig]
 
 
-def test_identifier_reload_task_direct():
+def test_param_identifier_reload_task_direct():
     """When using a direct task output, the identifier should not be different"""
 
     # Creates the configuration
@@ -518,7 +513,7 @@ def test_identifier_reload_task_direct():
     check_reload(config)
 
 
-def test_identifier_reload_meta():
+def test_param_identifier_reload_meta():
     """Test identifier don't change when using meta"""
     # Creates the configuration
     task = IdentifierReloadTask(id="123").submit(run_mode=RunMode.DRY_RUN)
@@ -541,7 +536,7 @@ class LoopC(Config):
     param_b: Param["LoopB"]
 
 
-def test_identifier_loop():
+def test_param_identifier_loop():
     c = LoopC()
     b = LoopB(param_c=c)
     a = LoopA(param_b=b)

experimaestro/tests/test_instance.py

@@ -1,21 +1,18 @@
 from typing import Optional
-from experimaestro import config, Param, Config
+from experimaestro import Param, Config
 from experimaestro.core.objects import TypeConfig
 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]
 
 

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,39 @@ 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 help annotations

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_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,31 +1,26 @@
 # --- 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 TypeConfig
 
 
 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
 
@@ -45,14 +40,12 @@ def test_multiple_inheritance():
 
 
 def test_missing_hierarchy():
-    @config()
-    class A:
+    class A(Config):
         pass
 
     class A1(A):
         pass
 
-    @config()
     class B(A1):
         pass
 
@@ -60,3 +53,13 @@ def test_missing_hierarchy():
 
     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=[])