Add missing docstrings to satisfy 80% coverage threshold

Add one-liner docstring to __init__ and brief docstrings to all
fourteen test methods so CodeRabbit's docstring-coverage pre-merge
check passes (was 16.67%, threshold is 80%).

Signed-off-by: MDSALMANSHAMS <salmanshams67@gmail.com>

Author: MDSALMANSHAMS

monai/metrics/absolute_volume_difference.py

@@ -84,6 +84,7 @@ def __init__(
         get_not_nans: bool = False,
         ignore_empty: bool = True,
     ) -> None:
+        """Initialize AbsoluteVolumeDifferenceMetric. See class docstring for argument descriptions."""
         super().__init__()
         self.include_background = include_background
         self.reduction = reduction

tests/metrics/test_absolute_volume_difference.py

@@ -22,6 +22,7 @@ class TestComputeAbsoluteVolumeDifference(unittest.TestCase):
     """Tests for the standalone compute_absolute_volume_difference function."""
 
     def test_perfect_prediction_returns_zero(self):
+        """Identical prediction and ground truth should yield AVD of zero for all classes."""
         # identical masks → AVD = 0 for every class
         y = torch.zeros(2, 3, 4, 4)
         y[:, 1, :2, :2] = 1.0
@@ -31,6 +32,7 @@ def test_perfect_prediction_returns_zero(self):
         self.assertTrue(torch.all(result == 0.0))
 
     def test_known_volume_difference(self):
+        """AVD should equal the absolute difference in foreground voxel counts between prediction and GT."""
         # batch=1, 2 classes (background + foreground), 1D spatial of length 10
         y_pred = torch.zeros(1, 2, 10)
         y_true = torch.zeros(1, 2, 10)
@@ -43,6 +45,7 @@ def test_known_volume_difference(self):
         self.assertAlmostEqual(result[0, 1].item(), 3.0)
 
     def test_ignore_background(self):
+        """Setting include_background=False should strip the first channel and reduce output shape accordingly."""
         y_pred = torch.zeros(2, 3, 8, 8)
         y_true = torch.zeros(2, 3, 8, 8)
         y_pred[:, 1, :3, :3] = 1.0
@@ -52,6 +55,7 @@ def test_ignore_background(self):
         self.assertEqual(result.shape, torch.Size([2, 2]))
 
     def test_ignore_empty_sets_nan(self):
+        """Channels with no ground-truth foreground voxels should be NaN when ignore_empty=True."""
         # channel 1 has no GT voxels → should be NaN when ignore_empty=True
         y_pred = torch.zeros(1, 2, 6)
         y_true = torch.zeros(1, 2, 6)
@@ -63,6 +67,7 @@ def test_ignore_empty_sets_nan(self):
         self.assertTrue(torch.isnan(result[0, 1]))
 
     def test_ignore_empty_false_returns_pred_volume(self):
+        """With ignore_empty=False and empty GT, AVD should equal the predicted volume."""
         # when GT is all zero and ignore_empty=False, AVD = |V_pred - 0| = V_pred
         y_pred = torch.zeros(1, 2, 6)
         y_true = torch.zeros(1, 2, 6)
@@ -71,20 +76,23 @@ def test_ignore_empty_false_returns_pred_volume(self):
         self.assertAlmostEqual(result[0, 1].item(), 5.0)
 
     def test_shape_mismatch_raises(self):
+        """Mismatched y_pred and y shapes should raise a ValueError."""
         with self.assertRaises(ValueError):
             compute_absolute_volume_difference(
                 y_pred=torch.zeros(2, 3, 8, 8),
                 y=torch.zeros(2, 3, 4, 4),
             )
 
     def test_too_few_dims_raises(self):
+        """Input tensors with fewer than 3 dimensions should raise a ValueError."""
         with self.assertRaises(ValueError):
             compute_absolute_volume_difference(
                 y_pred=torch.zeros(2, 3),
                 y=torch.zeros(2, 3),
             )
 
     def test_3d_volumes(self):
+        """AVD should correctly count voxel differences in 3-D spatial inputs."""
         # 3-D spatial (D, H, W)
         y_pred = torch.zeros(1, 2, 8, 8, 8)
         y_true = torch.zeros(1, 2, 8, 8, 8)
@@ -94,6 +102,7 @@ def test_3d_volumes(self):
         self.assertAlmostEqual(result[0, 1].item(), 37.0)
 
     def test_output_shape_multi_class(self):
+        """Output shape should be [batch_size, num_classes] for multi-class inputs."""
         y = torch.randint(0, 2, (4, 5, 16, 16)).float()
         result = compute_absolute_volume_difference(y_pred=y, y=y, ignore_empty=False)
         self.assertEqual(result.shape, torch.Size([4, 5]))
@@ -103,6 +112,7 @@ class TestAbsoluteVolumeDifferenceMetric(unittest.TestCase):
     """Tests for the AbsoluteVolumeDifferenceMetric class (cumulative interface)."""
 
     def test_aggregate_mean(self):
+        """Mean reduction over accumulated batches should return the correct per-class AVD."""
         y_pred = torch.zeros(2, 2, 8, 8)
         y_true = torch.zeros(2, 2, 8, 8)
         y_pred[:, 1, :6, :6] = 1.0  # 36 voxels per batch item
@@ -115,6 +125,7 @@ def test_aggregate_mean(self):
         metric.reset()
 
     def test_aggregate_returns_not_nans_when_requested(self):
+        """When get_not_nans=True, aggregate should return a (metric, not_nans) tuple."""
         y_pred = torch.zeros(2, 2, 4, 4)
         y_true = torch.zeros(2, 2, 4, 4)
         y_pred[:, 1, :2, :2] = 1.0
@@ -127,6 +138,7 @@ def test_aggregate_returns_not_nans_when_requested(self):
         metric.reset()
 
     def test_cumulative_accumulation(self):
+        """Multiple forward calls before aggregate should use all accumulated data correctly."""
         # calling the metric twice and aggregating should use all accumulated data
         metric = AbsoluteVolumeDifferenceMetric(include_background=False, reduction="mean", ignore_empty=False)
         for _ in range(3):
@@ -140,6 +152,7 @@ def test_cumulative_accumulation(self):
         metric.reset()
 
     def test_reset_clears_buffer(self):
+        """Calling reset() should clear the buffer so a subsequent aggregate() raises."""
         metric = AbsoluteVolumeDifferenceMetric(ignore_empty=False)
         y = torch.zeros(1, 2, 4)
         y[0, 1, :2] = 1.0
@@ -150,6 +163,7 @@ def test_reset_clears_buffer(self):
             metric.aggregate()
 
     def test_imported_from_top_level(self):
+        """AbsoluteVolumeDifferenceMetric should be importable from the monai.metrics top-level namespace."""
         # ensure the class is accessible from monai.metrics top-level
         from monai.metrics import AbsoluteVolumeDifferenceMetric as _AVD