experimaestro 2.0.0b8__py3-none-any.whl → 2.0.0b17__py3-none-any.whl

experimaestro/tests/test_identifier.py

@@ -14,7 +14,7 @@ from experimaestro import (
     field,
     Task,
     LightweightTask,
-    subparameters,
+    partial,
     param_group,
 )
 from experimaestro.core.objects import (
@@ -742,7 +742,7 @@ def test_identifier_field_default_vs_ignore_default():
     )
 
 
-# --- Test partial identifiers (subparameters) ---
+# --- Test partial identifiers (partial) ---
 
 
 # Define parameter groups at module level
@@ -751,7 +751,7 @@ model_group = param_group("model")
 
 
 def get_partial_identifier(config, sp):
-    """Helper to get partial identifier for a config and subparameters"""
+    """Helper to get partial identifier for a config and partial"""
     return config.__xpm__.get_partial_identifier(sp).all
 
 
@@ -759,7 +759,7 @@ 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])
+        checkpoints = partial(exclude_groups=[iter_group])
         max_iter: Param[int] = field(groups=[iter_group])
         learning_rate: Param[float]
 
@@ -772,16 +772,16 @@ def test_partial_identifier_excludes_grouped_params():
     # 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"
+    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])
+        checkpoints = partial(exclude_groups=[iter_group])
         max_iter: Param[int] = field(groups=[iter_group])
         learning_rate: Param[float]
 
@@ -791,9 +791,9 @@ def test_partial_identifier_includes_ungrouped_params():
     # 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"
+    assert pid1 != pid2, (
+        "Partial identifiers should differ when non-excluded params differ"
+    )
 
 
 def test_partial_identifier_matches_config_without_excluded():
@@ -801,7 +801,7 @@ def test_partial_identifier_matches_config_without_excluded():
 
     class ConfigWithIter(Config):
         __xpmid__ = "test.partial_identifier.config"
-        checkpoints = subparameters(exclude_groups=[iter_group])
+        checkpoints = partial(exclude_groups=[iter_group])
         max_iter: Param[int] = field(groups=[iter_group])
         learning_rate: Param[float]
 
@@ -815,16 +815,16 @@ def test_partial_identifier_matches_config_without_excluded():
     # 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"
+    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])
+        checkpoints = partial(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]
@@ -835,9 +835,9 @@ def test_partial_identifier_multiple_groups():
     # 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"
+    assert pid1 == pid2, (
+        "Partial identifiers should match when param is in any excluded group"
+    )
 
 
 def test_partial_identifier_include_overrides_exclude():
@@ -845,7 +845,7 @@ def test_partial_identifier_include_overrides_exclude():
 
     class ConfigIncludeOverride(Config):
         # iter_group is excluded but also included, so it should NOT be excluded
-        partial = subparameters(
+        partial = partial(
             exclude_groups=[iter_group, model_group], include_groups=[iter_group]
         )
         x: Param[int] = field(groups=[iter_group])
@@ -873,7 +873,7 @@ def test_partial_identifier_exclude_all():
 
     class ConfigExcludeAll(Config):
         # Exclude all, but include model_group
-        partial = subparameters(exclude_all=True, include_groups=[model_group])
+        partial = partial(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
@@ -895,16 +895,16 @@ def test_partial_identifier_exclude_all():
     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"
+    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)
+        partial = partial(exclude_no_group=True)
         x: Param[int] = field(groups=[iter_group])
         y: Param[float]  # No group
 

experimaestro/tests/test_identifier_stability.py

@@ -1,3 +1,4 @@
+# ruff: noqa: T201 - This module uses print for CLI output when run as script
 # Tests for identifier stability across versions
 
 import json
@@ -395,8 +396,7 @@ def test_identifier_stability():
 
     if not reference_file.exists():
         raise FileNotFoundError(
-            f"Reference file {reference_file} not found. "
-            f"Run 'python {__file__}' to generate it."
+            f"Reference file {reference_file} not found. Run 'python {__file__}' to generate it."
         )
 
     # Load reference identifiers
@@ -417,9 +417,7 @@ def test_identifier_stability():
             )
         elif current_id != expected_id:
             mismatches.append(
-                f"  - {name}: MISMATCH\n"
-                f"    Expected: {expected_id}\n"
-                f"    Current:  {current_id}"
+                f"  - {name}: MISMATCH\n    Expected: {expected_id}\n    Current:  {current_id}"
             )
 
     # Check for removed configurations

experimaestro/tests/test_multitoken.py

