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

experimaestro/scriptbuilder.py

@@ -67,9 +67,9 @@ class PythonScriptBuilder:
         Returns:
             str -- The script path on disk
         """
-        assert isinstance(
-            job, CommandLineJob
-        ), "Cannot handle a job which is not a command line job"
+        assert isinstance(job, CommandLineJob), (
+            "Cannot handle a job which is not a command line job"
+        )
         assert self.command is not None
         assert job.workspace, "No workspace defined for the job"
         assert job.launcher is not None, "No launcher defined for the job"
@@ -101,7 +101,7 @@ class PythonScriptBuilder:
                 """format='%(levelname)s:%(process)d:%(asctime)s [%(name)s] %(message)s', datefmt='%y-%m-%d %H:%M:%S')\n\n"""
             )
 
-            out.write("\nif __name__ == '__main__':\n\n" "")
+            out.write("\nif __name__ == '__main__':\n\n")
 
             # --- Checks locks right away
 

experimaestro/settings.py

@@ -23,6 +23,36 @@ class ServerSettings:
     """Token for the server"""
 
 
+@dataclass
+class HistorySettings:
+    """Settings for experiment history cleanup.
+
+    When an experiment ends, old runs are cleaned up according to these rules
+    (applied in order):
+
+    1. If current run succeeded, all past failed runs are removed
+    2. Failed runs that occurred before the newest successful run are removed
+       (since the success supersedes the earlier failures)
+    3. Keep at most `max_done` successful runs (oldest removed first)
+    4. Keep at most `max_failed` failed runs (oldest removed first)
+
+    Example: With max_done=2, max_failed=1 and runs:
+        - 10:00 completed
+        - 11:00 failed
+        - 12:00 completed
+        - 13:00 failed
+
+    Result: 11:00 failed is removed (before 12:00 success), 10:00 completed
+    is removed (max_done=2), leaving: 12:00 completed, 13:00 failed.
+    """
+
+    max_done: int = 5
+    """Maximum number of successful runs to keep per experiment"""
+
+    max_failed: int = 1
+    """Maximum number of failed runs to keep per experiment"""
+
+
 @dataclass
 class WorkspaceSettings:
     """Defines the workspace"""
@@ -45,6 +75,9 @@ class WorkspaceSettings:
     triggers: List[str] = field(default_factory=list)
     """Glob patterns to automatically select this workspace based on experiment ID"""
 
+    history: HistorySettings = field(default_factory=HistorySettings)
+    """Settings for experiment history cleanup"""
+
     def __post_init__(self):
         self.path = self.path.expanduser().resolve()
 
@@ -57,6 +90,9 @@ class Settings:
     env: Dict[str, str] = field(default_factory=dict)
     """Default environment variables"""
 
+    history: HistorySettings = field(default_factory=HistorySettings)
+    """Default history settings (can be overridden per workspace)"""
+
 
 @lru_cache()
 def get_settings(path: Optional[Path] = None) -> Settings:

experimaestro/tests/conftest.py

@@ -3,6 +3,9 @@ import pytest
 import os
 import shutil
 
+# Set shorter poll interval for tests (before any imports that read it)
+os.environ.setdefault("XPM_POLL_INTERVAL_MAX", "5.0")
+
 
 @pytest.fixture(scope="session")
 def xpmdirectory(tmp_path_factory):
@@ -23,7 +26,17 @@ def xpmdirectory(tmp_path_factory):
 def reset_scheduler():
     """Reset scheduler state between tests to avoid state leakage with singleton pattern"""
     from experimaestro.scheduler.base import Scheduler
-    from experimaestro.server import Server
+    from experimaestro.webui import WebUIServer
+    from experimaestro.tokens import CounterToken
+    from experimaestro.core.partial_lock import PartialJobResource
+    from experimaestro.dynamic import ResourcePoller
+
+    # Clear token and resource caches
+    CounterToken.TOKENS.clear()
+    PartialJobResource.RESOURCES.clear()
+
+    # Reset ResourcePoller singleton
+    ResourcePoller.reset()
 
     # Get the singleton instance if it exists
     if Scheduler._instance is not None:
@@ -60,9 +73,9 @@ def reset_scheduler():
             scheduler.addlistener(scheduler.state_provider)
 
     # Reset server instance too
-    if Server._instance is not None:
+    if WebUIServer._instance is not None:
         logging.debug("FIXTURE: Clearing server instance")
-        Server._instance = None
+        WebUIServer.clear_instance()
 
     yield
 
@@ -95,8 +108,15 @@ def reset_scheduler():
             scheduler.addlistener(scheduler.state_provider)
 
     # Reset server after test
-    if Server._instance is not None:
-        Server._instance = None
+    if WebUIServer._instance is not None:
+        WebUIServer.clear_instance()
+
+    # Clear token and resource caches after test
+    CounterToken.TOKENS.clear()
+    PartialJobResource.RESOURCES.clear()
+
+    # Reset ResourcePoller singleton after test
+    ResourcePoller.reset()
 
 
 # Sets a flag
@@ -105,6 +125,14 @@ def pytest_configure(config):
 
     sys._called_from_test = True
 
+    # Disable peewee logging by default (too verbose)
+    logging.getLogger("peewee").setLevel(logging.WARNING)
+
+    # Enable IPCom testing mode with polling for reliable file watching in tests
+    from experimaestro.ipc import IPCom
+
+    IPCom.set_testing_mode(enabled=True, polling_interval=0.01)
+
 
 def pytest_unconfigure(config):
     import sys  # This was missing from the manual

experimaestro/tests/connectors/bin/executable.py

@@ -1 +1 @@
-print("hello world")
+print("hello world")  # noqa: T201

experimaestro/tests/fixtures/pre_experiment/experiment_check_env.py

@@ -0,0 +1,16 @@
+"""Experiment that checks pre_experiment set an environment variable."""
+
+import os
+from experimaestro.experiments import ExperimentHelper, configuration, ConfigurationBase
+
+
+@configuration()
+class Configuration(ConfigurationBase):
+    pass
+
+
+def run(helper: ExperimentHelper, cfg: Configuration):
+    assert os.environ.get("XPM_TEST_PRE_EXPERIMENT") == "executed", (
+        "Pre-experiment script was not executed"
+    )
+    print("PRE_EXPERIMENT_TEST_PASSED")  # noqa: T201

experimaestro/tests/fixtures/pre_experiment/experiment_check_mock.py

@@ -0,0 +1,14 @@
+"""Experiment that checks pre_experiment mocked a module."""
+
+import xpm_fake_module  # noqa: F401 - this import will fail without pre_experiment
+from experimaestro.experiments import ExperimentHelper, configuration, ConfigurationBase
+
+
+@configuration()
+class Configuration(ConfigurationBase):
+    pass
+
+
+def run(helper: ExperimentHelper, cfg: Configuration):
+    assert xpm_fake_module.value == 42, "Mock module should have value 42"
+    print("MOCK_MODULE_TEST_PASSED")  # noqa: T201

experimaestro/tests/fixtures/pre_experiment/experiment_simple.py

@@ -0,0 +1,12 @@
+"""Simple experiment that does nothing."""
+
+from experimaestro.experiments import ExperimentHelper, configuration, ConfigurationBase
+
+
+@configuration()
+class Configuration(ConfigurationBase):
+    pass
+
+
+def run(helper: ExperimentHelper, cfg: Configuration):
+    pass

experimaestro/tests/fixtures/pre_experiment/pre_setup_env.py

@@ -0,0 +1,5 @@
+"""Pre-experiment script that sets an environment variable."""
+
+import os
+
+os.environ["XPM_TEST_PRE_EXPERIMENT"] = "executed"

experimaestro/tests/fixtures/pre_experiment/pre_setup_error.py

@@ -0,0 +1,3 @@
+"""Pre-experiment script that raises an error."""
+
+raise RuntimeError("Intentional error in pre_experiment")

experimaestro/tests/fixtures/pre_experiment/pre_setup_mock.py

@@ -0,0 +1,8 @@
+"""Pre-experiment script that mocks a module."""
+
+import sys
+from unittest.mock import MagicMock
+
+# Mock a module that doesn't exist
+sys.modules["xpm_fake_module"] = MagicMock()
+sys.modules["xpm_fake_module"].value = 42

experimaestro/tests/launchers/bin/test.py

@@ -1,3 +1,4 @@
+# ruff: noqa: T201 - Test script that outputs to stdout
 import argparse
 import sys
 

experimaestro/tests/launchers/test_slurm.py

@@ -104,14 +104,14 @@ class SlurmResumableTask(ResumableTask):
         if self.checkpoint.exists():
             attempt = int(self.checkpoint.read_text()) + 1
 
-        print(f"SlurmResumableTask attempt #{attempt}")
+        print(f"SlurmResumableTask attempt #{attempt}")  # noqa: T201
 
         # Write updated attempt count
         self.checkpoint.write_text(str(attempt))
 
         # Simulate timeout for first timeout_count attempts
         if attempt <= self.timeout_count:
-            print(f"Simulating SLURM TIMEOUT on attempt {attempt}")
+            print(f"Simulating SLURM TIMEOUT on attempt {attempt}")  # noqa: T201
             # Create timeout marker file for mock SLURM
             # The marker needs to be named <jobid>.timeout in the SLURM jobs directory
             # Use SLURM_JOB_ID environment variable (set by mock sbatch, like real SLURM)
@@ -123,7 +123,7 @@ class SlurmResumableTask(ResumableTask):
             raise RuntimeError(f"Simulated timeout on attempt {attempt}")
 
         # Success - task completed
-        print(f"Task completed successfully on attempt {attempt}")
+        print(f"Task completed successfully on attempt {attempt}")  # noqa: T201
         if self.output_file:
             self.output_file.write_text(f"Completed after {attempt} attempts")
 
@@ -151,15 +151,15 @@ def test_slurm_resumable_task(tmp_path: Path, slurmlauncher: SlurmLauncher):
 
         # Verify task completed successfully after retries
         assert state == JobState.DONE, f"Task did not complete successfully: {state}"
-        assert (
-            task.__xpm__.job.retry_count == 2
-        ), f"Expected 2 retries, got {task.__xpm__.job.retry_count}"
+        assert task.__xpm__.job.retry_count == 2, (
+            f"Expected 2 retries, got {task.__xpm__.job.retry_count}"
+        )
 
         # Verify checkpoint shows 3 attempts (2 timeouts + 1 success)
         assert checkpoint.exists(), "Checkpoint file was not created"
-        assert (
-            int(checkpoint.read_text()) == 3
-        ), f"Expected 3 attempts, got {checkpoint.read_text()}"
+        assert int(checkpoint.read_text()) == 3, (
+            f"Expected 3 attempts, got {checkpoint.read_text()}"
+        )
 
         # Verify output file was created on success
         assert output_file.exists(), "Output file was not created"

experimaestro/tests/partial_reschedule.py

@@ -0,0 +1,46 @@
+"""Script for running partial task in subprocess for concurrent testing"""
+
+if __name__ == "__main__":
+    import sys
+    import logging
+    from pathlib import Path
+    import time
+
+    from experimaestro.scheduler import JobState
+    from experimaestro.tests.utils import TemporaryExperiment
+    from experimaestro.tests.task_partial import PartialTask
+
+    root = logging.getLogger()
+    root.setLevel(logging.INFO)
+    logging.getLogger("xpm").setLevel(logging.DEBUG)
+
+    workdir, x, lockingpath, readypath, timepath = sys.argv[1:]
+
+    handler = logging.StreamHandler()
+    bf = logging.Formatter(
+        f"[XP{x}] [%(levelname)s] %(asctime)s.%(msecs)03d %(name)s "
+        f"[%(process)d/%(threadName)s]: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    handler.setFormatter(bf)
+    root.handlers.clear()
+    root.addHandler(handler)
+
+    with TemporaryExperiment("partial_reschedule%s" % x, workdir=workdir) as xp:
+        logging.info("Partial reschedule [%s]: starting task in %s", x, workdir)
+        task = PartialTask.C(path=lockingpath, x=int(x)).submit()
+
+        logging.info("Waiting for task (partial with %s) to be scheduled", lockingpath)
+        while task.job.state == JobState.UNSCHEDULED:
+            time.sleep(0.01)
+
+        # Write so that the test knows we are ready
+        Path(readypath).write_text("hello")
+        logging.info("Partial reschedule [%s]: ready", x)
+
+        # Wait until the experiment finishes
+        task.__xpm__.task.job.wait()
+        logging.info("Partial reschedule [%s]: finished", x)
+
+        # Write the timestamp from the task so the test can retrieve them easily
+        Path(timepath).write_text(Path(task.stdout()).read_text())

experimaestro/tests/restart.py

@@ -114,9 +114,9 @@ def restart(terminate: Callable, experiment):
                 time.sleep(0.1)
 
             currentState = scheduler.getJobState(job).result()
-            assert (
-                currentState == JobState.RUNNING
-            ), f"Job is not running (state is {currentState})"
+            assert currentState == JobState.RUNNING, (
+                f"Job is not running (state is {currentState})"
+            )
 
             # Notify the task
             with task.wait.open("w") as fp:

experimaestro/tests/restart_main.py

@@ -1,3 +1,4 @@
+# ruff: noqa: T201 - Test helper script
 import importlib
 import sys
 from experimaestro import experiment

experimaestro/tests/scripts/notifyandwait.py

@@ -1,3 +1,4 @@
+# ruff: noqa: T201 - Test script that outputs status to stderr
 import sys
 from pathlib import Path
 import time

experimaestro/tests/task_partial.py

@@ -0,0 +1,38 @@
+"""Task definitions for partial locking tests"""
+
+from pathlib import Path
+import time
+from experimaestro import Task, Param, Meta, field, PathGenerator, partial, param_group
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+# Define parameter groups
+iter_group = param_group("iter")
+
+
+class PartialTask(Task):
+    """Task that uses partial and waits for a file before completing"""
+
+    # Define a partial set
+    checkpoints = partial(exclude_groups=[iter_group])
+
+    # Parameter in iter_group - excluded from partial identifier
+    x: Param[int] = field(groups=[iter_group])
+
+    # The path to watch before completing
+    path: Param[Path]
+
+    # Path generated using the partial identifier
+    checkpoint_path: Meta[Path] = field(
+        default_factory=PathGenerator("checkpoint", partial=checkpoints)
+    )
+
+    def execute(self):
+        print(time.time())  # noqa: T201
+        # Create checkpoint directory
+        self.checkpoint_path.mkdir(parents=True, exist_ok=True)
+        # Wait for signal file
+        while not self.path.is_file():
+            time.sleep(0.1)
+        print(time.time())  # noqa: T201

experimaestro/tests/task_tokens.py

@@ -16,7 +16,7 @@ class TokenTask(Task):
     """A dummy parameter to create several distinct token tasks"""
 
     def execute(self):
-        print(time.time())
+        print(time.time())  # noqa: T201
         while not self.path.is_file():
             time.sleep(0.1)
-        print(time.time())
+        print(time.time())  # noqa: T201

experimaestro/tests/tasks/test_dynamic.py

@@ -201,9 +201,9 @@ def test_task_dynamic_replay():
             logging.info("First run ended (expected): %s", e)
 
         # First run should have produced at least one evaluation (for step 15)
-        assert (
-            len(evaluations_run1) == 1
-        ), f"Run 1: Expected 1 evaluation, got {len(evaluations_run1)}"
+        assert len(evaluations_run1) == 1, (
+            f"Run 1: Expected 1 evaluation, got {len(evaluations_run1)}"
+        )
 
         # Second run: restart and continue
         evaluations_run2 = []
@@ -226,6 +226,6 @@ def test_task_dynamic_replay():
         # - Replayed the step 15 checkpoint (from first run)
         # - Produced step 30 and 45 checkpoints
         # Total: 3 evaluations (but step 15 was replayed, not re-produced)
-        assert (
-            len(evaluations_run2) == 3
-        ), f"Run 2: Expected 3 evaluations, got {len(evaluations_run2)}"
+        assert len(evaluations_run2) == 3, (
+            f"Run 2: Expected 3 evaluations, got {len(evaluations_run2)}"
+        )

experimaestro/tests/test_dependencies.py

@@ -20,9 +20,9 @@ def check_dependencies(task: Task, *tasks: Task):
 
     assert len(deps) == len(tasks)
     for task in tasks:
-        assert (
-            id(task) in deps
-        ), f"Task {task.__xpmtype__} with ID {task.__identifier__()}"
+        assert id(task) in deps, (
+            f"Task {task.__xpmtype__} with ID {task.__identifier__()}"
+        )
         " is not not in the dependencies"
 
 

experimaestro/tests/test_deprecated.py

@@ -422,14 +422,14 @@ def test_task_deprecated_config_identifier():
         )
 
         # Old (non-deprecated) and new should have different paths
-        assert (
-            task_new.stdout() != task_old.stdout()
-        ), "Old and new path should be different"
+        assert task_new.stdout() != task_old.stdout(), (
+            "Old and new path should be different"
+        )
 
         # Deprecated should have same path as new (identifier matches)
-        assert (
-            task_new.stdout() == task_deprecated.stdout()
-        ), "Deprecated path should be the same as non deprecated"
+        assert task_new.stdout() == task_deprecated.stdout(), (
+            "Deprecated path should be the same as non deprecated"
+        )
 
 
 def test_task_deprecated_config_fix_deprecated():
@@ -485,14 +485,14 @@ def test_task_deprecated_identifier():
         task_deprecated = DeprecatedTask.C(x=1).submit(run_mode=RunMode.DRY_RUN)
 
         # Old and new should have different paths
-        assert (
-            task_new.stdout() != task_old.stdout()
-        ), "Old and new path should be different"
+        assert task_new.stdout() != task_old.stdout(), (
+            "Old and new path should be different"
+        )
 
         # Deprecated should have same path as new
-        assert (
-            task_new.stdout() == task_deprecated.stdout()
-        ), "Deprecated path should be the same as non deprecated"
+        assert task_new.stdout() == task_deprecated.stdout(), (
+            "Deprecated path should be the same as non deprecated"
+        )
 
 
 def test_task_deprecated_fix_deprecated():
@@ -550,9 +550,9 @@ def test_task_deprecated_with_convert_identifier():
         task_new = NewTaskWithConvert.C(values=[42]).submit(run_mode=RunMode.DRY_RUN)
 
         # Identifiers should match (computed via __convert__)
-        assert (
-            task_old.stdout() == task_new.stdout()
-        ), "Deprecated task should have same path as equivalent new task"
+        assert task_old.stdout() == task_new.stdout(), (
+            "Deprecated task should have same path as equivalent new task"
+        )
 
 
 @deprecate(NewTaskWithConvert, replace=True)