cooptools 1.64__tar.gz → 1.66__tar.gz

{cooptools-1.64 → cooptools-1.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.64
+Version: 1.66
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.64 → cooptools-1.66}/cooptools/decor.py

@@ -2,7 +2,8 @@ import functools
 import time
 import logging
 import inspect
-from typing import Protocol, Dict
+import threading
+from typing import Protocol, Dict, Optional
 from typing_extensions import runtime_checkable
 
 @runtime_checkable
@@ -15,6 +16,22 @@ class TimeableProtocol(Protocol):
 
 TIMEABLE_LOOKUPATTR = "_timeable"
 
+# ---------------------------------------------------------------------------
+# Thread-local call stack — tracks the currently executing @timer chain so
+# each invocation knows its parent function.  Push before calling func, pop
+# after (even on exception) so the stack stays consistent.
+# ---------------------------------------------------------------------------
+
+_call_stack_local = threading.local()
+
+
+def get_call_stack() -> list:
+    """Return the current thread's timer call stack (mutable live reference)."""
+    if not hasattr(_call_stack_local, 'stack'):
+        _call_stack_local.stack = []
+    return _call_stack_local.stack
+
+
 def try_handler(logger: logging.Logger = None):
     def wrapper(func):
         @functools.wraps(func)
@@ -32,7 +49,8 @@ def try_handler(logger: logging.Logger = None):
     return wrapper
 
 
-def update_ttc_values(ttc: TimeableProtocol, func_name: str, run_time: float):
+def update_ttc_values(ttc: TimeableProtocol, func_name: str, run_time: float,
+                      parent: Optional[str] = None):
     #update counter
     ttc.ns.setdefault(func_name, 0)
     ttc.ns[func_name] += 1
@@ -55,6 +73,10 @@ def update_ttc_values(ttc: TimeableProtocol, func_name: str, run_time: float):
     my_avg = ttc.internally_tracked_times[func_name] / ttc.ns[func_name]
     ttc.avgs[func_name] = my_avg
 
