feat: add depth range constraint to query filters (#112)

* Initial plan

* Add depth range filter to query constraints

- Add DepthRangeConstraintResult class to handle min/max depth constraints
- Add DepthRangeFilter with custom dialog for depth range input
- Add "Depth range" filter to default filters list
- Support querying depths between two values, >= min, or <= max
- Add unit tests for depth constraints

Co-authored-by: kevinsbarnard <[email protected]>

* Add additional unit tests for DepthRangeConstraintResult

Co-authored-by: kevinsbarnard <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: kevinsbarnard <[email protected]>

Author: Copilot

src/vars_gridview/ui/QueryDialog.py

@@ -6,6 +6,7 @@
     QAbstractItemView,
     QDialog,
     QDialogButtonBox,
+    QDoubleSpinBox,
     QHBoxLayout,
     QInputDialog,
     QLineEdit,
@@ -19,6 +20,7 @@
     QSpinBox,
     QFormLayout,
     QCompleter,
+    QCheckBox,
 )
 from PyQt6.QtGui import QDragEnterEvent, QDropEvent
 
@@ -228,6 +230,46 @@ def __str__(self) -> str:
         )
 
 
+class DepthRangeConstraintResult(BaseResult):
+    """
+    A constraint result that creates min/max constraints for depth range.
+    """
+
+    def __init__(self, min_depth: Optional[float], max_depth: Optional[float]):
+        self.min_depth = min_depth
+        self.max_depth = max_depth
+
+    @property
+    def constraints(self) -> Iterable[QueryConstraint]:
+        if self.min_depth is not None and self.max_depth is not None:
+            # Both min and max specified - use minmax for between constraint
+            yield QueryConstraint(
+                column="depth_meters",
+                minmax=[self.min_depth, self.max_depth],
+            )
+        elif self.min_depth is not None:
+            # Only min specified - depth >= min
+            yield QueryConstraint(
+                column="depth_meters",
+                min=self.min_depth,
+            )
+        elif self.max_depth is not None:
+            # Only max specified - depth <= max
+            yield QueryConstraint(
+                column="depth_meters",
+                max=self.max_depth,
+            )
+
+    def __str__(self) -> str:
+        if self.min_depth is not None and self.max_depth is not None:
+            return f"Depth: {self.min_depth}m - {self.max_depth}m"
+        elif self.min_depth is not None:
+            return f"Depth: >= {self.min_depth}m"
+        elif self.max_depth is not None:
+            return f"Depth: <= {self.max_depth}m"
+        return "Depth: (no constraint)"
+
+
 # FILTER IMPLEMENTATIONS
 
 
@@ -355,6 +397,87 @@ def __call__(self) -> Optional[VerifierConstraintResult]:
         return VerifierConstraintResult(result.value) if result else None
 
 
+class DepthRangeFilter(BaseFilter):
+    """
+    A filter that allows the user to specify a depth range constraint.
+    """
+
+    def __call__(self) -> Optional[DepthRangeConstraintResult]:
+        # Create a custom dialog for depth range input
+        dialog = QDialog(self.parent)
+        dialog.setWindowTitle("Depth Range")
+        layout = QFormLayout(dialog)
+
+        # Min depth input
+        min_depth_checkbox = QCheckBox("Set minimum depth")
+        min_depth_spinbox = QDoubleSpinBox()
+        min_depth_spinbox.setRange(0, 10000)
+        min_depth_spinbox.setValue(0)
+        min_depth_spinbox.setSuffix(" m")
+        min_depth_spinbox.setDecimals(2)
+        min_depth_spinbox.setEnabled(False)
+
+        # Max depth input
+        max_depth_checkbox = QCheckBox("Set maximum depth")
+        max_depth_spinbox = QDoubleSpinBox()
+        max_depth_spinbox.setRange(0, 10000)
+        max_depth_spinbox.setValue(1000)
+        max_depth_spinbox.setSuffix(" m")
+        max_depth_spinbox.setDecimals(2)
+        max_depth_spinbox.setEnabled(False)
+
+        # Connect checkboxes to enable/disable spinboxes
+        min_depth_checkbox.toggled.connect(min_depth_spinbox.setEnabled)
+        max_depth_checkbox.toggled.connect(max_depth_spinbox.setEnabled)
+
+        # Add widgets to layout
+        layout.addRow(min_depth_checkbox, min_depth_spinbox)
+        layout.addRow(max_depth_checkbox, max_depth_spinbox)
+
+        # Dialog buttons
+        button_box = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        button_box.accepted.connect(dialog.accept)
+        button_box.rejected.connect(dialog.reject)
+        layout.addWidget(button_box)
+
+        # Show dialog and get result
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            min_depth = (
+                min_depth_spinbox.value() if min_depth_checkbox.isChecked() else None
+            )
+            max_depth = (
+                max_depth_spinbox.value() if max_depth_checkbox.isChecked() else None
+            )
+
+            # Validate that at least one constraint is set
+            if min_depth is None and max_depth is None:
+                QMessageBox.warning(
+                    self.parent,
+                    "No Constraint",
+                    "Please set at least one depth constraint (minimum or maximum).",
+                )
+                return None
+
+            # Validate that min <= max if both are set
+            if (
+                min_depth is not None
+                and max_depth is not None
+                and min_depth > max_depth
+            ):
+                QMessageBox.warning(
+                    self.parent,
+                    "Invalid Range",
+                    "Minimum depth cannot be greater than maximum depth.",
+                )
+                return None
+
+            return DepthRangeConstraintResult(min_depth, max_depth)
+
+        return None
+
+
 # HELPER DIALOG CLASSES
 
 
