updating requested fixes

Author: cgmaiorano

src/graphomotor/core/models.py

@@ -296,7 +296,6 @@ def calculate_velocity_metrics(self) -> None:
 
         Args:
             self: LineSegment object to calculate velocities for.
-            ink_points: DataFrame containing the ink points for the line segment.
         """
         dx = np.diff(self.ink_points["x"].values)
         dy = np.diff(self.ink_points["y"].values)
@@ -326,8 +325,11 @@ def detect_hesitations(self, threshold_percentile: int = 20) -> None:
         duration of hesitations based on the number of points that fall below the
         threshold and the time interval between points.
 
+        hesitation_count defaults to 0 and hesitation_duration defaults to 0.0 in the
+        LineSegment object if there are less than 3 velocity points. This function also
+        assumes uniform sampling.
+
         Args:
-            ink_points: DataFrame containing the ink points for the line segment.
             threshold_percentile: Percentile to determine the velocity threshold for
                 hesitations (default is 20, meaning the bottom 20% of velocities are
                 considered hesitations).
@@ -337,8 +339,8 @@ def detect_hesitations(self, threshold_percentile: int = 20) -> None:
 
         dt = np.diff(self.ink_points["seconds"].values)
 
-        threshold = np.percentile(self.velocities, threshold_percentile)
-        hesitations = self.velocities < threshold
+        threshold_velocity = np.percentile(self.velocities, threshold_percentile)
+        hesitations = self.velocities < threshold_velocity
 
         hesitation_changes = np.diff(hesitations.astype(int))
         hesitation_starts = np.where(hesitation_changes == 1)[0] + 1
@@ -347,9 +349,7 @@ def detect_hesitations(self, threshold_percentile: int = 20) -> None:
         if hesitations[0]:
             hesitation_count += 1
 
-        hesitation_duration = np.sum(hesitations) * dt[0]
-
         self.hesitation_count = hesitation_count
-        self.hesitation_duration = hesitation_duration
+        self.hesitation_duration = np.sum(hesitations) * dt[0]
 
         return

tests/unit/test_models.py

@@ -242,13 +242,11 @@ def test_valid_ink_trajectory(
 
 def test_uniform_motion() -> None:
     """Test with points moving at constant velocity."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 1, 2, 3],
-            "y": [0, 0, 0, 0],
-            "seconds": [0, 1, 2, 3],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 1, 2, 3],
+        "y": [0, 0, 0, 0],
+        "seconds": [0, 1, 2, 3],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -260,24 +258,20 @@ def test_uniform_motion() -> None:
 
     segment.calculate_velocity_metrics()
 
-    assert segment.distance == pytest.approx(3.0)
-    assert segment.mean_speed == pytest.approx(1.0)
-    assert segment.speed_variance == pytest.approx(0.0)
-    assert len(segment.velocities) == 3
-    assert all(v == pytest.approx(1.0) for v in segment.velocities)
-    assert len(segment.accelerations) == 2
-    assert all(a == pytest.approx(0.0) for a in segment.accelerations)
+    assert segment.distance == 3.0
+    assert segment.mean_speed == 1.0
+    assert segment.speed_variance == 0.0
+    assert segment.velocities == [1.0, 1.0, 1.0]
+    assert segment.accelerations == [0.0, 0.0]
 
 
 def test_accelerating_motion() -> None:
     """Test with motion accelerating over time."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 1, 4, 9],
-            "y": [0, 0, 0, 0],
-            "seconds": [0, 1, 2, 3],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 1, 4, 9],
+        "y": [0, 0, 0, 0],
+        "seconds": [0, 1, 2, 3],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -303,13 +297,11 @@ def test_accelerating_motion() -> None:
 
 def test_velocity_two_points_only() -> None:
     """Test velocity calculation with only two points."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 3],
-            "y": [0, 4],
-            "seconds": [0, 2],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 3],
+        "y": [0, 4],
+        "seconds": [0, 2],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -331,13 +323,11 @@ def test_velocity_two_points_only() -> None:
 
 def test_decelerating_motion() -> None:
     """Test with decelerating motion (negative acceleration)."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 4, 7, 9],
-            "y": [0, 0, 0, 0],
-            "seconds": [0, 1, 2, 3],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 4, 7, 9],
+        "y": [0, 0, 0, 0],
+        "seconds": [0, 1, 2, 3],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -363,13 +353,11 @@ def test_decelerating_motion() -> None:
 
 def test_stationary_motion() -> None:
     """Test with no movement (all points the same)."""
-    points = pd.DataFrame(
-        {
-            "x": [1, 1, 1],
-            "y": [1, 1, 1],
-            "seconds": [0, 1, 2],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [1, 1, 1],
+        "y": [1, 1, 1],
+        "seconds": [0, 1, 2],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -392,13 +380,11 @@ def test_stationary_motion() -> None:
 
 def test_no_hesitations_uniform_motion() -> None:
     """Test with uniform motion where all velocities are equal."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 1, 2, 3],
-            "y": [0, 0, 0, 0],
-            "seconds": [0, 1, 2, 3],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 1, 2, 3],
+        "y": [0, 0, 0, 0],
+        "seconds": [0, 1, 2, 3],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -417,13 +403,11 @@ def test_no_hesitations_uniform_motion() -> None:
 
 def test_hesitation_at_start() -> None:
     """Test when the line starts with a hesitation."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 0.1, 1, 2],
-            "y": [0, 0.1, 0, 0],
-            "seconds": [0, 1, 2, 3],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 0.1, 1, 2],
+        "y": [0, 0.1, 0, 0],
+        "seconds": [0, 1, 2, 3],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -442,13 +426,11 @@ def test_hesitation_at_start() -> None:
 
 def test_multiple_hesitations() -> None:
     """Test when there are multiple hesitation periods."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 100, 100.1, 200, 200.1, 300, 400, 500, 600],
-            "y": [0, 0, 0, 0, 0, 0, 0, 0, 0],
-            "seconds": [0, 1, 2, 3, 4, 5, 6, 7, 8],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 100, 100.1, 200, 200.1, 300, 400, 500, 600],
+        "y": [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        "seconds": [0, 1, 2, 3, 4, 5, 6, 7, 8],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",
@@ -467,13 +449,11 @@ def test_multiple_hesitations() -> None:
 
 def test_less_than_three_velocities() -> None:
     """Test early return when velocities length is less than 3."""
-    points = pd.DataFrame(
-        {
-            "x": [0, 1],
-            "y": [0, 0],
-            "seconds": [0, 1],
-        }
-    )
+    points = pd.DataFrame({
+        "x": [0, 1],
+        "y": [0, 0],
+        "seconds": [0, 1],
+    })
     segment = models.LineSegment(
         start_label="1",
         end_label="2",