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

experimaestro/tests/test_identifier.py

@@ -5,8 +5,8 @@ from pathlib import Path
 from typing import Dict, List, Optional
 from experimaestro import (
     Param,
-    deprecate,
     Config,
+    InstanceConfig,
     Constant,
     Meta,
     Option,
@@ -14,6 +14,8 @@ from experimaestro import (
     field,
     Task,
     LightweightTask,
+    subparameters,
+    param_group,
 )
 from experimaestro.core.objects import (
     ConfigInformation,
@@ -34,7 +36,7 @@ class B(Config):
 
 
 class C(Config):
-    a: Param[int] = 1
+    a: Param[int] = field(ignore_default=1)
     b: Param[int]
 
 
@@ -68,42 +70,42 @@ def assert_notequal(a, b, message=""):
     assert getidentifier(a) != getidentifier(b), message
 
 
-def test_param_int():
-    assert_equal(A(a=1), A(a=1))
+def test_identifier_int():
+    assert_equal(A.C(a=1), A.C(a=1))
 
 
-def test_param_different_type():
-    assert_notequal(A(a=1), B(a=1))
+def test_identifier_different_type():
+    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))
+def test_identifier_order():
+    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))
+def test_identifier_default():
+    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)))
+def test_identifier_inner_eq():
+    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))
+def test_identifier_float():
+    assert_equal(Float.C(value=1), Float.C(value=1))
 
 
-def test_param_float2():
-    assert_equal(Float(value=1.0), Float(value=1))
+def test_identifier_float2():
+    assert_equal(Float.C(value=1.0), Float.C(value=1))
 
 
 # --- Argument name
 
 
-def test_param_name():
+def test_identifier_name():
     """The identifier fully determines the hash code"""
 
     class Config0(Config):
@@ -118,28 +120,28 @@ 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
 
 
-def test_param_option():
+def test_identifier_option():
     class OptionConfig(Config):
         __xpmid__ = "test.identifier.option"
         a: Param[int]
-        b: Option[int] = 1
+        b: Option[int] = field(ignore_default=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
 
 
-def test_param_identifier_dict():
+def test_identifier_dict():
     """Test identifiers of dictionary structures"""
 
     class B(Config):
@@ -148,11 +150,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
@@ -163,16 +168,16 @@ class TypeWithPath(Config):
     path: Param[Path]
 
 
-def test_param_identifier_path():
+def test_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
 
 
-def test_param_identifier_pathoption():
+def test_identifier_pathoption():
     """Path arguments should be ignored"""
 
     class A_with_path(Config):
@@ -184,10 +189,10 @@ 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():
+def test_identifier_enum():
     """test enum parameters"""
     from enum import Enum
 
@@ -198,11 +203,11 @@ 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():
+def test_identifier_addnone():
     """Test the case of new parameter (with None default)"""
 
     class B(Config):
@@ -215,28 +220,28 @@ 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():
+def test_identifier_defaultnew():
     """Path arguments should be ignored"""
 
     class A_with_b(Config):
         __xpmid__ = "defaultnew"
 
         a: Param[int]
-        b: Param[int] = 1
+        b: Param[int] = field(ignore_default=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))
+    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():
+def test_identifier_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -246,19 +251,19 @@ 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),
     )
 
 
-def test_param_constant():
+def test_identifier_constant():
     """Test if constants are taken into account for signature computation"""
 
     class A1(Config):
@@ -269,53 +274,20 @@ 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())
-
-
-def test_param_identifier_deprecated_class():
-    """Test that when submitting the task, the computed identifier is the one of
-    the new class"""
-
-    class NewConfig(Config):
-        __xpmid__ = "new"
-
-    @deprecate
-    class OldConfig(NewConfig):
-        __xpmid__ = "old"
-
-    class DerivedConfig(NewConfig):
-        __xpmid__ = "derived"
-
-    assert_notequal(
-        NewConfig(), DerivedConfig(), "A derived configuration has another ID"
-    )
-    assert_equal(
-        NewConfig(), OldConfig(), "Deprecated and new configuration have the same ID"
-    )
-
-
-def test_param_identifier_deprecated_attribute():
-    class Values(Config):
-        values: Param[List[int]] = []
-
-        @deprecate
-        def value(self, x):
-            self.values = [x]
-
-    assert_equal(Values(values=[1]), Values(value=1))
+    assert_notequal(A1.C(), A2.C())
 
 
 class MetaA(Config):
     x: Param[int]
 
 
