experimaestro 1.11.1__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_experiment.py

@@ -38,8 +38,8 @@ def test_experiment_history():
     """Test retrieving experiment history"""
     with TemporaryDirectory() as workdir:
         with TemporaryExperiment("experiment", workdir=workdir):
-            task_a = TaskA().submit()
-            TaskB(task_a=task_a, x=tag(1)).submit()
+            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)
@@ -66,7 +66,7 @@ def test_experiment_events():
 
     flag = FlagHandler()
     with TemporaryExperiment("experiment"):
-        task_a = TaskA()
+        task_a = TaskA.C()
         task_a.submit()
         task_a.on_completed(flag.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__])