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

experimaestro/tests/test_identifier.py

@@ -69,35 +69,35 @@ def assert_notequal(a, b, message=""):
 
 
 def test_param_int():
-    assert_equal(A(a=1), A(a=1))
+    assert_equal(A.C(a=1), A.C(a=1))
 
 
 def test_param_different_type():
-    assert_notequal(A(a=1), B(a=1))
+    assert_notequal(A.C(a=1), B.C(a=1))
 
 
 def test_param_order():
-    assert_equal(Values(value1=1, value2=2), Values(value2=2, value1=1))
+    assert_equal(Values.C(value1=1, value2=2), Values.C(value2=2, value1=1))
 
 
 def test_param_default():
-    assert_equal(C(a=1, b=2), C(b=2))
+    assert_equal(C.C(a=1, b=2), C.C(b=2))
 
 
 def test_identifier_default_field():
-    assert_equal(CField(a=1, b=2), CField(b=2))
+    assert_equal(CField.C(a=1, b=2), CField.C(b=2))
 
 
 def test_param_inner_eq():
-    assert_equal(D(a=A(a=1)), D(a=A(a=1)))
+    assert_equal(D.C(a=A.C(a=1)), D.C(a=A.C(a=1)))
 
 
 def test_param_float():
-    assert_equal(Float(value=1), Float(value=1))
+    assert_equal(Float.C(value=1), Float.C(value=1))
 
 
 def test_param_float2():
-    assert_equal(Float(value=1.0), Float(value=1))
+    assert_equal(Float.C(value=1.0), Float.C(value=1))
 
 
 # --- Argument name
@@ -118,8 +118,8 @@ def test_param_name():
         __xpmid__ = "test.identifier.argumentname"
         a: Param[int]
 
-    assert_notequal(Config0(a=2), Config1(b=2))
-    assert_equal(Config0(a=2), Config3(a=2))
+    assert_notequal(Config0.C(a=2), Config1.C(b=2))
+    assert_equal(Config0.C(a=2), Config3.C(a=2))
 
 
 # --- Test option
@@ -131,9 +131,9 @@ def test_param_option():
         a: Param[int]
         b: Option[int] = 1
 
-    assert_notequal(OptionConfig(a=2), OptionConfig(a=1))
-    assert_equal(OptionConfig(a=1, b=2), OptionConfig(a=1))
-    assert_equal(OptionConfig(a=1, b=2), OptionConfig(a=1, b=2))
+    assert_notequal(OptionConfig.C(a=2), OptionConfig.C(a=1))
+    assert_equal(OptionConfig.C(a=1, b=2), OptionConfig.C(a=1))
+    assert_equal(OptionConfig.C(a=1, b=2), OptionConfig.C(a=1, b=2))
 
 
 # --- Dictionnary
@@ -148,11 +148,14 @@ def test_param_identifier_dict():
     class A(Config):
         bs: Param[Dict[str, B]]
 
-    assert_equal(A(bs={"b1": B(x=1)}), A(bs={"b1": B(x=1)}))
-    assert_equal(A(bs={"b1": B(x=1), "b2": B(x=2)}), A(bs={"b2": B(x=2), "b1": B(x=1)}))
+    assert_equal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b1": B.C(x=1)}))
+    assert_equal(
+        A.C(bs={"b1": B.C(x=1), "b2": B.C(x=2)}),
+        A.C(bs={"b2": B.C(x=2), "b1": B.C(x=1)}),
+    )
 
-    assert_notequal(A(bs={"b1": B(x=1)}), A(bs={"b1": B(x=2)}))
-    assert_notequal(A(bs={"b1": B(x=1)}), A(bs={"b2": B(x=1)}))
+    assert_notequal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b1": B.C(x=2)}))
+    assert_notequal(A.C(bs={"b1": B.C(x=1)}), A.C(bs={"b2": B.C(x=1)}))
 
 
 # --- Ignore paths
@@ -165,8 +168,8 @@ class TypeWithPath(Config):
 
 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"))
+    assert_equal(TypeWithPath.C(a=1, path="/a/b"), TypeWithPath.C(a=1, path="/c/d"))
+    assert_notequal(TypeWithPath.C(a=2, path="/a/b"), TypeWithPath.C(a=1, path="/c/d"))
 
 
 # --- Test with added arguments
@@ -184,7 +187,7 @@ def test_param_identifier_pathoption():
         __xpmid__ = "pathoption_test"
         a: Param[int]
 