-def test_param_identifier_meta():
+def test_identifier_meta():
     """Test forced meta-parameter"""
 
     class B(Config):
@@ -331,121 +303,136 @@ 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)}),
     )
 
 
-def test_param_identifier_meta_default_dict():
+def test_identifier_meta_default_dict():
     class DictConfig(Config):
-        params: Param[Dict[str, MetaA]] = {}
+        params: Param[Dict[str, MetaA]] = field(ignore_default={})
 
     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)}),
     )
 
 
-def test_param_identifier_meta_default_array():
+def test_identifier_meta_default_array():
     class ArrayConfigWithDefault(Config):
-        array: Param[List[MetaA]] = []
+        array: Param[List[MetaA]] = field(ignore_default=[])
 
     # 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)]),
     )
 
 
-def test_param_identifier_pre_task():
+def test_identifier_init_task():
     class MyConfig(Config):
         pass
 
-    class IdentifierPreLightTask(LightweightTask):
+    class IdentifierInitTask(LightweightTask):
+        pass
+
+    class IdentifierInitTask2(Task):
         pass
 
-    class IdentifierPreTask(Task):
+    class IdentifierTask(Task):
         x: Param[MyConfig]
 
-    task = IdentifierPreTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
+    task = IdentifierTask.C(x=MyConfig.C()).submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
     )
-    task_with_pre_2 = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre_2 = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask.C(), IdentifierInitTask2.C()],
+    )
+    task_with_pre_3 = IdentifierTask.C(x=MyConfig.C()).submit(
+        run_mode=RunMode.DRY_RUN,
+        init_tasks=[IdentifierInitTask2.C(), IdentifierInitTask.C()],
     )
-    task_with_pre_3 = IdentifierPreTask(
-        x=MyConfig().add_pretasks(IdentifierPreLightTask())
-    ).submit(run_mode=RunMode.DRY_RUN)
 
-    assert_notequal(task, task_with_pre, "No pre-task")
+    assert_notequal(task, task_with_pre, "Should be different with init-task")
     assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_equal(task_with_pre, task_with_pre_3, "Pre-tasks are order-less")
+    assert_notequal(task_with_pre, task_with_pre_3, "Other parameters")
 
 
-def test_param_identifier_init_task():
-    class MyConfig(Config):
-        pass
+def test_identifier_init_task_dep():
+    class Loader(LightweightTask):
+        param1: Param[float]
 
-    class IdentifierInitTask(LightweightTask):
-        pass
+        def execute(self):
+            pass
 
-    class IdentifierInitTask2(Task):
-        pass
+    class FirstTask(Task):
+        def task_outputs(self, dep):
+            return dep(Loader.C(param1=1))
 
-    class IdentierTask(Task):
-        x: Param[MyConfig]
+        def execute(self):
+            pass
 
-    task = IdentierTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
-    )
-    task_with_pre_2 = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
+    class SecondTask(Task):
+        param3: Param[int]
+
+        def execute(self):
+            pass
+
+    # Two identical tasks
+    task_a_1 = FirstTask.C()
+    task_a_2 = FirstTask.C()
+    assert_equal(task_a_1, task_a_2)
+
+    # We process them with two different init tasks
+    loader_1 = task_a_1.submit(
+        init_tasks=[Loader.C(param1=0.5)], run_mode=RunMode.DRY_RUN
     )
-    task_with_pre_3 = IdentierTask(x=MyConfig()).submit(
-        run_mode=RunMode.DRY_RUN,
-        init_tasks=[IdentifierInitTask2(), IdentifierInitTask()],
+    loader_2 = task_a_2.submit(
+        init_tasks=[Loader.C(param1=5)], run_mode=RunMode.DRY_RUN
     )
+    assert_notequal(loader_1, loader_2)
 
-    assert_notequal(task, task_with_pre, "No pre-task")
-    assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_notequal(task_with_pre, task_with_pre_3, "Same parameters")
+    # Now, we process
+    c_1 = SecondTask.C(param3=2).submit(init_tasks=[loader_1], run_mode=RunMode.DRY_RUN)
+
+    c_2 = SecondTask.C(param3=2).submit(init_tasks=[loader_2], run_mode=RunMode.DRY_RUN)
+    assert_notequal(c_1, c_2)
 
 
 # --- Check configuration reloads
@@ -463,7 +450,7 @@ def check_reload(config):
     new_config = ConfigInformation.fromParameters(
         data, as_instance=False, discard_id=True
     )
-    assert new_config.__xpm__._full_identifier is None
+    assert new_config.__xpm__._identifier is None
     new_identifier = new_config.__xpm__.identifier.all
 
     assert new_identifier == old_identifier
@@ -473,28 +460,28 @@ class IdentifierReloadConfig(Config):
     id: Param[str]
 
 
-def test_param_identifier_reload_config():
+def test_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):
     task: Param[IdentifierReloadConfig]
 
 
-def test_param_identifier_reload_taskoutput():
+def test_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)
 
 
@@ -511,23 +498,23 @@ class IdentifierReloadTaskDerived(Config):
     other: Param[IdentifierReloadTaskConfig]
 
 
-def test_param_identifier_reload_task_direct():
+def test_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)
 
 
-def test_param_identifier_reload_meta():
+def test_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)
 
@@ -545,10 +532,10 @@ class LoopC(Config):
     param_b: Param["LoopB"]
 
 
-def test_param_identifier_loop():
-    c = LoopC()
-    b = LoopB(param_c=c)
-    a = LoopA(param_b=b)
+def test_identifier_loop():
+    c = LoopC.C()
+    b = LoopB.C(param_c=c)
+    a = LoopA.C(param_b=b)
     c.param_a = a
     c.param_b = b
 
@@ -570,3 +557,367 @@ def test_param_identifier_loop():
     for i in range(len(configs)):
         for j in range(1, len(configs)):
             assert identifiers[i][0] == identifiers[i][j]
+
+
+# --- Test InstanceConfig
+
+
+class SubModel(InstanceConfig):
+    """Test InstanceConfig - instances are distinguished even with same params"""
+
+    pass
+
+
+class SubModelAsConfig(Config):
+    """Same as SubModel but as regular Config for backwards compat testing"""
+
+    __xpmid__ = "test.SubModel"
+    pass
+
+
+class Model(Config):
+    """Model that can contain SubModel instances"""
+
+    m1: Param[SubModel]
+    m2: Param[SubModel]
+
+
+class ModelWithRegularConfig(Config):
+    """Model using regular Config instead of InstanceConfig"""
+
+    __xpmid__ = "test.Model"
+    m1: Param[SubModelAsConfig]
+    m2: Param[SubModelAsConfig]
+
+
+def test_instanceconfig_backwards_compat():
+    """Model using single InstanceConfig should have same ID as with regular Config"""
+    # Using InstanceConfig (first occurrence only, no instance marker added)
+    sm1 = SubModel.C()
+    sm1.__xpmtype__.identifier.name = "test.SubModel"  # Match the __xpmid__
+    m_instance = Model.C(m1=sm1, m2=sm1)
+    m_instance.__xpmtype__.identifier.name = "test.Model"
+
+    # Using regular Config
+    sc1 = SubModelAsConfig.C()
+    m_regular = ModelWithRegularConfig.C(m1=sc1, m2=sc1)
+
+    # Should have same identifier (backwards compatible)
+    assert_equal(
+        m_instance, m_regular, "Single InstanceConfig should be backwards compatible"
+    )
+
+
+def test_instanceconfig_same_params_different_instances():
+    """Model with separate InstanceConfig instances should differ from shared"""
+    sm1 = SubModel.C()
+    sm2 = SubModel.C()
+
+    # Using the same instance twice (shared)
+    m1 = Model.C(m1=sm1, m2=sm1)
+
+    # Using different instances (separate)
+    m2 = Model.C(m1=sm1, m2=sm2)
+
+    # These should be different because sm2 is a second instance with same params
+    assert_notequal(m1, m2, "Models with shared vs separate instances should differ")
+
+
+def test_instanceconfig_reused_instance():
+    """Reusing the same InstanceConfig instance should give same ID"""
+    sm1 = SubModel.C()
+
+    # Using the same instance object multiple times should be OK
+    m1 = Model.C(m1=sm1, m2=sm1)
+    m2 = Model.C(m1=sm1, m2=sm1)
+
+    # These should be the same because we're reusing the exact same objects
+    assert_equal(m1, m2, "Models with same instance objects should be equal")
+
+
+def test_instanceconfig_serialization():
+    """InstanceConfig identifiers should be stable after serialization"""
+    sm1 = SubModel.C()
+    sm2 = SubModel.C()
+
+    # Create a model with two different instances
+    m1 = Model.C(m1=sm1, m2=sm2)
+    original_id = getidentifier(m1)
+
+    # Serialize and reload
+    check_reload(m1)
+
+    # The identifier should remain the same
+    assert getidentifier(m1) == original_id
+
+
+# --- Test ignore_default vs default in field() ---
+
+
+def test_identifier_field_ignore_default():
+    """Test that field(ignore_default=X) ignores value in identifier when value == X"""
+
+    class ConfigWithIgnoreDefault(Config):
+        __xpmid__ = "test.identifier.field_ignore_default"
+        a: Param[int] = field(ignore_default=1)
+        b: Param[int]
+
+    # When a=1 (matches ignore_default), should be same as not specifying a
+    class ConfigWithoutA(Config):
+        __xpmid__ = "test.identifier.field_ignore_default"
+        b: Param[int]
+
+    assert_equal(
+        ConfigWithIgnoreDefault.C(a=1, b=2),
+        ConfigWithIgnoreDefault.C(b=2),
+        "field(ignore_default=1) should ignore a=1 in identifier",
+    )
+    assert_equal(
+        ConfigWithIgnoreDefault.C(a=1, b=2),
+        ConfigWithoutA.C(b=2),
+        "Config with ignore_default should match config without that param",
+    )
+
+    # When a=2 (doesn't match ignore_default), should be included
+    assert_notequal(
+        ConfigWithIgnoreDefault.C(a=2, b=2),
+        ConfigWithIgnoreDefault.C(b=2),
+        "field(ignore_default=1) should include a=2 in identifier",
+    )
+
+
+def test_identifier_field_default():
+    """Test that field(default=X) includes value in identifier even when value == X"""
+
+    class ConfigWithDefault(Config):
+        __xpmid__ = "test.identifier.field_default"
+        a: Param[int] = field(default=1)
+        b: Param[int]
+
+    class ConfigWithoutA(Config):
+        __xpmid__ = "test.identifier.field_default"
+        b: Param[int]
+
+    # When a=1 (matches default), should still be included in identifier
+    # so Config with a=1 should differ from Config without a
+    assert_notequal(
+        ConfigWithDefault.C(a=1, b=2),
+        ConfigWithoutA.C(b=2),
+        "field(default=1) should include a=1 in identifier",
+    )
+
+    # But two configs with same a=1 should be equal
+    assert_equal(
+        ConfigWithDefault.C(a=1, b=2),
+        ConfigWithDefault.C(a=1, b=2),
+        "Same values should have same identifier",
+    )
+
+
+def test_identifier_field_default_vs_ignore_default():
+    """Test difference between field(default=X) and field(ignore_default=X)"""
+
+    class ConfigWithDefault(Config):
+        __xpmid__ = "test.identifier.field_default_vs_ignore"
+        a: Param[int] = field(default=1)
+        b: Param[int]
+
+    class ConfigWithIgnoreDefault(Config):
+        __xpmid__ = "test.identifier.field_default_vs_ignore"
+        a: Param[int] = field(ignore_default=1)
+        b: Param[int]
+
+    # Both with a=1, b=2 - should differ because one includes a, other doesn't
+    assert_notequal(
+        ConfigWithDefault.C(a=1, b=2),
+        ConfigWithIgnoreDefault.C(a=1, b=2),
+        "field(default=1) vs field(ignore_default=1) should differ when a=1",
+    )
+
+    # Both with a=2 (not matching default), should be the same
+    assert_equal(
+        ConfigWithDefault.C(a=2, b=2),
+        ConfigWithIgnoreDefault.C(a=2, b=2),
+        "field(default=1) vs field(ignore_default=1) should be same when a!=1",
+    )
+
+
+# --- Test partial identifiers (subparameters) ---
+
+
+# Define parameter groups at module level
+iter_group = param_group("iter")
+model_group = param_group("model")
+
+
+def get_partial_identifier(config, sp):
+    """Helper to get partial identifier for a config and subparameters"""
+    return config.__xpm__.get_partial_identifier(sp).all
+
+
+def test_partial_identifier_excludes_grouped_params():
+    """Test that partial identifier excludes parameters in excluded groups"""
+
+    class ConfigWithGroups(Config):
+        checkpoints = subparameters(exclude_groups=[iter_group])
+        max_iter: Param[int] = field(groups=[iter_group])
+        learning_rate: Param[float]
+
+    c1 = ConfigWithGroups.C(max_iter=100, learning_rate=0.1)
+    c2 = ConfigWithGroups.C(max_iter=200, learning_rate=0.1)
+
+    # Full identifiers should differ (max_iter is different)
+    assert_notequal(c1, c2, "Full identifiers should differ when max_iter differs")
+
+    # Partial identifiers should be the same (max_iter is excluded)
+    pid1 = get_partial_identifier(c1, ConfigWithGroups.checkpoints)
+    pid2 = get_partial_identifier(c2, ConfigWithGroups.checkpoints)
+    assert (
+        pid1 == pid2
+    ), "Partial identifiers should match when only excluded params differ"
+
+
+def test_partial_identifier_includes_ungrouped_params():
+    """Test that partial identifier includes parameters not in excluded groups"""
+
+    class ConfigWithGroups(Config):
+        checkpoints = subparameters(exclude_groups=[iter_group])
+        max_iter: Param[int] = field(groups=[iter_group])
+        learning_rate: Param[float]
+
+    c1 = ConfigWithGroups.C(max_iter=100, learning_rate=0.1)
+    c2 = ConfigWithGroups.C(max_iter=100, learning_rate=0.2)
+
+    # Partial identifiers should differ (learning_rate is not excluded)
+    pid1 = get_partial_identifier(c1, ConfigWithGroups.checkpoints)
+    pid2 = get_partial_identifier(c2, ConfigWithGroups.checkpoints)
+    assert (
+        pid1 != pid2
+    ), "Partial identifiers should differ when non-excluded params differ"
+
+
+def test_partial_identifier_matches_config_without_excluded():
+    """Test that partial identifier matches config without the excluded fields"""
+
+    class ConfigWithIter(Config):
+        __xpmid__ = "test.partial_identifier.config"
+        checkpoints = subparameters(exclude_groups=[iter_group])
+        max_iter: Param[int] = field(groups=[iter_group])
+        learning_rate: Param[float]
+
+    class ConfigWithoutIter(Config):
+        __xpmid__ = "test.partial_identifier.config"
+        learning_rate: Param[float]
+
+    c_with = ConfigWithIter.C(max_iter=100, learning_rate=0.1)
+    c_without = ConfigWithoutIter.C(learning_rate=0.1)
+
+    # The partial identifier of c_with should match full identifier of c_without
+    pid = get_partial_identifier(c_with, ConfigWithIter.checkpoints)
+    full_id = getidentifier(c_without)
+    assert (
+        pid == full_id
+    ), "Partial identifier should match config without excluded fields"
+
+
+def test_partial_identifier_multiple_groups():
+    """Test partial identifier with parameter in multiple groups"""
+
+    class ConfigMultiGroup(Config):
+        checkpoints = subparameters(exclude_groups=[iter_group])
+        # This parameter is in both groups - should be excluded if any group is excluded
+        x: Param[int] = field(groups=[iter_group, model_group])
+        y: Param[float]
+
+    c1 = ConfigMultiGroup.C(x=1, y=0.1)
+    c2 = ConfigMultiGroup.C(x=2, y=0.1)
+
+    # Partial identifiers should be the same (x is in iter_group which is excluded)
+    pid1 = get_partial_identifier(c1, ConfigMultiGroup.checkpoints)
+    pid2 = get_partial_identifier(c2, ConfigMultiGroup.checkpoints)
+    assert (
+        pid1 == pid2
+    ), "Partial identifiers should match when param is in any excluded group"
+
+
+def test_partial_identifier_include_overrides_exclude():
+    """Test that include_groups overrides exclude_groups"""
+
+    class ConfigIncludeOverride(Config):
+        # iter_group is excluded but also included, so it should NOT be excluded
+        partial = subparameters(
+            exclude_groups=[iter_group, model_group], include_groups=[iter_group]
+        )
+        x: Param[int] = field(groups=[iter_group])
+        y: Param[int] = field(groups=[model_group])
+        z: Param[float]
+
+    c1 = ConfigIncludeOverride.C(x=1, y=1, z=0.1)
+    c2 = ConfigIncludeOverride.C(x=2, y=1, z=0.1)
+    c3 = ConfigIncludeOverride.C(x=1, y=2, z=0.1)
+
+    # x is in iter_group which is included (overrides exclusion)
+    # so different x should give different partial identifiers
+    pid1 = get_partial_identifier(c1, ConfigIncludeOverride.partial)
+    pid2 = get_partial_identifier(c2, ConfigIncludeOverride.partial)
+    assert pid1 != pid2, "Include should override exclude - x should be included"
+
+    # y is in model_group which is excluded (not included)
+    # so different y should give SAME partial identifiers
+    pid3 = get_partial_identifier(c3, ConfigIncludeOverride.partial)
+    assert pid1 == pid3, "y is excluded - different y should give same partial ID"
+
+
+def test_partial_identifier_exclude_all():
+    """Test exclude_all option"""
+
+    class ConfigExcludeAll(Config):
+        # Exclude all, but include model_group
+        partial = subparameters(exclude_all=True, include_groups=[model_group])
+        x: Param[int] = field(groups=[iter_group])
+        y: Param[int] = field(groups=[model_group])
+        z: Param[float]  # No group
+
+    c1 = ConfigExcludeAll.C(x=1, y=1, z=0.1)
+    c2 = ConfigExcludeAll.C(x=2, y=1, z=0.1)  # Different x (excluded)
+    c3 = ConfigExcludeAll.C(x=1, y=2, z=0.1)  # Different y (included)
+    c4 = ConfigExcludeAll.C(x=1, y=1, z=0.2)  # Different z (excluded - no group)
+
+    pid1 = get_partial_identifier(c1, ConfigExcludeAll.partial)
+    pid2 = get_partial_identifier(c2, ConfigExcludeAll.partial)
+    pid3 = get_partial_identifier(c3, ConfigExcludeAll.partial)
+    pid4 = get_partial_identifier(c4, ConfigExcludeAll.partial)
+
+    # x is excluded (in iter_group, not included) - same partial ID
+    assert pid1 == pid2, "x is excluded - should have same partial ID"
+
+    # y is included (in model_group) - different partial ID
+    assert pid1 != pid3, "y is included - should have different partial ID"
+
+    # z is excluded (no group, exclude_all=True) - same partial ID
+    assert (
+        pid1 == pid4
+    ), "z (no group) is excluded by exclude_all - should have same partial ID"
+
+
+def test_partial_identifier_exclude_no_group():
+    """Test exclude_no_group option"""
+
+    class ConfigExcludeNoGroup(Config):
+        partial = subparameters(exclude_no_group=True)
+        x: Param[int] = field(groups=[iter_group])
+        y: Param[float]  # No group
+
+    c1 = ConfigExcludeNoGroup.C(x=1, y=0.1)
+    c2 = ConfigExcludeNoGroup.C(x=2, y=0.1)  # Different x (has group - not excluded)
+    c3 = ConfigExcludeNoGroup.C(x=1, y=0.2)  # Different y (no group - excluded)
+
+    pid1 = get_partial_identifier(c1, ConfigExcludeNoGroup.partial)
+    pid2 = get_partial_identifier(c2, ConfigExcludeNoGroup.partial)
+    pid3 = get_partial_identifier(c3, ConfigExcludeNoGroup.partial)
+
+    # x has a group, so it's NOT excluded by exclude_no_group
+    assert pid1 != pid2, "x has group - should have different partial ID"
+
+    # y has no group, so it IS excluded by exclude_no_group
+    assert pid1 == pid3, "y has no group - should have same partial ID"