expr_tracker 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

expr_tracker/__init__.py

@@ -1,7 +1,7 @@
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _version
 
-from . import tracker
+from . import plugins, tracker
 from .alerts import (
     AlertConfig,
     AlertLevel,
@@ -61,6 +61,7 @@ __all__ = [
     "list_alert_rules",
     "log",
     "log_artifact",
+    "plugins",
     "register_backend",
     "remove_alert_rule",
     "span",

expr_tracker/history/store.py

@@ -19,6 +19,7 @@ from collections import deque
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, fields
 from pathlib import Path
+from typing import Any
 
 from loguru import logger
 
@@ -74,6 +75,9 @@ class HistoryOptions:
     stream: str | None = None
     # write the full span tree to spans.jsonl beside the metrics
     spans: bool = True
+    # run-wide defaults for et.span(); a span's own arguments win
+    span_print_fn: Callable[[str], None] | None = None
+    span_plugins: Sequence[Any] = ()
     # alerts and output
     alert_window: int = DEFAULT_WINDOW
     print_to_screen: bool = False

expr_tracker/plugins.py

@@ -0,0 +1,269 @@
+"""Span plugins: measure a resource across a span and attach it to the record.
+
+A plugin is any object with ``start(span)`` and ``end(span) -> dict``; a plain
+``fn(span) -> dict`` works as an end-only plugin. Whatever ``end`` returns is
+merged into the span's metrics under the span's own path, so a plugin returning
+``{"cpu_percent": 91.2}`` on a ``forward`` span writes ``forward/cpu_percent``.
+
+Plugins are opt-in because they are not free. A bare span costs ~13us; see each
+plugin's docstring for what it adds.
+"""
+
+from __future__ import annotations
+
+import atexit
+import threading
+import time
+from collections import deque
+from typing import Any
+
+from loguru import logger
+
+__all__ = ["CpuTime", "GpuStats", "TorchMemory", "stop_samplers"]
+
+
+class CpuTime:
+    """CPU utilisation over the span, from :func:`time.process_time`.
+
+    Reports ``cpu_percent`` (process CPU time / wall time, so >100% means the
+    span used more than one core) and ``cpu_time_ms``. Exact, not sampled, and
+    the cheapest thing here at ~1.5us per span. Counts every thread in the
+    process, so concurrent work outside the span inflates it.
+    """
+
+    __slots__ = ("_stack",)
+
+    def __init__(self):
+        self._stack: dict[int, list[float]] = {}
+
+    def _frames(self) -> list[float]:
+        return self._stack.setdefault(threading.get_ident(), [])
+
+    def start(self, span) -> None:
+        self._frames().append(time.process_time())
+
+    def end(self, span) -> dict[str, float]:
+        frames = self._frames()
+        if not frames:
+            return {}
+        used_ms = (time.process_time() - frames.pop()) * 1000.0
+        percent = 100.0 * used_ms / span.duration_ms if span.duration_ms > 0 else 0.0
+        return {"cpu_time_ms": round(used_ms, 3), "cpu_percent": round(percent, 1)}
+
+
+class TorchMemory:
+    """Peak CUDA memory the allocator held during the span, via torch.
+
+    Reports ``gpu_mem_peak_mb`` and ``gpu_mem_delta_mb`` (end minus start, i.e.
+    what the span kept). Exact, ~10us per span.
+
+    ``torch.cuda.max_memory_allocated`` is one global high-water mark, so a
+    naive reset would let a child span erase its parent's history. This keeps
+    its own stack and rolls each child's peak back into the enclosing span.
+    """
+
+    __slots__ = ("_device", "_stack", "_torch")
+
+    def __init__(self, device: Any = None):
+        self._device = device
+        self._torch = None
+        self._stack: dict[int, list[tuple[float, float]]] = {}
+
+    def _cuda(self):
+        if self._torch is None:
+            import torch  # raised to _safely() and logged once per span otherwise
+
+            self._torch = torch
+        if not self._torch.cuda.is_available():
+            raise RuntimeError("CUDA is not available")
+        return self._torch.cuda
+
+    def _frames(self) -> list[list[float]]:
+        return self._stack.setdefault(threading.get_ident(), [])
+
+    def _read(self, cuda) -> tuple[float, float]:
+        """(allocated, peak) in bytes.
+
+        One nested-stats call costs ~17us; the two public helpers rebuild and
+        flatten the whole stats dict separately and cost ~90us each.
+        """
+        nested = getattr(cuda, "memory_stats_as_nested_dict", None)
+        if nested is not None:
+            stats = nested(device=self._device).get("allocated_bytes")
+            if stats:
+                return float(stats["all"]["current"]), float(stats["all"]["peak"])
+        return (
+            float(cuda.memory_allocated(self._device)),
+            float(cuda.max_memory_allocated(self._device)),
+        )
+
+    def start(self, span) -> None:
+        cuda = self._cuda()
+        opening, outer_peak = self._read(cuda)
+        # [peak the enclosing span had reached, our opening bytes, carried peak]
+        self._frames().append([outer_peak, opening, 0.0])
+        cuda.reset_peak_memory_stats(self._device)
+
+    def end(self, span) -> dict[str, float]:
+        frames = self._frames()
+        if not frames:
+            return {}
+        outer_peak, opening, carried = frames.pop()
+        closing, raw_peak = self._read(self._cuda())
+        # The counter was reset for us, so it holds our peak alone; our own
+        # children left anything that predated them in `carried`
+        peak = max(raw_peak, carried)
+        if frames:
+            # Hand our parent back the peak it had before we reset the counter
+            frames[-1][2] = max(frames[-1][2], outer_peak)
+        return {
+            "gpu_mem_peak_mb": round(peak / 1048576, 3),
+            "gpu_mem_delta_mb": round((closing - opening) / 1048576, 3),
+        }
+
+
+class _NvmlSampler:
+    """One background thread polling NVML, shared by every :class:`GpuStats`.
+
+    Sampling in the background is the only honest way to report utilisation:
+    NVML's counter is a rolling average over its own window, so reading it once
+    at the end of a 3ms span says nothing about that span.
+    """
+
+    def __init__(self, index: int, interval: float):
+        self.index = index
+        self.interval = interval
+        self.samples: deque[tuple[float, float, float]] = deque(
+            maxlen=max(64, int(60.0 / interval))
+        )
+        self._handle = None
+        self._thread: threading.Thread | None = None
+        self._stop = threading.Event()
+        self._lock = threading.Lock()
+
+    def handle(self):
+        if self._handle is None:
+            import pynvml
+
+            pynvml.nvmlInit()
+            self._handle = pynvml.nvmlDeviceGetHandleByIndex(self.index)
+            self._pynvml = pynvml
+        return self._handle
+
+    def read(self) -> tuple[float, float]:
+        handle = self.handle()
+        rates = self._pynvml.nvmlDeviceGetUtilizationRates(handle)
+        memory = self._pynvml.nvmlDeviceGetMemoryInfo(handle)
+        return float(rates.gpu), float(memory.used)
+
+    def ensure_running(self) -> None:
+        thread = self._thread
+        if thread is not None and thread.is_alive():
+            return  # the common case, off the lock
+        with self._lock:
+            if self._thread is not None and self._thread.is_alive():
+                return
+            self.handle()  # fail loudly here, not once per sample
+            self._stop.clear()
+            self._thread = threading.Thread(
+                target=self._run, name=f"et-nvml-{self.index}", daemon=True
+            )
+            self._thread.start()
+
+    def _run(self) -> None:
+        while not self._stop.wait(self.interval):
+            try:
+                util, used = self.read()
+            except Exception as e:
+                logger.warning(f"NVML sampling stopped: {e}")
+                return
+            with self._lock:
+                self.samples.append((time.time(), util, used))
+
+    def stop(self) -> None:
+        self._stop.set()
+        thread = self._thread
+        if thread is not None:
+            thread.join(timeout=self.interval * 2 + 1.0)
+        self._thread = None
+
+    def window(self, start: float, end: float) -> list[tuple[float, float, float]]:
+        """Samples inside [start, end], newest first.
+
+        Scanned backwards so a span pays for its own window, not for the whole
+        minute of history the deque keeps.
+        """
+        picked = []
+        with self._lock:
+            samples = self.samples
+            for index in range(len(samples) - 1, -1, -1):
+                sample = samples[index]
+                if sample[0] < start:
+                    break
+                if sample[0] <= end:
+                    picked.append(sample)
+        return picked
+
+
+_SAMPLERS: dict[tuple[int, float], _NvmlSampler] = {}
+_SAMPLERS_LOCK = threading.Lock()
+
+
+def _sampler(index: int, interval: float) -> _NvmlSampler:
+    key = (index, interval)
+    with _SAMPLERS_LOCK:
+        sampler = _SAMPLERS.get(key)
+        if sampler is None:
+            sampler = _SAMPLERS[key] = _NvmlSampler(index, interval)
+    return sampler
+
+
+def stop_samplers() -> None:
+    """Stop every background NVML sampler. Called for you at run teardown."""
+    with _SAMPLERS_LOCK:
+        samplers = list(_SAMPLERS.values())
+        _SAMPLERS.clear()
+    for sampler in samplers:
+        sampler.stop()
+
+
+class GpuStats:
+    """GPU utilisation and device memory over the span, sampled via NVML.
+
+    Reports ``gpu_percent`` (mean utilisation across the span) and
+    ``gpu_mem_used_mb`` (peak device memory). Needs ``nvidia-ml-py``:
+    ``pip install expr-tracker[gpu]``.
+
+    A background thread does the sampling, so the span itself pays almost
+    nothing. Device memory covers the whole GPU, not just this process; use
+    :class:`TorchMemory` for what your own allocator holds.
+
+    Spans shorter than ``interval`` may contain no sample. They fall back to one
+    live reading (~14us), which for utilisation is NVML's own rolling average
+    rather than a measurement of the span.
+    """
+
+    __slots__ = ("_sampler",)
+
+    def __init__(self, index: int = 0, interval: float = 0.1):
+        if interval <= 0:
+            raise ValueError("interval must be > 0")
+        self._sampler = _sampler(int(index), float(interval))
+
+    def start(self, span) -> None:
+        self._sampler.ensure_running()
+
+    def end(self, span) -> dict[str, float]:
+        samples = self._sampler.window(span.started_at, time.time())
+        if samples:
+            util = sum(s[1] for s in samples) / len(samples)
+            used = max(s[2] for s in samples)
+        else:
+            util, used = self._sampler.read()
+        return {
+            "gpu_percent": round(util, 1),
+            "gpu_mem_used_mb": round(used / 1048576, 3),
+        }
+
+
+atexit.register(stop_samplers)

expr_tracker/spans.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import functools
 import threading
 import time
+from collections.abc import Callable, Sequence
 from contextvars import ContextVar
 from typing import Any
 
@@ -24,6 +25,41 @@ _STACK: ContextVar[tuple[Span, ...]] = ContextVar("et_span_stack", default=())
 
 DURATION_SUFFIX = "duration_ms"
 COUNT_SUFFIX = "count"
+RESERVED_METRICS = frozenset({DURATION_SUFFIX, COUNT_SUFFIX})
+
+
+_WARNED: set[tuple[str, str, str]] = set()
+
+
+def _warn_once(*key: str) -> None:
+    """A plugin that fails once fails every span; say so only the first time."""
+    if key in _WARNED:
+        return
+    if len(_WARNED) > 256:  # a pathological plugin must not leak memory
+        _WARNED.clear()
+    _WARNED.add(key)
+    logger.warning(key[-1])
+
+
+def _safely(plugin: Any, hook: str, span: Span):
+    """Call a plugin hook; a broken plugin must not break the measured code."""
+    method = getattr(plugin, hook, None)
+    if method is None and hook == "end" and callable(plugin):
+        method = plugin  # a plain callable is an end-only plugin
+    if method is None:
+        return None
+    try:
+        return method(span)
+    except Exception as e:
+        name = type(plugin).__name__
+        _warn_once(name, hook, f"Span plugin {name} failed in {hook}(): {e}")
+        return None
+
+
+def _pretty(value) -> str:
+    if isinstance(value, float):
+        return f"{value:.3f}".rstrip("0").rstrip(".")
+    return str(value)
 
 
 def current_span() -> Span | None:
@@ -45,19 +81,37 @@ class Span:
         "_store",
         "_token",
         "attributes",
+        "depth",
         "duration_ms",
         "error",
+        "metrics",
         "name",
         "path",
+        "plugins",
+        "print_depth",
+        "print_fn",
         "start",
         "started_at",
         "track",
     )
 
-    def __init__(self, name: str, store, **attributes: Any):
+    def __init__(
+        self,
+        name: str,
+        store,
+        *,
+        print_fn: Callable[[str], None] | None = None,
+        plugins: Sequence[Any] = (),
+        **attributes: Any,
+    ):
         self.name = str(name).strip("/") or "span"
         self.attributes = dict(attributes)
         self._store = store
+        self.print_fn = print_fn
+        self.plugins = tuple(plugins)
+        self.metrics: dict[str, Any] = {}
+        self.depth = 0
+        self.print_depth = 0
         self.path = self.name
         self.track = 0
         self.start = 0.0
@@ -72,29 +126,78 @@ class Span:
     def begin(self) -> Span:
         parent = current_span()
         self.path = f"{parent.path}/{self.name}" if parent else self.name
+        self.depth = parent.depth + 1 if parent else 0
         # Children share their parent's track, so a tree never straddles lanes
         self.track = parent.track if parent else threading.get_ident()
+        if self.print_fn is None and parent is not None:
+            self.print_fn = parent.print_fn  # inherited, so a tree prints as one
+        if parent is not None and parent.print_fn is self.print_fn:
+            self.print_depth = parent.print_depth + 1
+        # else this span roots its own output: indent from 0, not from a parent
+        # that printed nothing
+        if not self.plugins and parent is not None:
+            self.plugins = parent.plugins
+        for plugin in self.plugins:
+            _safely(plugin, "start", self)
         self.started_at = time.time()
         self.start = time.perf_counter()
         self._token = _STACK.set((*_STACK.get(), self))
+        self._announce("->", None)
         return self
 
     def end(self, error: BaseException | None = None) -> float:
         """Close the span and record it. Returns the duration in milliseconds."""
-        if self._ended:
+        if self._ended or self.started_at == 0.0:
+            # Never begun: there is no duration to report and nothing to record
             return self.duration_ms
         self._ended = True
         self.duration_ms = (time.perf_counter() - self.start) * 1000.0
         if error is not None:
             self.error = type(error).__name__
+        for plugin in self.plugins:
+            measured = _safely(plugin, "end", self)
+            if isinstance(measured, dict):
+                self.metrics.update(self._admissible(plugin, measured))
         if self._token is not None:
-            try:
-                _STACK.reset(self._token)
-            except ValueError:  # pragma: no cover - ended on another thread/task
-                _STACK.set(tuple(s for s in _STACK.get() if s is not self))
+            # Drop ourselves rather than resetting the token. A token restores
+            # the whole stack as it was, so a span ended out of order would
+            # resurrect spans that already closed underneath it.
+            self._token = None
+            _STACK.set(tuple(s for s in _STACK.get() if s is not self))
         self._record()
+        self._announce("<-", self.duration_ms)
         return self.duration_ms
 
+    def _admissible(self, plugin: Any, measured: dict) -> dict:
+        """A plugin may add metrics to a span; it may not redefine its timing."""
+        if not RESERVED_METRICS.intersection(measured):
+            return measured
+        name = type(plugin).__name__
+        for key in RESERVED_METRICS.intersection(measured):
+            _warn_once(name, key, f"Span plugin {name} may not set {key!r}; ignored")
+        return {k: v for k, v in measured.items() if k not in RESERVED_METRICS}
+
+    def _announce(self, marker: str, duration_ms: float | None):
+        if self.print_fn is None:
+            return
+        indent = "\t" * self.print_depth
+        stamp = time.strftime("%H:%M:%S", time.localtime())
+        if duration_ms is None:
+            line = f"{indent}{marker} {self.name}  {stamp}"
+        else:
+            extra = "".join(
+                f"  {key}={_pretty(value)}" for key, value in self.metrics.items()
+            )
+            failed = f"  !{self.error}" if self.error else ""
+            line = (
+                f"{indent}{marker} {self.name}  {stamp}  "
+                f"{duration_ms:.3f}ms{extra}{failed}"
+            )
+        try:
+            self.print_fn(line)
+        except Exception as e:  # printing must never break the thing measured
+            _warn_once("print_fn", type(e).__name__, f"Span print handler failed: {e}")
+
     def set(self, **attributes: Any) -> Span:
         """Attach attributes; they reach ``spans.jsonl``, not the metrics."""
         self.attributes.update(attributes)
@@ -128,16 +231,19 @@ class Span:
         metrics = {
             f"{self.path}/{DURATION_SUFFIX}": self.duration_ms,
             f"{self.path}/{COUNT_SUFFIX}": 1,
+            **{f"{self.path}/{key}": value for key, value in self.metrics.items()},
         }
         record = {
             "name": self.path,
-            "depth": self.path.count("/"),
+            "depth": self.depth,
             "track": self.track,
             "start": self.started_at,
             "dur_ms": self.duration_ms,
         }
         if self.attributes:
             record["args"] = self.attributes
+        if self.metrics:
+            record["metrics"] = self.metrics
         if self.error:
             record["error"] = self.error
         try:
@@ -147,19 +253,34 @@ class Span:
 
 
 class _NullSpan(Span):
-    """What you get without a run: still times, records nothing."""
+    """What you get without a run: still times and prints, records nothing."""
 
-    def __init__(self, name: str, **attributes: Any):
-        super().__init__(name, None, **attributes)
+    def __init__(self, name: str, **kwargs: Any):
+        super().__init__(name, None, **kwargs)
 
 
-def start_span(name: str, **attributes: Any) -> Span:
+def start_span(
+    name: str,
+    *,
+    print_fn: Callable[[str], None] | None = None,
+    plugins: Sequence[Any] = (),
+    **attributes: Any,
+) -> Span:
     """Begin a span that you will ``end()`` yourself, possibly in another scope."""
     from .run import current_run
 
     run = current_run()
     store = run.history if run is not None else None
-    span = Span(name, store, **attributes) if store is not None else _NullSpan(name)
+    if store is not None:
+        # The span's own arguments win over the run-wide defaults
+        print_fn = print_fn if print_fn is not None else store.options.span_print_fn
+        plugins = plugins or store.options.span_plugins
+    options = {"print_fn": print_fn, "plugins": plugins, **attributes}
+    span = (
+        Span(name, store, **options)
+        if store is not None
+        else _NullSpan(name, **options)
+    )
     return span.begin()
 
 
@@ -182,9 +303,16 @@ class span:
     ``forward/attention/duration_ms`` and window functions work on it directly.
     """
 
-    def __init__(self, name: str, **attributes: Any):
+    def __init__(
+        self,
+        name: str,
+        *,
+        print_fn: Callable[[str], None] | None = None,
+        plugins: Sequence[Any] = (),
+        **attributes: Any,
+    ):
         self._name = name
-        self._attributes = attributes
+        self._attributes = {"print_fn": print_fn, "plugins": plugins, **attributes}
         self._span: Span | None = None
 
     def __enter__(self) -> Span:

expr_tracker/trace.py

@@ -149,6 +149,7 @@ def build_trace(
             start = float(record["start"])
             origin = start if origin is None else min(origin, start)
             args = dict(record.get("args") or {})
+            args.update(record.get("metrics") or {})
             args["step"] = record.get("_step")
             if record.get("error"):
                 args["error"] = record["error"]

{expr_tracker-0.2.3.dist-info → expr_tracker-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: expr_tracker
-Version: 0.2.3
+Version: 0.2.4
 Summary: Local-first experiment tracking with queryable history and expression-based alerts on your training metrics
 Project-URL: Homepage, https://hspk.github.io/expr_tracker/
 Project-URL: Documentation, https://hspk.github.io/expr_tracker/
@@ -28,11 +28,14 @@ Requires-Dist: click>=8.1.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: pydantic>=2.0
 Provides-Extra: all
+Requires-Dist: nvidia-ml-py>=12.0; extra == 'all'
 Requires-Dist: pandas>=1.5; extra == 'all'
 Requires-Dist: polars>=0.20; extra == 'all'
 Requires-Dist: slark>=0.1.28; extra == 'all'
 Requires-Dist: trackio>=0.4.0; extra == 'all'
 Requires-Dist: wandb>=0.21.0; extra == 'all'
+Provides-Extra: gpu
+Requires-Dist: nvidia-ml-py>=12.0; extra == 'gpu'
 Provides-Extra: lark
 Requires-Dist: slark>=0.1.28; extra == 'lark'
 Provides-Extra: pandas
@@ -106,7 +109,7 @@ install command; it never crashes a run.
 | [Alerts](https://hspk.github.io/expr_tracker/guide/alerts/) | An expression DSL with rolling windows, three-valued logic (no false alarms during warm-up), a rule state machine, and a watchdog that catches a hung run. |
 | [Channels](https://hspk.github.io/expr_tracker/guide/alerts/#channels) | Lark, Slack, DingTalk, WeCom, generic webhook, email — with rate limiting, dedup, retries and per-channel routing. |
 | [Artifacts](https://hspk.github.io/expr_tracker/guide/artifacts/) | Versioned file sets, deduplicated by content, shared across a project's runs, with lineage. |
-| [Spans](https://hspk.github.io/expr_tracker/guide/spans/) | Time the parts of a step, and their parts. Each duration becomes a metric, so alerts and queries work on it unchanged; `et trace` exports the timeline for Perfetto. |
+| [Spans](https://hspk.github.io/expr_tracker/guide/spans/) | Time the parts of a step, and their parts. Each duration becomes a metric, so alerts and queries work on it unchanged; `et trace` exports the timeline for Perfetto. `print_fn` prints the tree live, and plugins attach CPU and GPU cost to each region. |
 | [Streams](https://hspk.github.io/expr_tracker/guide/streams/) | Independent producers — a data worker and a training loop — each with their own step cursor and file inside one run. |
 | [Distributed](https://hspk.github.io/expr_tracker/guide/distributed/) | Per-rank shards so concurrent appends cannot corrupt step order; only rank 0 alerts by default. |
 | [CLI](https://hspk.github.io/expr_tracker/guide/cli/) | `et history`, `et rules explain`, `et rules test`, `et alert`. |
@@ -152,6 +155,7 @@ uv run ruff format src tests
 | `test_expr_properties.py` | DSL properties: render round-trip stability, precedence, the whole `M` builder |
 | `test_trace.py` | Chrome Trace export: lane layout, stream and step selection, the CLI |
 | `test_spans.py` | nesting, aggregation, decorator and async forms, errors, thread and task isolation |
+| `test_span_plugins.py` | `print_fn` output and indentation, the plugin protocol, failure isolation, CPU/GPU built-ins |
 | `test_streams.py` | stream naming and validation, isolation, resolution order, backend grouping, two-process runs |
 | `test_distributed.py` | rank shards, `alert_on_rank`, real multi-process runs |
 | `test_wandb.py` | real wandb in offline mode: parameter mapping, step alignment, artifacts |

{expr_tracker-0.2.3.dist-info → expr_tracker-0.2.4.dist-info}/RECORD

@@ -1,13 +1,14 @@
-expr_tracker/__init__.py,sha256=wWvM6nZSIlP_pWYcmQGEbMMD9GCBA0hpatui5TNwPHI,1418
+expr_tracker/__init__.py,sha256=AdY6R3bKLlZFhNtJPBAA3UHhO9nZ7YpojLrkW9OevlM,1442
 expr_tracker/_compat.py,sha256=qf8oYIK_lkoLzcPp6wPCYLJtVatCl7ROYRNPwc5F1Pg,981
 expr_tracker/artifacts.py,sha256=yRVXmuqdZUxiZa0c_CwZi4rBxaItwhu9bZ1x21yP1S0,12560
 expr_tracker/cli.py,sha256=dtp0YsNtGg7T7M-elA511YX8NU_-OJRAwNbs8I1353o,7255
 expr_tracker/encoders.py,sha256=X5ySQasSrYPsdYCdk7nhpJFGFB9f_8HWQuGOQjTvh9E,11991
+expr_tracker/plugins.py,sha256=-ako71QBr5ARYS3aFUueHx3SMESk5ii2wj_yiz2_Mzc,9592
 expr_tracker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 expr_tracker/run.py,sha256=nuXhNmepG688X86cI0FMM_hqjyygD1Oi8Ck8-lyHsPA,16664
-expr_tracker/spans.py,sha256=su1M0yxgi51911a6rBPaWhDoVBfIW1vla_okYCW9Z28,7365
+expr_tracker/spans.py,sha256=sYj7BoFuNXEd4Ic11W_cqhLEjkh3ViBfTnW4vOvTTkg,12144
 expr_tracker/summary.py,sha256=lpHSh3pci2Ym6wJhVZwNUJbUp2A64EN_rC7Ym2d7PPI,3150
-expr_tracker/trace.py,sha256=lag-T-5F1LOz4MKsxeMfTW1FJN0KxxznJ48sYT7vX28,6966
+expr_tracker/trace.py,sha256=stOIuEzuFLHZrrqbaTWndOOnhSXEJzHF91zPGDpU5PA,7019
 expr_tracker/tracker.py,sha256=hpZB8bFA2GqCbvHEDZkBS9cCzi2JgXeLUNTzJm-wr8c,5921
 expr_tracker/types.py,sha256=69gFtUaKGl4asLK7nJci9XyTyV0yTIPorB-bcfGrCBA,383
 expr_tracker/alerts/__init__.py,sha256=dl96OYZh75kV3NLBSA35zNvTFcL6XFMuPoYvRoz7hlQ,8192
@@ -29,10 +30,10 @@ expr_tracker/history/frame.py,sha256=PFDGqR0oHY94KosSXA7Fu-bphEhZ2yM8cXW9rlZ2IC0
 expr_tracker/history/naming.py,sha256=CT2xDpo0GHYnLyjgRlsPjIX3GAIDEdn4U9I1-cNahHw,2507
 expr_tracker/history/reader.py,sha256=5PY5nbNfX-Cl34jcyYTq2qm8nNgNDTqv7U5Xnb9Rgxw,14155
 expr_tracker/history/series.py,sha256=cFdUO1FRs5KW0jYsNPzda3tcu645NH1wwfXJitQfXFM,4042
-expr_tracker/history/store.py,sha256=ZazPIcQ0Aj23DzIBN7B-xiIAk5ej6wfwsUdBYNywHNw,36047
+expr_tracker/history/store.py,sha256=uSbHcGdLXFVFbYQKm6IaQgpdCrNvvb9Axpxi9emvwBo,36228
 expr_tracker/history/writer.py,sha256=q5kNANcZCq5nykvOK5jZ2xc6Z1B4oZxEn3uSXzDCtlY,16096
-expr_tracker-0.2.3.dist-info/METADATA,sha256=HXNy4hcFe74JnO8dYmnPfoCqt2IJpjWJT34E6eK6yYE,9120
-expr_tracker-0.2.3.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-expr_tracker-0.2.3.dist-info/entry_points.txt,sha256=GfZCAG2JFsd5CxTjRsGJAhYInpBCuLjrU3csmUVBDSs,45
-expr_tracker-0.2.3.dist-info/licenses/LICENSE,sha256=ORsYTnF-2SLUaM8FgXlJ-uXuN4ceGACAAU3JZiS8pvs,1069
-expr_tracker-0.2.3.dist-info/RECORD,,
+expr_tracker-0.2.4.dist-info/METADATA,sha256=aSjFfY1k1dJwzBRHWvm3aqisY6O0Gi6S7HvMAp37Fs4,9447
+expr_tracker-0.2.4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+expr_tracker-0.2.4.dist-info/entry_points.txt,sha256=GfZCAG2JFsd5CxTjRsGJAhYInpBCuLjrU3csmUVBDSs,45
+expr_tracker-0.2.4.dist-info/licenses/LICENSE,sha256=ORsYTnF-2SLUaM8FgXlJ-uXuN4ceGACAAU3JZiS8pvs,1069
+expr_tracker-0.2.4.dist-info/RECORD,,

{expr_tracker-0.2.3.dist-info → expr_tracker-0.2.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any