+    # Record call-chain parent once (hierarchy is static; first writer wins).
+    if parent is not None and hasattr(ttc, 'parents'):
+        ttc.parents.setdefault(func_name, parent)
+
 
 def timer(logger: logging.Logger = None,
           log_level: int = logging.DEBUG,
@@ -68,11 +90,20 @@ def timer(logger: logging.Logger = None,
 
         @functools.wraps(func)
         def wrapper_timer(*args, **kwargs):
-            # capture time
+            # Push to call stack before executing so nested @timer calls see us
+            # as their parent.  Pop in finally so the stack stays consistent
+            # even if func raises.
+            _stack = get_call_stack()
+            _parent: Optional[str] = _stack[-1] if _stack else None
+            _stack.append(func.__name__)
+
             start_time = time.perf_counter()  # 1
-            value = func(*args, **kwargs)
-            end_time = time.perf_counter()  # 2
-            run_time = end_time - start_time  # 3
+            try:
+                value = func(*args, **kwargs)
+            finally:
+                end_time = time.perf_counter()  # 2
+                run_time = end_time - start_time  # 3
+                _stack.pop()
 
             ttc = None
 
@@ -96,7 +127,8 @@ def timer(logger: logging.Logger = None,
             if ttc is None:
                 return value
 
-            update_ttc_values(ttc, func_name=func.__name__, run_time=run_time)
+            update_ttc_values(ttc, func_name=func.__name__, run_time=run_time,
+                              parent=_parent)
             end_time2 = time.perf_counter()
             timer_runtime = end_time2 - end_time
             update_ttc_values(ttc, func_name=TIMEABLE_LOOKUPATTR, run_time=timer_runtime)

{cooptools-1.64 → cooptools-1.66}/cooptools/physics/kinematic_utils.py

@@ -182,8 +182,16 @@ def _tick_accel_from_profile(profile: Tuple[PhaseResult, ...], dt: float) -> flo
     many phases fit within dt so the tick's velocity change matches the true profile
     instead of overshooting by committing the whole tick to one extreme.
     """
+    if dt < 0:
+        raise ValueError(f"_tick_accel_from_profile: dt must be >= 0, got {dt}")
     if not profile:
         return 0.0
+    if dt == 0:
+        # No time elapses this tick (e.g. delta_time_ms=0 for a position-only /
+        # realign update) -- the time-weighted average has no window to average
+        # over, so fall back to the instantaneous decision: the first phase's
+        # acceleration, which is what the weighted average converges to as dt -> 0+.
+        return profile[0].accel
     remaining = dt
     weighted = 0.0
     for phase in profile:

{cooptools-1.64 → cooptools-1.66}/cooptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.64
+Version: 1.66
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.64 → cooptools-1.66}/setup.py

@@ -7,7 +7,7 @@ with open('requirements.txt') as f:
     requirements = f.read().splitlines()
 
 setuptools.setup(name='cooptools',
-      version='1.64',
+      version='1.66',
       description='Generic Tooling',
       url='https://github.com/tylertjburns/cooptools',
       author='tburns',

{cooptools-1.64 → cooptools-1.66}/tests/test_kinematic_utils.py

@@ -71,6 +71,18 @@ class Test_AxisArrivalAccel(unittest.TestCase):
         self.assertNotEqual(result, a)  # not the naive "just keep accelerating" answer
         self.assertLess(result, a)
 
+    def test__dt_zero__in_braking_regime__does_not_raise_and_returns_brake(self):
+        # regression: a position-only update (delta_time_ms=0, e.g. a waypoint
+        # realign) while already past the switching threshold used to fall through
+        # to single_axis_motion_profile + _tick_accel_from_profile(profile, dt=0),
+        # which raised ZeroDivisionError. d=10, v=20, a=5 is the same past-threshold
+        # state as test__well_past_stopping_distance__brakes above.
+        result = kin._axis_arrival_accel(d=10, v=20, a=5, dt=0)
+        self.assertEqual(result, -5.0)
+
+    def test__dt_zero__in_cheap_accelerate_regime__still_accelerates(self):
+        self.assertEqual(kin._axis_arrival_accel(d=1000, v=1, a=5, dt=0), 5.0)
+
 
 class Test_TickAccelFromProfile(unittest.TestCase):
     """Direct unit coverage for the tick-blending helper in isolation, using
@@ -100,6 +112,21 @@ class Test_TickAccelFromProfile(unittest.TestCase):
         result = kin._tick_accel_from_profile((p1,), dt=0.03)
         self.assertAlmostEqual(result, (-8.0 * 0.01) / 0.03, places=9)
 
+    def test__dt_zero__non_empty_profile__returns_first_phase_accel_without_dividing_by_zero(self):
+        # regression: dt=0 (e.g. a position-only / realign update with
+        # delta_time_ms=0) used to divide weighted-by-zero into a ZeroDivisionError.
+        p1 = kin.PhaseResult(length=0, time=0.01, label="brake", accel=-8.0)
+        p2 = kin.PhaseResult(length=0, time=5.0, label="accel", accel=3.0)
+        self.assertEqual(kin._tick_accel_from_profile((p1, p2), dt=0), -8.0)
+
+    def test__dt_zero__empty_profile__returns_zero(self):
+        self.assertEqual(kin._tick_accel_from_profile((), dt=0), 0.0)
+
+    def test__dt_negative__raises_value_error(self):
+        p1 = kin.PhaseResult(length=0, time=0.01, label="brake", accel=-8.0)
+        with self.assertRaises(ValueError):
+            kin._tick_accel_from_profile((p1,), dt=-0.01)
+
 
 class Test_ArrivalAcceleration(unittest.TestCase):
     """Direct unit coverage for the multi-axis wrapper around _axis_arrival_accel."""

{cooptools-1.64 → cooptools-1.66}/tests/test_waypointFollower.py

@@ -285,6 +285,24 @@ class Test_WaypointFollower_RealignToNextWaypoint(unittest.TestCase):
         self.assertEqual(follower.Position, (2.0, 100.0))
         self.assertEqual(follower.Velocity.CurrentVelocity_M_S, (1000.0, 0.0))
 
+    def test__update__delta_time_ms_zero__realign_to_next_waypoint__does_not_raise(self):
+        # regression: a position-only update (delta_time_ms=0, e.g. a caller placing
+        # a mover or re-issuing a route without advancing time) while braking toward
+        # a destination used to raise ZeroDivisionError from deep inside
+        # arrival_acceleration -> _axis_arrival_accel -> _tick_accel_from_profile,
+        # which divided a time-weighted acceleration by dt=0.
+        follower = _make_follower()
+        follower.add_waypoints([Waypoint(end_pos=(0, 100), is_destination=True)])
+        follower._goal_seeker.set_velocity((0, 60))  # fast enough to be past the
+                                                      # switching threshold this close
+
+        # act -- must not raise
+        reached = follower.update(delta_time_ms=0, realign_to_next_waypoint=True)
+
+        # assert -- no time elapsed, so nothing moved and nothing was reached
+        self.assertEqual(reached, [])
+        self.assertEqual(follower.Position, (0.0, 0.0))
+
 
 class Test_WaypointFollower_DistanceToNextDestination(unittest.TestCase):