celldetective 1.5.0b10__py3-none-any.whl → 1.5.0b12__py3-none-any.whl

tests/gui/test_event_annotator_cleanup.py

@@ -0,0 +1,310 @@
+"""
+Tests for EventAnnotator and PairEventAnnotator closeEvent cleanup.
+
+These tests verify that the memory leak fixes in closeEvent properly:
+1. Close matplotlib figures
+2. Stop and delete animations
+3. Clear large data structures
+4. Call super().closeEvent()
+
+Bug prevented: Memory leaks from unclosed matplotlib figures and FuncAnimation
+reference cycles when closing the annotator windows.
+"""
+
+import pytest
+import gc
+import logging
+from unittest.mock import MagicMock, patch, PropertyMock
+import matplotlib.pyplot as plt
+from PyQt5.QtGui import QCloseEvent
+
+
+@pytest.fixture(autouse=True)
+def disable_logging():
+    """Disable all logging to avoid Windows OSError with pytest capture."""
+    try:
+        logging.disable(logging.CRITICAL)
+        yield
+    finally:
+        logging.disable(logging.NOTSET)
+
+
+class TestEventAnnotatorCloseEvent:
+    """
+    Tests for EventAnnotator.closeEvent memory cleanup.
+
+    Bug: closeEvent did not properly close matplotlib figures or delete
+    the FuncAnimation, causing memory leaks due to reference cycles.
+
+    Fix: Added proper cleanup of fig, cell_fig, anim, stack, and df_tracks.
+    """
+
+    def test_closeevent_closes_matplotlib_figures(self, qtbot):
+        """
+        Test that closeEvent properly closes matplotlib figures.
+
+        Steps:
+        1. Create a mock EventAnnotator with fig and cell_fig attributes
+        2. Call closeEvent
+        3. Verify plt.close was called for both figures
+        """
+        with patch("celldetective.gui.event_annotator.plt") as mock_plt:
+            # Create a minimal mock that simulates the annotator
+            from celldetective.gui.event_annotator import EventAnnotator
+
+            # Mock the parent and initialization to avoid complex setup
+            with patch.object(EventAnnotator, "__init__", lambda self, parent: None):
+                annotator = EventAnnotator(None)
+
+                # Set up minimal attributes needed for closeEvent
+                annotator.fig = MagicMock()
+                annotator.cell_fig = MagicMock()
+                annotator.anim = MagicMock()
+                annotator.anim.event_source = MagicMock()
+                annotator.stack = MagicMock()
+                annotator.df_tracks = MagicMock()
+                annotator.stop = MagicMock()
+
+                # Mock stop_btn for stop() method if needed
+                annotator.stop_btn = MagicMock()
+                annotator.start_btn = MagicMock()
+                annotator.prev_frame_btn = MagicMock()
+                annotator.next_frame_btn = MagicMock()
+
+                # Create a real QCloseEvent
+                event = QCloseEvent()
+
+                # Patch super().closeEvent to avoid Qt issues
+                with patch.object(EventAnnotator.__bases__[0], "closeEvent"):
+                    EventAnnotator.closeEvent(annotator, event)
+
+                # Verify figures were closed
+                assert mock_plt.close.call_count >= 2
+
+    def test_closeevent_stops_animation(self, qtbot):
+        """
+        Test that closeEvent stops the animation.
+
+        Steps:
+        1. Create mock annotator with anim attribute
+        2. Call closeEvent
+        3. Verify animation event_source.stop() was called
+        """
+        from celldetective.gui.event_annotator import EventAnnotator
+
+        with patch.object(EventAnnotator, "__init__", lambda self, parent: None):
+            annotator = EventAnnotator(None)
+
+            # Set up animation mock
+            mock_anim = MagicMock()
+            mock_anim.event_source = MagicMock()
+            annotator.anim = mock_anim
+
+            # Set up other required attributes
+            annotator.fig = MagicMock()
+            annotator.cell_fig = MagicMock()
+            annotator.stack = MagicMock()
+            annotator.df_tracks = MagicMock()
+            annotator.stop = MagicMock()
+            annotator.stop_btn = MagicMock()
+            annotator.start_btn = MagicMock()
+            annotator.prev_frame_btn = MagicMock()
+            annotator.next_frame_btn = MagicMock()
+
+            event = QCloseEvent()
+
+            with patch("celldetective.gui.event_annotator.plt"):
+                with patch.object(EventAnnotator.__bases__[0], "closeEvent"):
+                    EventAnnotator.closeEvent(annotator, event)
+
+            # Verify animation was stopped
+            mock_anim.event_source.stop.assert_called_once()
+
+
+class TestPairEventAnnotatorCloseEvent:
+    """
+    Tests for PairEventAnnotator.closeEvent memory cleanup.
+
+    Bug: closeEvent only deleted self.stack and didn't close figures,
+    stop animations, or clear dataframes.
+
+    Fix: Added proper cleanup of fig, cell_fig, anim, stack, dataframes,
+    and df_relative. Also calls super().closeEvent().
+    """
+
+    def test_closeevent_clears_dataframes(self, qtbot):
+        """
+        Test that closeEvent properly clears dataframes dictionary.
+
+        Steps:
+        1. Create mock PairEventAnnotator with dataframes attribute
+        2. Call closeEvent
+        3. Verify dataframes.clear() was called
+        """
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        with patch.object(PairEventAnnotator, "__init__", lambda self, parent: None):
+            annotator = PairEventAnnotator(None)
+
+            # Set up dataframes mock
+            mock_dataframes = MagicMock()
+            annotator.dataframes = mock_dataframes
+
+            # Set up other required attributes
+            annotator.fig = MagicMock()
+            annotator.cell_fig = MagicMock()
+            annotator.anim = MagicMock()
+            annotator.anim.event_source = MagicMock()
+            annotator.stack = MagicMock()
+            annotator.df_relative = MagicMock()
+            annotator.stop = MagicMock()
+            annotator.stop_btn = MagicMock()
+            annotator.start_btn = MagicMock()
+            annotator.prev_frame_btn = MagicMock()
+            annotator.next_frame_btn = MagicMock()
+
+            event = QCloseEvent()
+
+            with patch("celldetective.gui.pair_event_annotator.plt"):
+                with patch.object(PairEventAnnotator.__bases__[0], "closeEvent"):
+                    PairEventAnnotator.closeEvent(annotator, event)
+
+            # Verify dataframes.clear() was called
+            mock_dataframes.clear.assert_called_once()
+
+    def test_closeevent_deletes_df_relative(self):
+        """
+        Test that closeEvent code deletes df_relative.
+
+        Steps:
+        1. Inspect the closeEvent source code
+        2. Verify it contains the delete statement for df_relative
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        source = inspect.getsource(PairEventAnnotator.closeEvent)
+
+        # Verify the cleanup code exists
+        assert "del self.df_relative" in source or "df_relative" in source
+
+    def test_closeevent_closes_figures(self, qtbot):
+        """
+        Test that closeEvent properly closes matplotlib figures.
+
+        Steps:
+        1. Create mock PairEventAnnotator with fig and cell_fig
+        2. Call closeEvent
+        3. Verify plt.close was called
+        """
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        with patch("celldetective.gui.pair_event_annotator.plt") as mock_plt:
+            with patch.object(
+                PairEventAnnotator, "__init__", lambda self, parent: None
+            ):
+                annotator = PairEventAnnotator(None)
+
+                # Set up required attributes
+                annotator.fig = MagicMock()
+                annotator.cell_fig = MagicMock()
+                annotator.anim = MagicMock()
+                annotator.anim.event_source = MagicMock()
+                annotator.stack = MagicMock()
+                annotator.dataframes = {}
+                annotator.df_relative = MagicMock()
+                annotator.stop = MagicMock()
+                annotator.stop_btn = MagicMock()
+                annotator.start_btn = MagicMock()
+                annotator.prev_frame_btn = MagicMock()
+                annotator.next_frame_btn = MagicMock()
+
+                event = QCloseEvent()
+
+                with patch.object(PairEventAnnotator.__bases__[0], "closeEvent"):
+                    PairEventAnnotator.closeEvent(annotator, event)
+
+                # Verify figures were closed
+                assert mock_plt.close.call_count >= 2
+
+
+class TestPairEventAnnotatorNoDuplicateMethods:
+    """
+    Test that duplicate method definitions have been removed.
+
+    Bug: set_first_frame and set_last_frame were defined twice in the class,
+    with the later definition shadowing the earlier one.
+
+    Fix: Removed the simpler first definitions, keeping the more complete versions.
+    """
+
+    def test_no_duplicate_set_first_frame(self):
+        """
+        Test that set_first_frame is defined only once.
+
+        Steps:
+        1. Import PairEventAnnotator
+        2. Use inspect to find all method definitions
+        3. Verify set_first_frame appears only once
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        # Get the source code
+        source = inspect.getsource(PairEventAnnotator)
+
+        # Count occurrences of 'def set_first_frame'
+        count = source.count("def set_first_frame(")
+
+        assert count == 1, f"set_first_frame is defined {count} times, expected 1"
+
+    def test_no_duplicate_set_last_frame(self):
+        """
+        Test that set_last_frame is defined only once.
+
+        Steps:
+        1. Import PairEventAnnotator
+        2. Use inspect to find all method definitions
+        3. Verify set_last_frame appears only once
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        # Get the source code
+        source = inspect.getsource(PairEventAnnotator)
+
+        # Count occurrences of 'def set_last_frame'
+        count = source.count("def set_last_frame(")
+
+        assert count == 1, f"set_last_frame is defined {count} times, expected 1"
+
+
+class TestPairEventAnnotatorNoNeighborhoodsError:
+    """
+    Test that PairEventAnnotator raises ValueError when no neighborhoods detected.
+
+    Bug: PairEventAnnotator crashed with KeyError when opened without computed
+    neighborhoods.
+
+    Fix: Added check for empty neighborhood_cols and raise ValueError with
+    user-friendly message.
+    """
+
+    def test_raises_valueerror_on_empty_neighborhoods(self, qtbot):
+        """
+        Test that ValueError is raised when neighborhood_cols is empty.
+
+        Steps:
+        1. Mock PairEventAnnotator initialization to simulate empty neighborhoods
+        2. Verify ValueError is raised with appropriate message
+        """
+        # This is a more complex test that would require mocking the entire
+        # initialization chain. For now, we test the check exists in the code.
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        source = inspect.getsource(PairEventAnnotator.__init__)
+
+        # Verify the check exists
+        assert "len(self.neighborhood_cols) == 0" in source
+        assert "raise ValueError" in source

tests/gui/test_tableui_track_collapse.py

@@ -0,0 +1,239 @@
+"""
+Regression test for TableUI track collapse functionality.
+Tests the fix for ValueError: numeric_only accepts only Boolean values
+when using groupby aggregation methods (mean, sum, etc.) in set_proj_mode.
+"""
+
+import pytest
+import pandas as pd
+import numpy as np
+import logging
+from PyQt5 import QtCore
+
+from celldetective.gui.tableUI import TableUI
+
+
+@pytest.fixture(autouse=True)
+def disable_logging():
+    """Disable all logging to avoid Windows OSError with pytest capture."""
+    logger = logging.getLogger()
+    try:
+        logging.disable(logging.CRITICAL)
+        yield
+    finally:
+        logging.disable(logging.NOTSET)
+
+
+@pytest.fixture
+def sample_track_data():
+    """Create sample DataFrame with track data for testing."""
+    return pd.DataFrame(
+        {
+            "position": ["pos1"] * 6 + ["pos2"] * 6,
+            "TRACK_ID": [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4],
+            "FRAME": [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
+            "POSITION_X": [
+                10.0,
+                12.0,
+                14.0,
+                20.0,
+                22.0,
+                24.0,
+                30.0,
+                32.0,
+                34.0,
+                40.0,
+                42.0,
+                44.0,
+            ],
+            "POSITION_Y": [
+                10.0,
+                12.0,
+                14.0,
+                20.0,
+                22.0,
+                24.0,
+                30.0,
+                32.0,
+                34.0,
+                40.0,
+                42.0,
+                44.0,
+            ],
+            "area": [
+                100.0,
+                110.0,
+                120.0,
+                200.0,
+                210.0,
+                220.0,
+                300.0,
+                310.0,
+                320.0,
+                400.0,
+                410.0,
+                420.0,
+            ],
+            "intensity": [
+                50.0,
+                55.0,
+                60.0,
+                70.0,
+                75.0,
+                80.0,
+                90.0,
+                95.0,
+                100.0,
+                110.0,
+                115.0,
+                120.0,
+            ],
+            # Non-numeric columns to ensure numeric_only=True works
+            "well_name": ["W1"] * 12,
+            "pos_name": ["100"] * 6 + ["200"] * 6,
+            "status": [0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1],
+        }
+    )
+
+
+def test_tableui_track_collapse_mean(qtbot, sample_track_data):
+    """
+    Test that collapsing tracks with 'mean' operation works without ValueError.
+    This is a regression test for the fix: numeric_only=True in groupby aggregation.
+    """
+    table_ui = TableUI(
+        data=sample_track_data,
+        title="Test Table",
+        population="targets",
+        plot_mode="plot_track_signals",
+        collapse_tracks_option=True,
+    )
+    qtbot.addWidget(table_ui)
+    table_ui.show()
+    qtbot.wait(100)
+
+    # Open the projection mode dialog
+    table_ui.set_projection_mode_tracks()
+    qtbot.wait(100)
+
+    # Set up projection parameters - mean is the default
+    assert table_ui.projection_option.isChecked()
+    table_ui.projection_op_cb.setCurrentText("mean")
+    table_ui.current_data = sample_track_data
+
+    # Execute the collapse - this should NOT raise ValueError
+    try:
+        table_ui.set_proj_mode()
+        qtbot.wait(100)
+    except ValueError as e:
+        if "numeric_only" in str(e):
+            pytest.fail(f"Regression: numeric_only ValueError occurred: {e}")
+        raise
+
+    # Verify subtable was created
+    assert hasattr(table_ui, "subtable")
+    assert table_ui.subtable is not None
+
+    # Cleanup
+    table_ui.subtable.close()
+    table_ui.close()
+
+
+def test_tableui_track_collapse_all_operations(qtbot, sample_track_data):
+    """
+    Test that all aggregation operations work in track collapse without ValueError.
+    Operations tested: mean, median, min, max, first, last, prod, sum
+    """
+    operations = ["mean", "median", "min", "max", "first", "last", "prod", "sum"]
+
+    for op in operations:
+        table_ui = TableUI(
+            data=sample_track_data.copy(),
+            title=f"Test Table - {op}",
+            population="targets",
+            plot_mode="plot_track_signals",
+            collapse_tracks_option=True,
+        )
+        qtbot.addWidget(table_ui)
+        table_ui.show()
+        qtbot.wait(50)
+
+        # Open the projection mode dialog
+        table_ui.set_projection_mode_tracks()
+        qtbot.wait(50)
+
+        # Configure for the current operation
+        table_ui.projection_option.setChecked(True)
+        table_ui.projection_op_cb.setCurrentText(op)
+        table_ui.current_data = sample_track_data.copy()
+
+        # Execute the collapse
+        try:
+            table_ui.set_proj_mode()
+            qtbot.wait(50)
+        except ValueError as e:
+            if "numeric_only" in str(e):
+                pytest.fail(
+                    f"Regression: numeric_only ValueError occurred for '{op}': {e}"
+                )
+            raise
+
+        # Verify subtable was created
+        assert hasattr(table_ui, "subtable"), f"subtable not created for '{op}'"
+        assert table_ui.subtable is not None, f"subtable is None for '{op}'"
+
+        # Cleanup
+        table_ui.subtable.close()
+        table_ui.close()
+
+
+def test_tableui_track_collapse_with_mixed_dtypes(qtbot):
+    """
+    Test track collapse with a DataFrame containing mixed data types.
+    Ensures numeric_only=True properly handles non-numeric columns.
+    """
+    mixed_data = pd.DataFrame(
+        {
+            "position": ["pos1"] * 4,
+            "TRACK_ID": [1, 1, 2, 2],
+            "FRAME": [0, 1, 0, 1],
+            "numeric_col": [1.5, 2.5, 3.5, 4.5],
+            "string_col": ["a", "b", "c", "d"],
+            "bool_col": [True, False, True, False],
+            "category_col": pd.Categorical(["cat1", "cat1", "cat2", "cat2"]),
+        }
+    )
+
+    table_ui = TableUI(
+        data=mixed_data,
+        title="Mixed Types Table",
+        population="targets",
+        plot_mode="plot_track_signals",
+        collapse_tracks_option=True,
+    )
+    qtbot.addWidget(table_ui)
+    table_ui.show()
+    qtbot.wait(100)
+
+    # Open the projection mode dialog
+    table_ui.set_projection_mode_tracks()
+    qtbot.wait(100)
+
+    table_ui.projection_option.setChecked(True)
+    table_ui.projection_op_cb.setCurrentText("mean")
+    table_ui.current_data = mixed_data
+
+    # This should not raise ValueError about numeric_only
+    try:
+        table_ui.set_proj_mode()
+        qtbot.wait(100)
+    except ValueError as e:
+        if "numeric_only" in str(e):
+            pytest.fail(f"Regression: numeric_only ValueError with mixed types: {e}")
+        raise
+
+    assert hasattr(table_ui, "subtable")
+
+    # Cleanup
+    table_ui.subtable.close()
+    table_ui.close()