experimaestro 1.5.1__py3-none-any.whl → 2.0.0a8__py3-none-any.whl

experimaestro/tests/test_checkers.py

@@ -10,7 +10,7 @@ def test_choices():
     class TestChoices(Config):
         a: Annotated[str, Choices(["a", "b"])]
 
-    TestChoices(a="a").__xpm__.validate()
+    TestChoices.C(a="a").__xpm__.validate()
 
     with pytest.raises((ValueError, KeyError)):
-        TestChoices(a="c").__xpm__.validate()
+        TestChoices.C(a="c").__xpm__.validate()

experimaestro/tests/test_dependencies.py

@@ -1,7 +1,7 @@
 from typing import Any, Callable
 import pytest
 from experimaestro import Config, Param, Task, RunMode
-from experimaestro.scheduler.base import JobDependency
+from experimaestro.scheduler.jobs import JobDependency
 from experimaestro.tests.utils import TemporaryExperiment
 
 
@@ -35,21 +35,21 @@ class TaskB(Task):
 
 
 def test_dependencies_simple(xp):
-    a = TaskA().submit()
-    b = TaskB(a=a).submit()
+    a = TaskA.C().submit()
+    b = TaskB.C(a=a).submit()
     check_dependencies(b, a)
 
 
 def test_dependencies_implicit(xp):
-    a = TaskA().submit()
-    b = TaskB(a=a)
+    a = TaskA.C().submit()
+    b = TaskB.C(a=a)
     b.submit()
     check_dependencies(b, a)
 
 
 class TaskC(Task):
     def task_outputs(self, dep: Callable[[Config], None]) -> Any:
-        return dep(ConfigC(param_c=self))
+        return dep(ConfigC.C(param_c=self))
 
 
 class ConfigC(Config):
@@ -61,15 +61,15 @@ class TaskD(Task):
 
 
 def test_dependencies_task_output(xp):
-    task_c = TaskC()
+    task_c = TaskC.C()
     c = task_c.submit()
-    d = TaskD(param_c=c).submit()
+    d = TaskD.C(param_c=c).submit()
     check_dependencies(d, task_c)
 
 
 class Inner_TaskA(Task):
     def task_outputs(self, dep: Callable[[Config], None]) -> Any:
-        return dep(Inner_OutputTaskA())
+        return dep(Inner_OutputTaskA.C())
 
 
 class Inner_OutputTaskA(Config):
@@ -81,13 +81,7 @@ class Inner_TaskB(Task):
 
 
 def test_dependencies_inner_task_output(xp):
-    task_a = Inner_TaskA()
+    task_a = Inner_TaskA.C()
     a = task_a.submit()
-    b = Inner_TaskB(param_a=a).submit()
+    b = Inner_TaskB.C(param_a=a).submit()
     check_dependencies(b, task_a)
-
-
-def test_dependencies_pre_task(xp):
-    a = TaskA().submit()
-    a2 = TaskA().add_pretasks(a).submit()
-    check_dependencies(a2, a)

experimaestro/tests/test_experiment.py

@@ -0,0 +1,73 @@
+from experimaestro import Task, Param, get_experiment, tag
+from experimaestro.tests.utils import TemporaryDirectory, TemporaryExperiment
+
+
+class TaskA(Task):
+    def execute(self):
+        pass
+
+
+class TaskB(Task):
+    task_a: Param[TaskA]
+    x: Param[int]
+
+    def execute(self):
+        pass
+
+
+# xp = get_experiment(id="my-xp-1")
+
+# # Returns a list of tasks which were submitted and successful
+# tasks = xp.get_tasks(myxps.evaluation.Evaluation, status=Job.DONE)
+
+# for task in tasks:
+#     # Look at the tags
+#     print(task.tags)
+
+#     # Get some information
+#     print("Task ran in {task.workdir}")
+
+#     # Look at the parent jobs
+#    print(task.depends_on)
+
+#    # Look at the dependant
+#    print(task.dependents)
+
+
+def test_experiment_history():
+    """Test retrieving experiment history"""
+    with TemporaryDirectory() as workdir:
+        with TemporaryExperiment("experiment", workdir=workdir):
+            task_a = TaskA.C().submit()
+            TaskB.C(task_a=task_a, x=tag(1)).submit()
+
+        # Look at the experiment
+        xp = get_experiment("experiment", workdir=workdir)
+
+        (task_a_info,) = xp.get_jobs(TaskA)
+        (task_b_info,) = xp.get_jobs(TaskB)
+        assert task_b_info.tags == {"x": 1}
+        assert task_b_info.depends_on == [task_a_info]
+
+
+class FlagHandler:
+    def __init__(self):
+        self.flag = False
+
+    def set(self):
+        self.flag = True
+
+    def is_set(self):
+        return self.flag
+
+
+def test_experiment_events():
+    """Test handlers"""
+
+    flag = FlagHandler()
+    with TemporaryExperiment("experiment"):
+        task_a = TaskA.C()
+        task_a.submit()
+        task_a.on_completed(flag.set)
+
+    assert flag.is_set()

