timer + ETAEstimator: use perf_counter instead of monotonic

`unpythonic.misc.timer` and `unpythonic.timeutil.ETAEstimator`
both measured wall-clock time via `time.monotonic()`.  Both are
monotonic (guaranteed since Python 3.3), but `monotonic`'s
resolution is implementation-defined, and on Windows it is backed
by a ~16 ms tick counter.  `time.perf_counter()` is documented
as "the highest available resolution to measure a short
duration" and is also guaranteed monotonic.

The bug that forced the investigation was in `timer`: a PyPy-
JIT'd `for _ in range(int(1e6)): pass` block runs in microseconds,
which on Windows is **below** `monotonic`'s resolution, so
`timer().dt` registered as exactly `0.0`.  Three testsets in
unpythonic's own suite then failed on windows-latest × pypy-3.11
in the expanded CI matrix:

  - `test_misc::timer` — `test[tictoc.dt > 0]` held `0 > 0`, Fail.
  - `test_fploop::performance benchmark` — `fp2.dt / ip.dt` was
    ZeroDivisionError, Error.
  - `test_tco::performance benchmark` — same ZeroDivisionError.

All three cascaded from the one root cause; switching the clock
in `timer` makes all three go green without touching the tests
themselves.  Every other call site of `timer` in user code also
silently benefits.

`ETAEstimator` measures per-task timings on the order of seconds
to minutes, so `monotonic`'s resolution was not a correctness
problem at that scale.  Switched for consistency and for the
documentation claim that `perf_counter` is the right tool for
measuring wall-clock elapsed within a single process.  Both
classes only measure a dynamic extent in one process, so the
"comparable across processes" guarantee of `monotonic` that we
give up is not used anywhere.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Technologicat

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 **Fixed**:
 
+- `unpythonic.misc.timer` and `unpythonic.timeutil.ETAEstimator`: switched the underlying clock from `time.monotonic()` to `time.perf_counter()`. Both are monotonic (guaranteed since Python 3.3), but `perf_counter` is documented as *"a clock with the highest available resolution to measure a short duration"*, whereas `monotonic`'s resolution is implementation-defined. On Windows specifically, `time.monotonic()` is backed by a low-resolution (~16 ms) tick counter, so a `with timer() as t: ...` block that ran in microseconds — such as a PyPy-JIT'd `for _ in range(int(1e6)): pass` — recorded `t.dt` as **exactly 0.0**, silently producing wrong results and, in downstream code that divided by it, a `ZeroDivisionError`. On POSIX the two clocks are usually backed by the same high-resolution source, so this was a latent Windows-only bug. `ETAEstimator` is not affected as a correctness bug at its typical per-task scale (seconds to minutes), but was switched for consistency. We give up `monotonic`'s "comparable across processes" guarantee, which neither class needs — both measure a dynamic extent in wall-clock time within a single process.
 - `unpythonic.test.runner`: module discovery crashed on MS Windows with `re.error: bad escape (end of pattern) at position 0`. The runner used `re.sub(os.path.sep, ...)` to convert a relative path into a dotted module name, which worked by accident on POSIX (where `os.path.sep` is `/`, not a regex metacharacter), but on Windows `os.path.sep` is a lone backslash — an incomplete escape as a regex pattern. Fixed by using `str.replace` instead, which treats both arguments as literal strings. Affects any project that reuses `unpythonic.test.runner` for its own macro-enabled tests on Windows.
 
 

unpythonic/misc.py

@@ -15,7 +15,7 @@
 from itertools import count
 import inspect
 from queue import Empty
-from time import monotonic
+from time import perf_counter
 from types import FunctionType, LambdaType
 
 from .regutil import register_decorator
@@ -124,10 +124,19 @@ def __init__(self, p=False):
         """
         self.p = p
     def __enter__(self):
-        self.t0 = monotonic()
+        # `perf_counter`, not `monotonic`: the former is documented as "a
+        # clock with the highest available resolution to measure a short
+        # duration" and is backed by `QueryPerformanceCounter` (~100 ns) on
+        # Windows, whereas `monotonic` is backed there by the ~16 ms
+        # tick-counter and would record `dt = 0` for microsecond-scale
+        # blocks (e.g. a PyPy-JIT'd tight loop).  Both are monotonic; we
+        # only give up the "comparable across processes" guarantee of
+        # `monotonic`, which `timer` does not need since it only measures
+        # a dynamic extent in wall-clock time within a single process.
+        self.t0 = perf_counter()
         return self
     def __exit__(self, exctype, excvalue, traceback):
-        self.dt = monotonic() - self.t0
+        self.dt = perf_counter() - self.t0
         if self.p:
             print(self.dt)
 

unpythonic/timeutil.py

@@ -70,7 +70,7 @@ class ETAEstimator:
     is available in `self.completed`.
     """
     def __init__(self, total: int, keep_last: typing.Optional[int] = None):
-        self.t1 = time.monotonic()  # time since last tick
+        self.t1 = time.perf_counter()  # time since last tick
         self.t0 = self.t1  # time since beginning
         self.total = total  # total number of work items
         self.completed = 0  # number of completed work items
@@ -79,7 +79,7 @@ def __init__(self, total: int, keep_last: typing.Optional[int] = None):
     def tick(self) -> None:
         """Mark one more task as completed, automatically updating the internal timings cache."""
         self.completed += 1
-        t = time.monotonic()
+        t = time.perf_counter()
         dt = t - self.t1
         self.t1 = t
         self.que.append(dt)
@@ -109,7 +109,7 @@ def _estimate(self) -> typing.Optional[float]:
     estimate = property(fget=_estimate, doc="Estimate of time remaining, in seconds. Computed when read; read-only. If no tasks have been marked completed yet, the estimate is `None`.")
 
     def _elapsed(self) -> float:
-        return time.monotonic() - self.t0
+        return time.perf_counter() - self.t0
     elapsed = property(fget=_elapsed, doc="Total elapsed time, in seconds. Computed when read; read-only.")
 
     def _formatted_eta(self) -> str: