experimaestro 2.0.0a8__py3-none-any.whl → 2.0.0b4__py3-none-any.whl

experimaestro/tests/test_environment.py

@@ -0,0 +1,200 @@
+"""Tests for environment capture utilities"""
+
+import json
+import pytest
+
+from experimaestro.utils.git import get_git_info
+from experimaestro.utils.environment import (
+    get_environment_info,
+    get_editable_packages_git_info,
+    save_environment_info,
+    load_environment_info,
+)
+
+
+class TestGetGitInfo:
+    """Tests for get_git_info function"""
+
+    def test_returns_dict_in_git_repo(self, tmp_path):
+        """Test that get_git_info returns a dict when in a git repo"""
+        # Use the current working directory which should be a git repo
+        git_info = get_git_info()
+
+        assert git_info is not None
+        assert isinstance(git_info, dict)
+        assert "commit" in git_info
+        assert "commit_short" in git_info
+        assert "branch" in git_info
+        assert "dirty" in git_info
+        assert "message" in git_info
+        assert "author" in git_info
+        assert "date" in git_info
+
+    def test_commit_format(self):
+        """Test that commit hashes have correct format"""
+        git_info = get_git_info()
+        if git_info is None:
+            pytest.skip("Not in a git repository")
+
+        # Full commit should be 40 hex characters
+        assert len(git_info["commit"]) == 40
+        assert all(c in "0123456789abcdef" for c in git_info["commit"])
+
+        # Short commit should be 7 characters
+        assert len(git_info["commit_short"]) == 7
+
+    def test_returns_none_for_non_git_dir(self, tmp_path):
+        """Test that get_git_info returns None for non-git directories"""
+        git_info = get_git_info(tmp_path)
+        assert git_info is None
+
+    def test_dirty_flag(self):
+        """Test that dirty flag is a boolean"""
+        git_info = get_git_info()
+        if git_info is None:
+            pytest.skip("Not in a git repository")
+
+        assert isinstance(git_info["dirty"], bool)
+
+
+class TestGetEnvironmentInfo:
+    """Tests for get_environment_info function"""
+
+    def test_returns_dict_with_required_keys(self):
+        """Test that get_environment_info returns dict with required keys"""
+        env_info = get_environment_info()
+
+        assert isinstance(env_info, dict)
+        assert "python_version" in env_info
+        assert "packages" in env_info
+        assert "editable_packages" in env_info
+
+    def test_python_version_format(self):
+        """Test that python_version has correct format"""
+        env_info = get_environment_info()
+        version = env_info["python_version"]
+
+        # Should be in format X.Y.Z
+        parts = version.split(".")
+        assert len(parts) == 3
+        assert all(part.isdigit() for part in parts)
+
+    def test_packages_is_dict(self):
+        """Test that packages is a dict of name -> version"""
+        env_info = get_environment_info()
+        packages = env_info["packages"]
+
+        assert isinstance(packages, dict)
+        assert len(packages) > 0  # Should have at least some packages
+
+        # Check that all values are strings (versions)
+        for name, version in packages.items():
+            assert isinstance(name, str)
+            assert isinstance(version, str)
+
+    def test_experimaestro_is_editable(self):
+        """Test that experimaestro itself is detected as editable"""
+        env_info = get_environment_info()
+        editable = env_info["editable_packages"]
+
+        # When running tests, experimaestro should be installed in editable mode
+        assert "experimaestro" in editable
+        assert "version" in editable["experimaestro"]
+        assert "path" in editable["experimaestro"]
+        assert "git" in editable["experimaestro"]
+
+    def test_editable_package_has_git_info(self):
+        """Test that editable packages include git info"""
+        env_info = get_environment_info()
+        editable = env_info["editable_packages"]
+
+        # experimaestro should have git info since it's in a git repo
+        if "experimaestro" in editable:
+            git_info = editable["experimaestro"]["git"]
+            if git_info is not None:  # May be None if not in git repo
+                assert "commit" in git_info
+                assert "dirty" in git_info
+
+
+class TestGetEditablePackagesGitInfo:
+    """Tests for get_editable_packages_git_info function"""
+
+    def test_returns_dict(self):
+        """Test that function returns a dict"""
+        result = get_editable_packages_git_info()
+        assert isinstance(result, dict)
+
+    def test_contains_experimaestro(self):
+        """Test that experimaestro is in the result"""
+        result = get_editable_packages_git_info()
+        assert "experimaestro" in result
+
+
+class TestSaveAndLoadEnvironmentInfo:
+    """Tests for save_environment_info and load_environment_info functions"""
+
+    def test_save_creates_file(self, tmp_path):
+        """Test that save_environment_info creates a JSON file"""
+        path = tmp_path / "environment.json"
+
+        result = save_environment_info(path)
+
+        assert path.exists()
+        assert isinstance(result, dict)
+
+    def test_save_writes_valid_json(self, tmp_path):
+        """Test that saved file contains valid JSON"""
+        path = tmp_path / "environment.json"
+
+        save_environment_info(path)
+
+        content = json.loads(path.read_text())
+        assert "python_version" in content
+        assert "packages" in content
+        assert "editable_packages" in content
+
+    def test_load_reads_saved_data(self, tmp_path):
+        """Test that load_environment_info reads back saved data"""
+        path = tmp_path / "environment.json"
+
+        saved = save_environment_info(path)
+        loaded = load_environment_info(path)
+
+        assert loaded == saved
+
+    def test_load_returns_none_for_missing_file(self, tmp_path):
+        """Test that load returns None for non-existent file"""
+        path = tmp_path / "nonexistent.json"
+
+        result = load_environment_info(path)
+
+        assert result is None
+
+    def test_load_returns_none_for_invalid_json(self, tmp_path):
+        """Test that load returns None for invalid JSON"""
+        path = tmp_path / "invalid.json"
+        path.write_text("not valid json{")
+
+        result = load_environment_info(path)
+
+        assert result is None
+
+
+class TestExperimentEnvironmentSaving:
+    """Integration tests for environment saving in experiments"""
+
+    def test_experiment_saves_environment_info(self, xpmdirectory):
+        """Test that experiment saves environment.json on start"""
+        from experimaestro import experiment
+
+        # Just enter the experiment context, no need to run any tasks
+        with experiment(xpmdirectory, "test-env-save", port=-1) as xp:
+            pass  # environment.json should be saved on __enter__
+
+        env_path = xp.workdir / "environment.json"
+        assert env_path.exists()
+
+        env_info = json.loads(env_path.read_text())
+        assert "python_version" in env_info
+        assert "packages" in env_info
+        assert "editable_packages" in env_info

experimaestro/tests/test_file_progress_integration.py

@@ -321,7 +321,7 @@ def test_file_progress_concurrent_experiments():
 
         with TemporaryExperiment(
             "file-progress-concurrent-2",
-            workdir=xp1.workdir,
+            workdir=xp1.workspace.path,
             maxwait=max_wait,
             port=0,
         ) as xp2:

experimaestro/tests/test_forward.py

@@ -1,11 +1,11 @@
-from experimaestro import Param, Config
+from experimaestro import field, Param, Config
 from experimaestro.click import forwardoption
 import click
 
 
 def test_main():
     class MyModel(Config):
-        epochs: Param[int] = 100
+        epochs: Param[int] = field(ignore_default=100)
         """Number of learning epochs"""
 
     @forwardoption.epochs(MyModel)
@@ -19,7 +19,7 @@ def test_main():
 
 def test_rename():
     class MyModel(Config):
-        epochs: Param[int] = 100
+        epochs: Param[int] = field(ignore_default=100)
         """Number of learning epochs"""
 
     @forwardoption.epochs(MyModel, "my-epochs")

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]
 
 
@@ -129,7 +131,7 @@ 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.C(a=2), OptionConfig.C(a=1))
     assert_equal(OptionConfig.C(a=1, b=2), OptionConfig.C(a=1))
@@ -229,7 +231,7 @@ def test_identifier_defaultnew():
         __xpmid__ = "defaultnew"
 
         a: Param[int]
-        b: Param[int] = 1
+        b: Param[int] = field(ignore_default=1)
 
     class A(Config):
         __xpmid__ = "defaultnew"
@@ -281,41 +283,6 @@ def test_identifier_constant():
     assert_notequal(A1.C(), A2.C())
 
 
-def test_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.C(), DerivedConfig.C(), "A derived configuration has another ID"
-    )
-    assert_equal(
-        NewConfig.C(),
-        OldConfig.C(),
-        "Deprecated and new configuration have the same ID",
-    )
-
-
-def test_identifier_deprecated_attribute():
-    class Values(Config):
-        values: Param[List[int]] = []
-
-        @deprecate
-        def value(self, x):
-            self.values = [x]
-
-    assert_equal(Values.C(values=[1]), Values.C(value=1))
-
-
 class MetaA(Config):
     x: Param[int]
 
@@ -365,7 +332,7 @@ def test_identifier_meta():
 
 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.C(params={}),
@@ -381,7 +348,7 @@ def test_identifier_meta_default_dict():
 
 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(
@@ -590,3 +557,367 @@ def test_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"