experimaestro/tests/test_file_progress.py

@@ -0,0 +1,425 @@
+"""Tests for the file-based progress tracking system"""
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from experimaestro.progress import (
+    ProgressEntry,
+    ProgressFileWriter,
+    ProgressFileReader,
+    FileBasedProgressReporter,
+)
+
+
+class TestProgressEntry:
+    """Test ProgressEntry dataclass"""
+
+    def test_to_dict(self):
+        entry = ProgressEntry(
+            timestamp=1234567890.0, level=1, progress=0.5, desc="Test description"
+        )
+
+        expected = {
+            "timestamp": 1234567890.0,
+            "level": 1,
+            "progress": 0.5,
+            "desc": "Test description",
+        }
+
+        assert entry.to_dict() == expected
+
+    def test_from_dict(self):
+        data = {
+            "timestamp": 1234567890.0,
+            "level": 1,
+            "progress": 0.5,
+            "desc": "Test description",
+        }
+
+        entry = ProgressEntry.from_dict(data)
+
+        assert entry.timestamp == 1234567890.0
+        assert entry.level == 1
+        assert entry.progress == 0.5
+        assert entry.desc == "Test description"
+
+    def test_from_dict_minimal(self):
+        data = {"timestamp": 1234567890.0, "level": 0, "progress": 1.0}
+
+        entry = ProgressEntry.from_dict(data)
+
+        assert entry.timestamp == 1234567890.0
+        assert entry.level == 0
+        assert entry.progress == 1.0
+        assert entry.desc is None
+
+
+class TestProgressFileWriter:
+    """Test ProgressFileWriter class"""
+
+    def test_init_creates_directory(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+            writer = ProgressFileWriter(task_path)
+
+            assert writer.progress_dir.exists()
+            assert writer.progress_dir == task_path / ".experimaestro"
+
+    def test_write_single_progress(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+            writer = ProgressFileWriter(task_path)
+
+            writer.write_progress(0, 0.5, "Test progress")
+
+            # Check file was created
+            progress_file = writer.progress_dir / "progress-0000.jsonl"
+            assert progress_file.exists()
+
+            # Check symlink was created
+            latest_link = writer.progress_dir / "progress-latest.jsonl"
+            assert latest_link.exists()
+            assert latest_link.is_symlink()
+            assert latest_link.resolve().name == progress_file.name
+
+    def test_write_multiple_progress(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+            writer = ProgressFileWriter(task_path)
+
+            # Write multiple progress entries
+            writer.write_progress(0, 0.1, "Step 1")
+            writer.write_progress(0, 0.5, "Step 2")
+            writer.write_progress(1, 0.3, "Substep")
+            writer.write_progress(0, 1.0, "Complete")
+
+            progress_file = writer.progress_dir / "progress-0000.jsonl"
+            assert progress_file.exists()
+
+            # Read and verify entries
+            lines = progress_file.read_text().strip().split("\n")
+            assert len(lines) == 4
+
+            # Check first entry
+            entry1 = json.loads(lines[0])
+            assert entry1["level"] == 0
+            assert entry1["progress"] == 0.1
+            assert entry1["desc"] == "Step 1"
+
+    def test_file_rotation(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+            # Set small max entries for testing rotation
+            writer = ProgressFileWriter(task_path, max_entries_per_file=2)
+
+            # Write 3 entries to trigger rotation
+            writer.write_progress(0, 0.1, "Entry 1")
+            writer.write_progress(0, 0.2, "Entry 2")
+            writer.write_progress(0, 0.3, "Entry 3")  # Should trigger rotation
+
+            # Check both files exist
+            file1 = writer.progress_dir / "progress-0000.jsonl"
+            file2 = writer.progress_dir / "progress-0001.jsonl"
+
+            assert file1.exists()
+            assert file2.exists()
+
+            # Check file1 has 2 entries
+            lines1 = file1.read_text().strip().split("\n")
+            assert len(lines1) == 2
+
+            # Check file2 has 1 entry
+            lines2 = file2.read_text().strip().split("\n")
+            assert len(lines2) == 1
+
+            # Check symlink points to latest file
+            latest_link = writer.progress_dir / "progress-latest.jsonl"
+            assert latest_link.resolve().name == file2.name
+
+    def test_resume_from_existing_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Create first writer and write some entries
+            writer1 = ProgressFileWriter(task_path, max_entries_per_file=2)
+            writer1.write_progress(0, 0.1, "Entry 1")
+            writer1.write_progress(0, 0.2, "Entry 2")
+
+            # Create second writer (simulating restart)
+            writer2 = ProgressFileWriter(task_path, max_entries_per_file=2)
+
+            # Should resume from existing state
+            assert writer2.current_file_index == 0
+            assert writer2.current_file_entries == 2
+
+            # Writing one more should trigger rotation
+            writer2.write_progress(0, 0.3, "Entry 3")
+
+            file2 = writer2.progress_dir / "progress-0001.jsonl"
+            assert file2.exists()
+
+
+class TestProgressFileReader:
+    """Test ProgressFileReader class"""
+
+    def test_read_entries_from_file(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Write some test data
+            writer = ProgressFileWriter(task_path)
+            writer.write_progress(0, 0.5, "Test")
+            writer.write_progress(1, 0.3, "Nested")
+
+            # Read it back
+            reader = ProgressFileReader(task_path)
+            progress_file = reader.get_progress_files()[0]
+            entries = list(reader.read_entries(progress_file))
+
+            assert len(entries) == 2
+            assert entries[0].level == 0
+            assert entries[0].progress == 0.5
+            assert entries[0].desc == "Test"
+            assert entries[1].level == 1
+            assert entries[1].progress == 0.3
+            assert entries[1].desc == "Nested"
+
+    def test_read_all_entries(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Write entries across multiple files
+            writer = ProgressFileWriter(task_path, max_entries_per_file=2)
+            writer.write_progress(0, 0.1, "Entry 1")
+            writer.write_progress(0, 0.2, "Entry 2")
+            writer.write_progress(0, 0.3, "Entry 3")  # Triggers rotation
+            writer.write_progress(0, 0.4, "Entry 4")
+
+            # Read all entries
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            assert len(entries) == 4
+            assert entries[0].desc == "Entry 1"
+            assert entries[1].desc == "Entry 2"
+            assert entries[2].desc == "Entry 3"
+            assert entries[3].desc == "Entry 4"
+
+    def test_read_latest_entries(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Write many entries
+            writer = ProgressFileWriter(task_path, max_entries_per_file=3)
+            for i in range(10):
+                writer.write_progress(0, i / 10.0, f"Entry {i}")
+
+            # Read latest 5 entries
+            reader = ProgressFileReader(task_path)
+            latest = reader.read_latest_entries(5)
+
+            assert len(latest) == 5
+            # Should be entries 5-9 in chronological order
+            assert latest[0].desc == "Entry 5"
+            assert latest[4].desc == "Entry 9"
+
+    def test_get_current_progress(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Write progress for multiple levels
+            writer = ProgressFileWriter(task_path)
+            writer.write_progress(0, 0.1, "Level 0 start")
+            writer.write_progress(1, 0.5, "Level 1 progress")
+            writer.write_progress(0, 0.5, "Level 0 update")
+            writer.write_progress(1, 1.0, "Level 1 complete")
+            writer.write_progress(0, 1.0, "Level 0 complete")
+
+            # Get current progress
+            reader = ProgressFileReader(task_path)
+            current = reader.get_current_progress()
+
+            assert len(current) == 2
+            assert current[0].progress == 1.0
+            assert current[0].desc == "Level 0 complete"
+            assert current[1].progress == 1.0
+            assert current[1].desc == "Level 1 complete"
+
+    def test_get_latest_file_via_symlink(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Write some entries
+            writer = ProgressFileWriter(task_path, max_entries_per_file=2)
+            writer.write_progress(0, 0.1, "Entry 1")
+            writer.write_progress(0, 0.2, "Entry 2")
+            writer.write_progress(0, 0.3, "Entry 3")  # Triggers rotation
+
+            # Get latest file
+            reader = ProgressFileReader(task_path)
+            latest_file = reader.get_latest_file()
+
+            expected_file = task_path / ".experimaestro" / "progress-0001.jsonl"
+            assert latest_file.name == expected_file.name
+
+    def test_no_progress_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reader = ProgressFileReader(task_path)
+
+            assert reader.get_progress_files() == []
+            assert reader.get_latest_file() is None
+            assert list(reader.read_all_entries()) == []
+            assert reader.read_latest_entries(10) == []
+            assert reader.get_current_progress() == {}
+
+
+class TestFileBasedProgressReporter:
+    """Test FileBasedProgressReporter class"""
+
+    def test_set_progress_writes_to_file(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reporter = FileBasedProgressReporter(task_path)
+            reporter.set_progress(0.5, 0, "Test progress")
+
+            # Verify file was written
+            progress_file = task_path / ".experimaestro" / "progress-0000.jsonl"
+            assert progress_file.exists()
+
+            # Read and verify content
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            assert len(entries) == 1
+            assert entries[0].level == 0
+            assert entries[0].progress == 0.5
+            assert entries[0].desc == "Test progress"
+
+    def test_set_progress_threshold(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reporter = FileBasedProgressReporter(task_path)
+
+            # First progress
+            reporter.set_progress(0.5, 0, "Test")
+
+            # Small change (should not write)
+            reporter.set_progress(0.505, 0, "Test")
+
+            # Larger change (should write)
+            reporter.set_progress(0.6, 0, "Test")
+
+            # Read entries
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            # Should only have 2 entries (first and third)
+            assert len(entries) == 2
+            assert entries[0].progress == 0.5
+            assert entries[1].progress == 0.6
+
+    def test_set_progress_description_change(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reporter = FileBasedProgressReporter(task_path)
+
+            # Same progress, different description
+            reporter.set_progress(0.5, 0, "Description 1")
+            reporter.set_progress(0.5, 0, "Description 2")
+
+            # Read entries
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            # Should have both entries due to description change
+            assert len(entries) == 2
+            assert entries[0].desc == "Description 1"
+            assert entries[1].desc == "Description 2"
+
+    def test_eoj_writes_marker(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reporter = FileBasedProgressReporter(task_path)
+            reporter.set_progress(1.0, 0, "Complete")
+            reporter.eoj()
+
+            # Read entries
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            assert len(entries) == 2
+            assert entries[0].level == 0
+            assert entries[0].progress == 1.0
+            assert entries[1].level == -1  # EOJ marker
+            assert entries[1].progress == 1.0
+            assert entries[1].desc == "EOJ"
+
+    def test_multiple_levels(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            reporter = FileBasedProgressReporter(task_path)
+
+            # Progress at different levels
+            reporter.set_progress(0.1, 0, "Main task")
+            reporter.set_progress(0.5, 1, "Subtask")
+            reporter.set_progress(0.3, 2, "Sub-subtask")
+            reporter.set_progress(0.5, 0, "Main task update")
+
+            # Read current progress
+            reader = ProgressFileReader(task_path)
+            current = reader.get_current_progress()
+
+            assert len(current) == 3
+            assert current[0].progress == 0.5
+            assert current[0].desc == "Main task update"
+            assert current[1].progress == 0.5
+            assert current[1].desc == "Subtask"
+            assert current[2].progress == 0.3
+            assert current[2].desc == "Sub-subtask"
+
+
+class TestIntegrationWithNotifications:
+    """Test integration with existing notification system"""
+
+    @patch("experimaestro.taskglobals.Env.instance")
+    def test_progress_function_writes_to_file(self, mock_env):
+        """Test that the progress() function writes to file system"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            task_path = Path(tmpdir)
+
+            # Mock the task environment
+            mock_env.return_value.taskpath = task_path
+            mock_env.return_value.slave = False
+
+            # Import and call progress function
+            from experimaestro.notifications import progress
+
+            progress(0.5, level=0, desc="Test progress")
+
+            # Verify file was written
+            progress_file = task_path / ".experimaestro" / "progress-0000.jsonl"
+            assert progress_file.exists()
+
+            # Read and verify
+            reader = ProgressFileReader(task_path)
+            entries = list(reader.read_all_entries())
+
+            assert len(entries) == 1
+            assert entries[0].level == 0
+            assert entries[0].progress == 0.5
+            assert entries[0].desc == "Test progress"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])