-    assert_equal(A_with_path(a=1), A_without_path(a=1))
+    assert_equal(A_with_path.C(a=1), A_without_path.C(a=1))
 
 
 def test_param_identifier_enum():
@@ -198,8 +201,8 @@ def test_param_identifier_enum():
     class EnumConfig(Config):
         a: Param[EnumParam]
 
-    assert_notequal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.SECOND))
-    assert_equal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.FIRST))
+    assert_notequal(EnumConfig.C(a=EnumParam.FIRST), EnumConfig.C(a=EnumParam.SECOND))
+    assert_equal(EnumConfig.C(a=EnumParam.FIRST), EnumConfig.C(a=EnumParam.FIRST))
 
 
 def test_param_identifier_addnone():
@@ -215,8 +218,8 @@ def test_param_identifier_addnone():
     class A(Config):
         __xpmid__ = "defaultnone"
 
-    assert_equal(A_with_b(), A())
-    assert_notequal(A_with_b(b=B(x=1)), A())
+    assert_equal(A_with_b.C(), A.C())
+    assert_notequal(A_with_b.C(b=B.C(x=1)), A.C())
 
 
 def test_param_defaultnew():
@@ -232,8 +235,8 @@ def test_param_defaultnew():
         __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))
+    assert_equal(A_with_b.C(a=1, b=1), A.C(a=1))
+    assert_equal(A_with_b.C(a=1), A.C(a=1))
 
 
 def test_param_taskconfigidentifier():
@@ -246,15 +249,15 @@ def test_param_taskconfigidentifier():
         x: Param[int]
 
         def task_outputs(self, dep):
-            return dep(MyConfig(a=1))
+            return dep(MyConfig.C(a=1))
 
     assert_equal(
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
     )
     assert_notequal(
-        MyTask(x=2).submit(run_mode=RunMode.DRY_RUN),
-        MyTask(x=1).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=2).submit(run_mode=RunMode.DRY_RUN),
+        MyTask.C(x=1).submit(run_mode=RunMode.DRY_RUN),
     )
 
 
@@ -269,13 +272,13 @@ def test_param_constant():
         __xpmid__ = "test.constant"
         version: Constant[int] = 1
 
-    assert_equal(A1(), A1bis())
+    assert_equal(A1.C(), A1bis.C())
 
     class A2(Config):
         __xpmid__ = "test.constant"
         version: Constant[int] = 2
 
-    assert_notequal(A1(), A2())
+    assert_notequal(A1.C(), A2.C())
 
 
 def test_param_identifier_deprecated_class():
@@ -293,10 +296,12 @@ def test_param_identifier_deprecated_class():
         __xpmid__ = "derived"
 
     assert_notequal(
-        NewConfig(), DerivedConfig(), "A derived configuration has another ID"
+        NewConfig.C(), DerivedConfig.C(), "A derived configuration has another ID"
     )
     assert_equal(
-        NewConfig(), OldConfig(), "Deprecated and new configuration have the same ID"
+        NewConfig.C(),
+        OldConfig.C(),
+        "Deprecated and new configuration have the same ID",
     )
 
 
@@ -308,7 +313,7 @@ def test_param_identifier_deprecated_attribute():
         def value(self, x):
             self.values = [x]
 
-    assert_equal(Values(values=[1]), Values(value=1))
+    assert_equal(Values.C(values=[1]), Values.C(value=1))
 
 
 class MetaA(Config):
@@ -331,26 +336,30 @@ def test_param_identifier_meta():
         params: Param[Dict[str, MetaA]]
 
     # As meta
-    assert_notequal(B(a=MetaA(x=1)), B(a=MetaA(x=2)))
-    assert_equal(B(a=setmeta(MetaA(x=1), True)), B(a=setmeta(MetaA(x=2), True)))
+    assert_notequal(B.C(a=MetaA.C(x=1)), B.C(a=MetaA.C(x=2)))
+    assert_equal(B.C(a=setmeta(MetaA.C(x=1), True)), B.C(a=setmeta(MetaA.C(x=2), True)))
 
     # As parameter
-    assert_equal(C(a=MetaA(x=1)), C(a=MetaA(x=2)))
-    assert_notequal(C(a=setmeta(MetaA(x=1), False)), C(a=setmeta(MetaA(x=2), False)))
+    assert_equal(C.C(a=MetaA.C(x=1)), C.C(a=MetaA.C(x=2)))
+    assert_notequal(
+        C.C(a=setmeta(MetaA.C(x=1), False)), C.C(a=setmeta(MetaA.C(x=2), False))
+    )
 
     # Array with mixed
     assert_equal(
-        ArrayConfig(array=[MetaA(x=1)]),
-        ArrayConfig(array=[MetaA(x=1), setmeta(MetaA(x=2), True)]),
+        ArrayConfig.C(array=[MetaA.C(x=1)]),
+        ArrayConfig.C(array=[MetaA.C(x=1), setmeta(MetaA.C(x=2), True)]),
     )
 
     # Array with empty list
