DM-42324: Fix min/max rows logic for Deduplication.

python/lsst/daf/relation/_operations/_deduplication.py

@@ -53,7 +53,13 @@ def __str__(self) -> str:
 
     def applied_min_rows(self, target: Relation) -> int:
         # Docstring inherited.
-        return 1
+        return 1 if target.min_rows >= 1 else 0
+
+    def applied_max_rows(self, target: Relation) -> int | None:
+        # Docstring inherited.
+        if not target.columns:
+            return 1 if target.max_rows is None or target.max_rows >= 1 else 0
+        return target.max_rows
 
     def commute(self, current: UnaryOperationRelation) -> UnaryCommutator:
         # Docstring inherited.

python/lsst/daf/relation/_relation.py

@@ -665,15 +665,13 @@ class BaseRelation:
     """
 
     def __init_subclass__(cls) -> None:
-        assert (
-            cls.__name__
-            in {
-                "LeafRelation",
-                "UnaryOperationRelation",
-                "BinaryOperationRelation",
-                "MarkerRelation",
-            }
-            or cls.__base__.__name__ != "Relation"
+        assert cls.__name__ in {
+            "LeafRelation",
+            "UnaryOperationRelation",
+            "BinaryOperationRelation",
+            "MarkerRelation",
+        } or (
+            cls.__base__ is not None and cls.__base__.__name__ != "Relation"
         ), "Relation inheritance is closed to predefined types in daf_relation and MarkerRelation subclasses."
 
     @property

python/lsst/daf/relation/iteration/_engine.py

@@ -284,8 +284,7 @@ def convert_column_expression(
                 function = self.get_function(name)
                 if function is not None:
                     arg_callables = [self.convert_column_expression(arg) for arg in args]
-                    # MyPy doesn't see 'function' as not-None for some reason.
-                    return lambda row: function(*[c(row) for c in arg_callables])  # type: ignore
+                    return lambda row: function(*[c(row) for c in arg_callables])
                 first, *rest = (self.convert_column_expression(arg) for arg in args)
                 return lambda row: getattr(first(row), name)(*[r(row) for r in rest])
         raise AssertionError("matches should be exhaustive and all branches should return")
@@ -336,9 +335,7 @@ def convert_predicate(self, predicate: Predicate) -> Callable[[Mapping[ColumnTag
                 function = self.get_function(name)
                 if function is not None:
                     arg_callables = [self.convert_column_expression(arg) for arg in args]
-                    # MyPy doesn't see 'function' as not-None in the capture
-                    # for some reason.
-                    return lambda row: function(*[c(row) for c in arg_callables])  # type: ignore
+                    return lambda row: function(*[c(row) for c in arg_callables])
                 first, *rest = (self.convert_column_expression(arg) for arg in args)
                 return lambda row: getattr(first(row), name)(*[r(row) for r in rest])
             case LogicalAnd(operands=operands):

tests/test_deduplication.py

@@ -63,6 +63,16 @@ def test_attributes(self) -> None:
         self.assertFalse(operation.is_order_dependent)
         self.assertFalse(operation.is_count_dependent)
 
+    def test_min_max_rows(self) -> None:
+        """Test min and max rows for edge-case deduplications."""
+        self.assertEqual(self.leaf.with_only_columns(set()).without_duplicates().min_rows, 1)
+        self.assertEqual(self.leaf.with_only_columns(set()).without_duplicates().max_rows, 1)
+        leaf0 = self.engine.make_leaf({self.a}, payload=iteration.RowSequence([]), name="leaf")
+        self.assertEqual(leaf0.without_duplicates().min_rows, 0)
+        self.assertEqual(leaf0.without_duplicates().max_rows, 0)
+        self.assertEqual(leaf0.with_only_columns([]).without_duplicates().min_rows, 0)
+        self.assertEqual(leaf0.with_only_columns([]).without_duplicates().max_rows, 0)
+
     def test_backtracking_apply(self) -> None:
         """Test apply logic that involves reordering operations in the existing
         tree to perform the new operation in a preferred engine.