@@ -753,6 +876,7 @@ def _create_default_filters(self) -> List[BaseFilter]:
             ),
             SimpleTextFilter(self, "Activity", "activity"),
             SimpleTextFilter(self, "Observation group", "observation_group"),
+            DepthRangeFilter(self, "Depth range"),
             GeneratorFilter(self, "Generator", "generator", prompt="Generator"),
             VerifierFilter(self, "Verifier", "verifier", prompt="Verifier"),
             FunctionalFilter(self, "Verified", lambda: VerifiedConstraintResult()),

tests/test_depth_range_result.py

@@ -0,0 +1,74 @@
+import unittest
+from vars_gridview.ui.QueryDialog import DepthRangeConstraintResult
+
+
+class TestDepthRangeConstraintResult(unittest.TestCase):
+    """Test the DepthRangeConstraintResult class."""
+
+    def test_both_min_and_max(self):
+        """Test depth range with both min and max values."""
+        result = DepthRangeConstraintResult(100.0, 2500.0)
+        
+        # Check string representation
+        self.assertEqual(str(result), "Depth: 100.0m - 2500.0m")
+        
+        # Check constraints
+        constraints = list(result.constraints)
+        self.assertEqual(len(constraints), 1)
+        self.assertEqual(constraints[0].column, "depth_meters")
+        self.assertEqual(constraints[0].minmax, [100.0, 2500.0])
+
+    def test_min_only(self):
+        """Test depth range with only minimum value (>= 100m)."""
+        result = DepthRangeConstraintResult(100.0, None)
+        
+        # Check string representation
+        self.assertEqual(str(result), "Depth: >= 100.0m")
+        
+        # Check constraints
+        constraints = list(result.constraints)
+        self.assertEqual(len(constraints), 1)
+        self.assertEqual(constraints[0].column, "depth_meters")
+        self.assertEqual(constraints[0].min, 100.0)
+        self.assertIsNone(constraints[0].max)
+        self.assertIsNone(constraints[0].minmax)
+
+    def test_max_only(self):
+        """Test depth range with only maximum value (<= 2500m)."""
+        result = DepthRangeConstraintResult(None, 2500.0)
+        
+        # Check string representation
+        self.assertEqual(str(result), "Depth: <= 2500.0m")
+        
+        # Check constraints
+        constraints = list(result.constraints)
+        self.assertEqual(len(constraints), 1)
+        self.assertEqual(constraints[0].column, "depth_meters")
+        self.assertEqual(constraints[0].max, 2500.0)
+        self.assertIsNone(constraints[0].min)
+        self.assertIsNone(constraints[0].minmax)
+
+    def test_neither_min_nor_max(self):
+        """Test depth range with neither min nor max (edge case)."""
+        result = DepthRangeConstraintResult(None, None)
+        
+        # Check string representation
+        self.assertEqual(str(result), "Depth: (no constraint)")
+        
+        # Check that no constraints are yielded
+        constraints = list(result.constraints)
+        self.assertEqual(len(constraints), 0)
+
+    def test_example_shallow_water(self):
+        """Example: Query for shallow water observations (0-100m)."""
+        result = DepthRangeConstraintResult(0.0, 100.0)
+        self.assertEqual(str(result), "Depth: 0.0m - 100.0m")
+
+    def test_example_deep_water(self):
+        """Example: Query for deep water observations (>= 2500m)."""
+        result = DepthRangeConstraintResult(2500.0, None)
+        self.assertEqual(str(result), "Depth: >= 2500.0m")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_query_constraints.py

@@ -0,0 +1,55 @@
+import unittest
+from vars_gridview.lib.m3.query import QueryConstraint
+
+
+class TestDepthConstraints(unittest.TestCase):
+    """Test the depth range constraints functionality."""
+
+    def test_min_depth_constraint(self):
+        """Test that a minimum depth constraint is created correctly."""
+        constraint = QueryConstraint(column="depth_meters", min=100.0)
+        result_dict = constraint.to_dict()
+        
+        self.assertEqual(result_dict["column"], "depth_meters")
+        self.assertEqual(result_dict["min"], 100.0)
+        self.assertNotIn("max", result_dict)
+        self.assertNotIn("minmax", result_dict)
+
+    def test_max_depth_constraint(self):
+        """Test that a maximum depth constraint is created correctly."""
+        constraint = QueryConstraint(column="depth_meters", max=2500.0)
+        result_dict = constraint.to_dict()
+        
+        self.assertEqual(result_dict["column"], "depth_meters")
+        self.assertEqual(result_dict["max"], 2500.0)
+        self.assertNotIn("min", result_dict)
+        self.assertNotIn("minmax", result_dict)
+
+    def test_minmax_depth_constraint(self):
+        """Test that a depth range (minmax) constraint is created correctly."""
+        constraint = QueryConstraint(column="depth_meters", minmax=[100.0, 2500.0])
+        result_dict = constraint.to_dict()
+        
+        self.assertEqual(result_dict["column"], "depth_meters")
+        self.assertEqual(result_dict["minmax"], [100.0, 2500.0])
+        self.assertNotIn("min", result_dict)
+        self.assertNotIn("max", result_dict)
+
+    def test_constraint_to_dict_skip_null(self):
+        """Test that null values are excluded when skip_null=True."""
+        constraint = QueryConstraint(
+            column="depth_meters",
+            min=100.0,
+            max=None,
+            equals=None
+        )
+        result_dict = constraint.to_dict(skip_null=True)
+        
+        self.assertIn("column", result_dict)
+        self.assertIn("min", result_dict)
+        self.assertNotIn("max", result_dict)
+        self.assertNotIn("equals", result_dict)
+
+
+if __name__ == "__main__":
+    unittest.main()