-    assert_equal(ArrayConfig(array=[]), ArrayConfig(array=[setmeta(MetaA(x=2), True)]))
+    assert_equal(
+        ArrayConfig.C(array=[]), ArrayConfig.C(array=[setmeta(MetaA.C(x=2), True)])
+    )
 
     # Dict with mixed
     assert_equal(
-        DictConfig(params={"a": MetaA(x=1)}),
-        DictConfig(params={"a": MetaA(x=1), "b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={"a": MetaA.C(x=1)}),
+        DictConfig.C(params={"a": MetaA.C(x=1), "b": setmeta(MetaA.C(x=2), True)}),
     )
 
 
@@ -359,14 +368,14 @@ def test_param_identifier_meta_default_dict():
         params: Param[Dict[str, MetaA]] = {}
 
     assert_equal(
-        DictConfig(params={}),
-        DictConfig(params={"b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={}),
+        DictConfig.C(params={"b": setmeta(MetaA.C(x=2), True)}),
     )
 
     # Dict with mixed
     assert_equal(
-        DictConfig(params={"a": MetaA(x=1)}),
-        DictConfig(params={"a": MetaA(x=1), "b": setmeta(MetaA(x=2), True)}),
+        DictConfig.C(params={"a": MetaA.C(x=1)}),
+        DictConfig.C(params={"a": MetaA.C(x=1), "b": setmeta(MetaA.C(x=2), True)}),
     )
 
 
@@ -376,13 +385,13 @@ def test_param_identifier_meta_default_array():
 
     # Array (with default) with mixed
     assert_equal(
-        ArrayConfigWithDefault(array=[MetaA(x=1)]),
-        ArrayConfigWithDefault(array=[MetaA(x=1), setmeta(MetaA(x=2), True)]),
+        ArrayConfigWithDefault.C(array=[MetaA.C(x=1)]),
+        ArrayConfigWithDefault.C(array=[MetaA.C(x=1), setmeta(MetaA.C(x=2), True)]),
     )
     # Array (with default) with empty list
     assert_equal(
-        ArrayConfigWithDefault(array=[]),
-        ArrayConfigWithDefault(array=[setmeta(MetaA(x=2), True)]),
+        ArrayConfigWithDefault.C(array=[]),
+        ArrayConfigWithDefault.C(array=[setmeta(MetaA.C(x=2), True)]),
     )
 
 
@@ -396,19 +405,19 @@ def test_param_identifier_pre_task():
     class IdentifierPreTask(Task):
         x: Param[MyConfig]
 
-    task = IdentifierPreTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
+    task = IdentifierPreTask.C(x=MyConfig.C()).submit(run_mode=RunMode.DRY_RUN)
     task_with_pre = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
+        IdentifierPreTask.C(x=MyConfig.C())
+        .add_pretasks(IdentifierPreLightTask.C())
         .submit(run_mode=RunMode.DRY_RUN)
     )
     task_with_pre_2 = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
+        IdentifierPreTask.C(x=MyConfig.C())
+        .add_pretasks(IdentifierPreLightTask.C())
         .submit(run_mode=RunMode.DRY_RUN)
     )
-    task_with_pre_3 = IdentifierPreTask(
-        x=MyConfig().add_pretasks(IdentifierPreLightTask())
+    task_with_pre_3 = IdentifierPreTask.C(
+        x=MyConfig.C().add_pretasks(IdentifierPreLightTask.C())
     ).submit(run_mode=RunMode.DRY_RUN)
 
     assert_notequal(task, task_with_pre, "No pre-task")
@@ -429,18 +438,18 @@ def test_param_identifier_init_task():
     class IdentierTask(Task):
         x: Param[MyConfig]
 
-    task = IdentierTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = IdentierTask(x=MyConfig()).submit(
+    task = IdentierTask.C(x=MyConfig.C()).submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre = IdentierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_2 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_2 = IdentierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_3 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_3 = IdentierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask2(), IdentifierInitTask()],
+        init_tasks=[IdentifierInitTask2.C(), IdentifierInitTask.C()],
     )
 
     assert_notequal(task, task_with_pre, "No pre-task")
@@ -475,14 +484,14 @@ class IdentifierReloadConfig(Config):
 
 def test_param_identifier_reload_config():
     # Creates the configuration
-    check_reload(IdentifierReloadConfig(id="123"))
+    check_reload(IdentifierReloadConfig.C(id="123"))
 
 
 class IdentifierReload(Task):
     id: Param[str]
 
-    def task_outputs(self, dep):
-        return IdentifierReloadConfig(id=self.id)
+    def task_outputs(self, dep) -> IdentifierReloadConfig.C:
+        return IdentifierReloadConfig.C(id=self.id)
 
 
 class IdentifierReloadDerived(Config):
@@ -493,8 +502,8 @@ def test_param_identifier_reload_taskoutput():
     """When using a task output, the identifier should not be different"""
 
     # Creates the configuration
-    task = IdentifierReload(id="123").submit(run_mode=RunMode.DRY_RUN)
-    config = IdentifierReloadDerived(task=task)
+    task = IdentifierReload.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadDerived.C(task=task)
     check_reload(config)
 
 
@@ -515,9 +524,9 @@ def test_param_identifier_reload_task_direct():
     """When using a direct task output, the identifier should not be different"""
 
     # Creates the configuration
-    task = IdentifierReloadTask(id="123").submit(run_mode=RunMode.DRY_RUN)
-    config = IdentifierReloadTaskDerived(
-        task=task, other=IdentifierReloadTaskConfig(x=2)
+    task = IdentifierReloadTask.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadTaskDerived.C(
+        task=task, other=IdentifierReloadTaskConfig.C(x=2)
     )
     check_reload(config)
 
@@ -525,9 +534,9 @@ def test_param_identifier_reload_task_direct():
 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)
-    config = IdentifierReloadTaskDerived(
-        task=task, other=setmeta(IdentifierReloadTaskConfig(x=2), True)
+    task = IdentifierReloadTask.C(id="123").submit(run_mode=RunMode.DRY_RUN)
+    config = IdentifierReloadTaskDerived.C(
+        task=task, other=setmeta(IdentifierReloadTaskConfig.C(x=2), True)
     )
     check_reload(config)
 
@@ -546,9 +555,9 @@ class LoopC(Config):
 
 
 def test_param_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

@@ -17,16 +17,16 @@ class B(Config):
 
 
 def test_simple_instance():
-    a = A1(x=1)
-    b = B(a=a)
+    a = A1.C(x=1)
+    b = B.C(a=a)
     b = b.instance()
 
     assert not isinstance(b, ConfigMixin)
-    assert isinstance(b, B.__xpmtype__.objecttype)
+    assert isinstance(b, B.__xpmtype__.value_type)
 
     assert not isinstance(b.a, ConfigMixin)
-    assert isinstance(b.a, A1.__xpmtype__.objecttype)
-    assert isinstance(b.a, A.__xpmtype__.basetype)
+    assert isinstance(b.a, A1.__xpmtype__.value_type)
+    assert isinstance(b.a, A.__xpmtype__.value_type)
 
 
 # --- Test pre tasks
@@ -47,9 +47,9 @@ class LoadModel(SerializationLWTask):
 
 
 def test_instance_serialized():
-    model = Model()
-    model.add_pretasks(LoadModel(value=model))
-    trainer = Evaluator(model=model)
+    model = Model.C()
+    model.add_pretasks(LoadModel.C(value=model))
+    trainer = Evaluator.C(model=model)
     instance = trainer.instance()
 
     assert isinstance(
@@ -65,6 +65,6 @@ class ConfigWithOptional(Config):
 
 def test_instance_optional():
     """Test that optional parameters are set to None when calling instance"""
-    c = ConfigWithOptional().instance()
+    c = ConfigWithOptional.C().instance()
     assert c.x == 1
     assert c.y is None

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.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
@@ -28,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):
@@ -40,27 +38,26 @@ 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)
@@ -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()
 
@@ -92,18 +84,3 @@ 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_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

@@ -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,7 +174,7 @@ 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
 
 
@@ -182,7 +182,7 @@ def test_constant():
     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
@@ -202,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)
@@ -216,7 +216,7 @@ 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
@@ -247,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"})
@@ -263,7 +263,7 @@ class ConfigWithDefault(Config):
 
 
 def test_param_default():
-    assert ConfigWithDefault().x == 1
+    assert ConfigWithDefault.C().x == 1
 
 
 class ConfigWithDefaultFactory(Config):
@@ -271,7 +271,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
@@ -299,15 +299,15 @@ def test_param_default_set():
     class A0(Config):
         x: Param[int] = 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