@@ -45,13 +45,11 @@ class TokenUsageTracker:
 
             if self.memory_used > self.memory_limit:
                 self.violations.append(
-                    f"Memory limit exceeded: {self.memory_used} > {self.memory_limit} "
-                    f"(task {task_id})"
+                    f"Memory limit exceeded: {self.memory_used} > {self.memory_limit} (task {task_id})"
                 )
             if self.cpu_used > self.cpu_limit:
                 self.violations.append(
-                    f"CPU limit exceeded: {self.cpu_used} > {self.cpu_limit} "
-                    f"(task {task_id})"
+                    f"CPU limit exceeded: {self.cpu_used} > {self.cpu_limit} (task {task_id})"
                 )
 
             logger.debug(

experimaestro/tests/{test_subparameters.py → test_partial.py}

@@ -1,14 +1,14 @@
-"""Tests for subparameters (partial identifier computation)"""
+"""Tests for partial (partial identifier computation)"""
 
 from experimaestro import (
     Config,
     Task,
     Param,
     field,
-    subparameters,
+    partial,
     param_group,
     ParameterGroup,
-    Subparameters,
+    Partial,
 )
 
 
@@ -17,8 +17,8 @@ iter_group = param_group("iter")
 model_group = param_group("model")
 
 
-class TestSubparametersBasic:
-    """Test basic subparameters functionality"""
+class TestPartialBasic:
+    """Test basic partial functionality"""
 
     def test_param_group_creation(self):
         """Test creating parameter groups"""
@@ -42,38 +42,38 @@ class TestSubparametersBasic:
         s2 = {group1, group3}
         assert len(s2) == 2
 
-    def test_subparameters_creation(self):
-        """Test creating subparameters"""
-        sp = subparameters(exclude_groups=[iter_group])
-        assert isinstance(sp, Subparameters)
+    def test_partials_creation(self):
+        """Test creating partial"""
+        sp = partial(exclude_groups=[iter_group])
+        assert isinstance(sp, Partial)
         assert iter_group in sp.exclude_groups
 
-    def test_subparameters_is_excluded(self):
+    def test_partials_is_excluded(self):
         """Test is_excluded method"""
-        sp = subparameters(exclude_groups=[iter_group])
+        sp = partial(exclude_groups=[iter_group])
         assert sp.is_excluded({iter_group}) is True
         assert sp.is_excluded({model_group}) is False
         assert sp.is_excluded(set()) is False
 
-    def test_subparameters_include_overrides_exclude(self):
+    def test_partials_include_overrides_exclude(self):
         """Test that include_groups overrides exclude_groups"""
-        sp = subparameters(
+        sp = partial(
             exclude_groups=[iter_group, model_group], include_groups=[iter_group]
         )
         # iter_group is in both, but include wins
         assert sp.is_excluded({iter_group}) is False
         assert sp.is_excluded({model_group}) is True
 
-    def test_subparameters_exclude_all(self):
+    def test_partials_exclude_all(self):
         """Test exclude_all option"""
-        sp = subparameters(exclude_all=True, include_groups=[model_group])
+        sp = partial(exclude_all=True, include_groups=[model_group])
         assert sp.is_excluded({iter_group}) is True
         assert sp.is_excluded({model_group}) is False
         assert sp.is_excluded(set()) is True
 
-    def test_subparameters_exclude_no_group(self):
+    def test_partials_exclude_no_group(self):
         """Test exclude_no_group option"""
-        sp = subparameters(exclude_no_group=True)
+        sp = partial(exclude_no_group=True)
         assert sp.is_excluded(set()) is True
         assert sp.is_excluded({iter_group}) is False
 
@@ -94,24 +94,24 @@ class TestPartialIdentifiers:
         assert iter_group in xpmtype.arguments["x"].groups
         assert len(xpmtype.arguments["y"].groups) == 0
 
-    def test_subparameters_collected_in_objecttype(self):
-        """Test that subparameters are collected in ObjectType"""
+    def test_partials_collected_in_objecttype(self):
+        """Test that partial are collected in ObjectType"""
 
         class MyTask(Task):
-            checkpoints = subparameters(exclude_groups=[iter_group])
+            checkpoints = partial(exclude_groups=[iter_group])
             x: Param[int]
 
         xpmtype = MyTask.__getxpmtype__()
         xpmtype.__initialize__()
 
-        assert "checkpoints" in xpmtype._subparameters
-        assert xpmtype._subparameters["checkpoints"].name == "checkpoints"
+        assert "checkpoints" in xpmtype._partials
+        assert xpmtype._partials["checkpoints"].name == "checkpoints"
 
     def test_partial_identifier_same_when_excluded_differs(self):
         """Test that partial identifiers are the same when only excluded params differ"""
 
         class MyTask(Task):
-            checkpoints = subparameters(exclude_groups=[iter_group])
+            checkpoints = partial(exclude_groups=[iter_group])
             max_iter: Param[int] = field(groups=[iter_group])
             learning_rate: Param[float]
 
@@ -130,7 +130,7 @@ class TestPartialIdentifiers:
         """Test that partial identifiers differ when included params differ"""
 
         class MyTask(Task):
-            checkpoints = subparameters(exclude_groups=[iter_group])
+            checkpoints = partial(exclude_groups=[iter_group])
             max_iter: Param[int] = field(groups=[iter_group])
             learning_rate: Param[float]
 
@@ -146,7 +146,7 @@ class TestPartialIdentifiers:
         """Test partial identifiers with parameters in multiple groups"""
 
         class MyTask(Task):
-            checkpoints = subparameters(exclude_groups=[iter_group])
+            checkpoints = partial(exclude_groups=[iter_group])
             # This parameter is in both groups
             x: Param[int] = field(groups=[iter_group, model_group])
             y: Param[float]

experimaestro/tests/test_partial_paths.py

@@ -7,7 +7,7 @@ from experimaestro import (
     Meta,
     field,
     PathGenerator,
-    subparameters,
+    partial,
     param_group,
 )
 from experimaestro.scheduler import JobState
@@ -20,10 +20,10 @@ iter_group = param_group("iter")
 
 
 class TaskWithPartial(Task):
-    """Task that uses subparameters for partial paths"""
+    """Task that uses partial for partial paths"""
 
-    # Define a subparameters set
-    checkpoints = subparameters(exclude_groups=[iter_group])
+    # Define a partial set
+    checkpoints = partial(exclude_groups=[iter_group])
 
     # Parameter in iter_group - excluded from partial identifier
     max_iter: Param[int] = field(groups=[iter_group])
@@ -93,139 +93,82 @@ def test_partial_path_different_for_different_params():
         assert task1.checkpoint_path != task2.checkpoint_path
 
 
-def test_partial_registered_in_database():
-    """Test that partials are registered in the database when jobs are submitted"""
-    from experimaestro.scheduler.state_provider import WorkspaceStateProvider
-    from experimaestro.scheduler.state_db import PartialModel, JobPartialModel
-
-    with TemporaryDirectory(prefix="xpm", suffix="partial_db") as workdir:
-        with TemporaryExperiment("partial_db", workdir=workdir, maxwait=30) as xp:
-            task = TaskWithPartial.C(max_iter=100, learning_rate=0.1).submit()
-
-        assert task.__xpm__.job.state == JobState.DONE
-
-        # Get the state provider and check database
-        # Note: Must use read_only=False since the experiment left a singleton
-        # with read_only=False that hasn't been closed yet
-        provider = WorkspaceStateProvider.get_instance(workdir, read_only=False)
-
-        try:
-            with provider.workspace_db.bind_ctx([PartialModel, JobPartialModel]):
-                # Check that partial is registered
-                partials = list(PartialModel.select())
-                assert len(partials) == 1
-                assert partials[0].subparameters_name == "checkpoints"
-
-                # Check that job is linked to partial
-                job_partials = list(JobPartialModel.select())
-                assert len(job_partials) == 1
-                assert job_partials[0].partial_id == partials[0].partial_id
-                assert job_partials[0].experiment_id == xp.workdir.name
-        finally:
-            provider.close()
-
-
-def test_orphan_partial_cleanup():
-    """Test that orphan partials are cleaned up when jobs are deleted"""
-    from experimaestro.scheduler.state_provider import WorkspaceStateProvider
-    from experimaestro.scheduler.state_db import PartialModel, JobPartialModel
-
-    with TemporaryDirectory(prefix="xpm", suffix="partial_cleanup") as workdir:
-        with TemporaryExperiment("partial_cleanup", workdir=workdir, maxwait=30) as xp:
-            task = TaskWithPartial.C(max_iter=100, learning_rate=0.1).submit()
-
-        assert task.__xpm__.job.state == JobState.DONE
-        checkpoint_path = task.checkpoint_path
-
-        # Verify partial path exists
-        assert checkpoint_path.exists()
-
-        # Get the state provider
-        provider = WorkspaceStateProvider.get_instance(workdir, read_only=False)
-
-        try:
-            # Delete the job
-            with provider.workspace_db.bind_ctx([PartialModel, JobPartialModel]):
-                job_partials = list(JobPartialModel.select())
-                assert len(job_partials) == 1
-
-            # Delete job (this also removes job-partial link)
-            provider.delete_job(
-                task.__xpm__.job.identifier,
-                xp.workdir.name,
-                xp.run_id,
-            )
-
-            # Now the partial should be orphaned
-            orphans = provider.get_orphan_partials()
-            assert len(orphans) == 1
-
-            # Cleanup orphan partials
-            deleted = provider.cleanup_orphan_partials(perform=True)
-            assert len(deleted) == 1
-
-            # Verify partial directory is deleted
-            assert not checkpoint_path.exists()
-
-            # Verify partial is removed from database
-            with provider.workspace_db.bind_ctx([PartialModel]):
-                partials = list(PartialModel.select())
-                assert len(partials) == 0
-        finally:
-            provider.close()
-
-
-def test_shared_partial_not_orphaned():
-    """Test that partials shared by multiple jobs are not orphaned until all jobs deleted"""
-    from experimaestro.scheduler.state_provider import WorkspaceStateProvider
-
-    with TemporaryDirectory(prefix="xpm", suffix="partial_shared_cleanup") as workdir:
-        with TemporaryExperiment(
-            "partial_shared_cleanup", workdir=workdir, maxwait=30
-        ) as xp:
-            # Submit two tasks with same learning_rate (same partial)
-            task1 = TaskWithPartial.C(max_iter=100, learning_rate=0.1).submit()
-            task2 = TaskWithPartial.C(max_iter=200, learning_rate=0.1).submit()
-
-        assert task1.__xpm__.job.state == JobState.DONE
-        assert task2.__xpm__.job.state == JobState.DONE
-
-        # They share the same partial path
-        checkpoint_path = task1.checkpoint_path
-        assert checkpoint_path == task2.checkpoint_path
-        assert checkpoint_path.exists()
-
-        provider = WorkspaceStateProvider.get_instance(workdir, read_only=False)
+def test_partial_concurrent_processes():
+    """Test that two processes competing for the same partial are serialized.
+
+    Similar to test_token_reschedule but for partial locking:
+    - Two tasks with different x (excluded param) share the same partial
+    - They should run sequentially (one after the other)
+    """
+    import sys
+    import subprocess
+    import logging
+    import time
+    import pytest
+    from .utils import TemporaryDirectory, timeout, get_times_frompath
+
+    with TemporaryDirectory("partial_reschedule") as workdir:
+        lockingpath = workdir / "lockingpath"
+
+        command = [
+            sys.executable,
+            Path(__file__).parent / "partial_reschedule.py",
+            workdir,
+        ]
+
+        ready1 = workdir / "ready.1"
+        time1 = workdir / "time.1"
+        p1 = subprocess.Popen(
+            command + ["1", str(lockingpath), str(ready1), str(time1)]
+        )
+
+        ready2 = workdir / "ready.2"
+        time2 = workdir / "time.2"
+        p2 = subprocess.Popen(
+            command + ["2", str(lockingpath), str(ready2), str(time2)]
+        )
 
         try:
-            # Delete first job
-            provider.delete_job(
-                task1.__xpm__.job.identifier,
-                xp.workdir.name,
-                xp.run_id,
-            )
-
-            # Partial should NOT be orphaned (still used by task2)
-            orphans = provider.get_orphan_partials()
-            assert len(orphans) == 0
-
-            # Partial directory should still exist
-            assert checkpoint_path.exists()
-
-            # Delete second job
-            provider.delete_job(
-                task2.__xpm__.job.identifier,
-                xp.workdir.name,
-                xp.run_id,
-            )
-
-            # Now partial should be orphaned
-            orphans = provider.get_orphan_partials()
-            assert len(orphans) == 1
-
-            # Cleanup
-            deleted = provider.cleanup_orphan_partials(perform=True)
-            assert len(deleted) == 1
-            assert not checkpoint_path.exists()
-        finally:
-            provider.close()
+            with timeout(30):
+                logging.info("Waiting for both experiments to be ready")
+                # Wait that both processes are ready
+                while not ready1.is_file():
+                    time.sleep(0.01)
+                while not ready2.is_file():
+                    time.sleep(0.01)
+
+                # Create the locking path to allow tasks to finish
+                logging.info(
+                    "Both processes are ready: allowing tasks to finish by writing in %s",
+                    lockingpath,
+                )
+                lockingpath.write_text("Let's go")
+
+                # Waiting for the output
+                logging.info("Waiting for XP1 to finish (%s)", time1)
+                while not time1.is_file():
+                    time.sleep(0.01)
+                logging.info("Experiment 1 finished")
+
+                logging.info("Waiting for XP2 to finish")
+                while not time2.is_file():
+                    time.sleep(0.01)
+                logging.info("Experiment 2 finished")
+
+                time1_val = get_times_frompath(time1)
+                time2_val = get_times_frompath(time2)
+
+                logging.info("%s vs %s", time1_val, time2_val)
+                # One should have finished before the other started
+                # (they share the same partial, so only one can run at a time)
+                assert time1_val > time2_val or time2_val > time1_val
+        except TimeoutError:
+            p1.terminate()
+            p2.terminate()
+            pytest.fail("Timeout")
+
+        except Exception:
+            logging.warning("Other exception: killing processes (just in case)")
+            p1.terminate()
+            p2.terminate()
+            raise