predcache 0.1.0__tar.gz → 0.2.0__tar.gz

{predcache-0.1.0/src/predcache.egg-info → predcache-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: predcache
-Version: 0.1.0
+Version: 0.2.0
 Summary: Persistent timestamp-keyed prediction cache and batched inference runner for ML models
 Author-email: Anton Uralskii <uralskyanton@gmail.com>
 License: MIT
@@ -28,9 +28,13 @@ Requires-Dist: numpy>=1.21
 Provides-Extra: parquet
 Requires-Dist: pandas>=1.5; extra == "parquet"
 Requires-Dist: pyarrow>=10; extra == "parquet"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20; extra == "otel"
 Provides-Extra: test
 Requires-Dist: pytest>=7; extra == "test"
 Requires-Dist: pandas>=1.5; extra == "test"
+Requires-Dist: opentelemetry-api>=1.20; extra == "test"
+Requires-Dist: opentelemetry-sdk>=1.20; extra == "test"
 Dynamic: license-file
 
 # predcache
@@ -104,9 +108,50 @@ out = cache.get_or_compute(
   box; register custom backends with `register_backend(name, dump, load)`.
 - **Batched inference runner** — framework-agnostic `(start, stop) -> scores`
   contract, progress callbacks, tuned default batch size (500).
+- **OpenTelemetry instrumentation** — optional spans + counters for cache hits,
+  computed predictions, batched inference and feature assembly (see below).
 - **L-inf normalization** helper matching the source system's
   `normalize_vector_absolute`.
 
+## Observability (OpenTelemetry)
+
+`predcache` emits spans and counters for every expensive operation. The
+`opentelemetry-api` package is **optional**: without it predcache runs
+identically with zero overhead; with it installed, signals flow to whatever
+Tracer/Meter provider your application configured.
+
+```bash
+pip install predcache[otel]        # pull in opentelemetry-api
+```
+
+```python
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+
+trace.set_tracer_provider(TracerProvider())
+trace.get_tracer_provider().add_span_processor(
+    BatchSpanProcessor(ConsoleSpanExporter())
+)
+
+from predcache import PredictionCache
+
+cache = PredictionCache("preds.pkl")
+cache.get_or_compute(keys, compute_fn)
+# -> span "predcache.get_or_compute" with predcache.requested / .computed /
+#    .hits / .elapsed_s attributes, + predictions.computed counter
+```
+
+| Signal | Name | Attributes |
+|---|---|---|
+| span | `predcache.get_or_compute` | `predcache.requested`, `.computed`, `.hits`, `.elapsed_s` |
+| span | `predcache.inference` | `predcache.rows`, `.batch_size`, `.elapsed_s` |
+| span | `predcache.features` | `predcache.windows`, `.window`, `.warmup`, `.elapsed_s` |
+| counter | `predcache.predictions.computed` / `.hits` | — |
+| counter | `predcache.inference.batches` / `.rows` | — |
+
+Set `PREDCACHE_OTEL=0` to disable emission entirely (hot loops, test runs).
+
 ## Origin
 
 This package is the generalized core of the prediction-serving layer of

{predcache-0.1.0 → predcache-0.2.0}/README.md

@@ -69,9 +69,50 @@ out = cache.get_or_compute(
   box; register custom backends with `register_backend(name, dump, load)`.
 - **Batched inference runner** — framework-agnostic `(start, stop) -> scores`
   contract, progress callbacks, tuned default batch size (500).
+- **OpenTelemetry instrumentation** — optional spans + counters for cache hits,
+  computed predictions, batched inference and feature assembly (see below).
 - **L-inf normalization** helper matching the source system's
   `normalize_vector_absolute`.
 
+## Observability (OpenTelemetry)
+
+`predcache` emits spans and counters for every expensive operation. The
+`opentelemetry-api` package is **optional**: without it predcache runs
+identically with zero overhead; with it installed, signals flow to whatever
+Tracer/Meter provider your application configured.
+
+```bash
+pip install predcache[otel]        # pull in opentelemetry-api
+```
+
+```python
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+
+trace.set_tracer_provider(TracerProvider())
+trace.get_tracer_provider().add_span_processor(
+    BatchSpanProcessor(ConsoleSpanExporter())
+)
+
+from predcache import PredictionCache
+
+cache = PredictionCache("preds.pkl")
+cache.get_or_compute(keys, compute_fn)
+# -> span "predcache.get_or_compute" with predcache.requested / .computed /
+#    .hits / .elapsed_s attributes, + predictions.computed counter
+```
+
+| Signal | Name | Attributes |
+|---|---|---|
+| span | `predcache.get_or_compute` | `predcache.requested`, `.computed`, `.hits`, `.elapsed_s` |
+| span | `predcache.inference` | `predcache.rows`, `.batch_size`, `.elapsed_s` |
+| span | `predcache.features` | `predcache.windows`, `.window`, `.warmup`, `.elapsed_s` |
+| counter | `predcache.predictions.computed` / `.hits` | — |
+| counter | `predcache.inference.batches` / `.rows` | — |
+
+Set `PREDCACHE_OTEL=0` to disable emission entirely (hot loops, test runs).
+
 ## Origin
 
 This package is the generalized core of the prediction-serving layer of

{predcache-0.1.0 → predcache-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "predcache"
-version = "0.1.0"
+version = "0.2.0"
 description = "Persistent timestamp-keyed prediction cache and batched inference runner for ML models"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -37,7 +37,8 @@ dependencies = ["numpy>=1.21"]
 
 [project.optional-dependencies]
 parquet = ["pandas>=1.5", "pyarrow>=10"]
-test = ["pytest>=7", "pandas>=1.5"]
+otel = ["opentelemetry-api>=1.20"]
+test = ["pytest>=7", "pandas>=1.5", "opentelemetry-api>=1.20", "opentelemetry-sdk>=1.20"]
 
 [project.urls]
 Homepage = "https://github.com/Geomanti/predcache"

{predcache-0.1.0 → predcache-0.2.0}/src/predcache/__init__.py

@@ -1,14 +1,16 @@
 """predcache: persistent prediction caching and batched inference for ML models."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 from .cache import PredictionCache, CacheEntry
 from .batched import BatchedInferenceRunner, InferenceFn
 from .windowing import FeatureWindowAssembler
+from .observability import otel_available
 
 __all__ = [
     "PredictionCache",
     "CacheEntry",
     "BatchedInferenceRunner",
     "FeatureWindowAssembler",
+    "otel_available",
 ]

{predcache-0.1.0 → predcache-0.2.0}/src/predcache/batched.py

@@ -14,6 +14,8 @@ from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence
 
 import numpy as np
 
+from .observability import _TimedSpan, add_count
+
 __all__ = ["BatchedInferenceRunner", "InferenceFn"]
 
 # A scorer takes (start, stop) and returns an array-like of predictions
@@ -79,19 +81,28 @@ class BatchedInferenceRunner:
         out: List[Any] = []
         t0 = time.perf_counter()
         n_batches = 0
-        for start, stop in self.batches():
-            chunk = self.inference_fn(start, stop)
-            out.extend(_row_iter(chunk))
-            n_batches += 1
-            if progress_cb and n_batches % self.progress_every == 0:
-                cb = {
-                    "rows_done": stop,
-                    "rows_total": self.n_samples,
-                    "batches": n_batches,
-                    "elapsed_s": round(time.perf_counter() - t0, 3),
-                }
-                self.progress_log.append(cb)
-                progress_cb(cb)
+        with _TimedSpan(
+            "predcache.inference",
+            {
+                "predcache.rows": self.n_samples,
+                "predcache.batch_size": self.batch_size,
+            },
+        ):
+            for start, stop in self.batches():
+                chunk = self.inference_fn(start, stop)
+                out.extend(_row_iter(chunk))
+                n_batches += 1
+                add_count("predcache.inference.batches", 1)
+                add_count("predcache.inference.rows", stop - start)
+                if progress_cb and n_batches % self.progress_every == 0:
+                    cb = {
+                        "rows_done": stop,
+                        "rows_total": self.n_samples,
+                        "batches": n_batches,
+                        "elapsed_s": round(time.perf_counter() - t0, 3),
+                    }
+                    self.progress_log.append(cb)
+                    progress_cb(cb)
         return out
 
 

{predcache-0.1.0 → predcache-0.2.0}/src/predcache/cache.py

@@ -24,6 +24,8 @@ import tempfile
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, Hashable, Iterable, List, Optional, Protocol
 
+from .observability import _TimedSpan, add_count
+
 __all__ = ["PredictionCache", "CacheEntry", "register_backend"]
 
 
@@ -200,13 +202,22 @@ class PredictionCache:
         dict ``{key: value}``.  Computed values are merged into the cache.
         """
         missing = [k for k in keys if k not in self._entries]
-        if missing:
-            computed = compute_fn(missing) or {}
-            for k, v in computed.items():
-                self._entries[k] = v
-            self._dirty = True
-            if save:
-                self.save()
+        with _TimedSpan(
+            "predcache.get_or_compute",
+            {
+                "predcache.requested": len(keys),
+                "predcache.computed": len(missing),
+                "predcache.hits": len(keys) - len(missing),
+            },
+        ):
+            if missing:
+                computed = compute_fn(missing) or {}
+                for k, v in computed.items():
+                    self._entries[k] = v
+                self._dirty = True
+                add_count("predcache.predictions.computed", len(computed))
+                if save:
+                    self.save()
         return {k: self._entries[k] for k in keys if k in self._entries}
 
     def drop(self, keys: List[Hashable]) -> int:

predcache-0.2.0/src/predcache/observability.py

@@ -0,0 +1,118 @@
+"""Optional OpenTelemetry instrumentation for predcache.
+
+Design
+------
+* **Zero hard dependency** — when ``opentelemetry`` is not installed every
+  helper here degrades to a no-op context manager / counter sink, so the
+  core cache stays dependency-light.
+* **Auto-enabled** — as soon as ``opentelemetry-api`` is importable, spans
+  and counters flow to whatever ``TracerProvider``/``MeterProvider`` the
+  host application configured (the OpenTelemetry API returns no-op
+  tracers/meters until a provider is set, so unconfigured hosts pay
+  near-zero cost).
+* **Explicit off switch** — set ``PREDCACHE_OTEL=0`` to disable emission
+  entirely (useful in hot loops or test matrices without the package).
+
+Emitted signals
+---------------
+Spans (as current spans, so they nest under the caller's trace):
+
+* ``predcache.get_or_compute`` — attributes ``predcache.requested``,
+  ``predcache.computed``, ``predcache.hits``
+* ``predcache.inference`` — ``predcache.rows``, ``predcache.batches``,
+  ``predcache.batch_size``, ``predcache.elapsed_s``
+* ``predcache.features`` — ``predcache.windows``, ``predcache.window``,
+  ``predcache.warmup``
+
+Counters:
+
+* ``predcache.predictions.computed`` / ``predcache.predictions.hits``
+* ``predcache.inference.batches`` / ``predcache.inference.rows``
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from contextlib import nullcontext
+from typing import Any, Dict, Optional
+
+__all__ = ["span", "add_count", "otel_available"]
+
+try:  # opentelemetry-api is optional
+    from opentelemetry import metrics, trace
+
+    _OTEL_AVAILABLE = True
+except ImportError:  # pragma: no cover - exercised in no-dependency installs
+    _OTEL_AVAILABLE = False
+
+_TRACER = None
+_METER = None
+_COUNTERS: Dict[str, Any] = {}
+
+
+def otel_available() -> bool:
+    """True when opentelemetry is importable and not disabled by env var."""
+    return _OTEL_AVAILABLE and os.environ.get("PREDCACHE_OTEL", "1") != "0"
+
+
+def _tracer():
+    global _TRACER
+    if _TRACER is None and _OTEL_AVAILABLE:
+        # ProxyTracer: resolves the real provider lazily, so caching here is safe
+        # even when the host sets the TracerProvider after importing predcache.
+        _TRACER = trace.get_tracer("predcache")
+    return _TRACER
+
+
+def _meter():
+    global _METER
+    if _METER is None and _OTEL_AVAILABLE:
+        _METER = metrics.get_meter("predcache")
+    return _METER
+
+
+def span(name: str, attributes: Optional[Dict[str, Any]] = None):
+    """Start a span as the current span; no-op context when OTel is absent."""
+    tracer = _tracer() if otel_available() else None
+    if tracer is None:
+        return nullcontext()
+    return tracer.start_as_current_span(name, attributes=attributes or {})
+
+
+def add_count(name: str, value: int = 1, attributes: Optional[Dict[str, Any]] = None) -> None:
+    """Increment a monotonic counter; no-op when OTel is absent."""
+    meter = _meter() if otel_available() else None
+    if meter is None:
+        return
+    counter = _COUNTERS.get(name)
+    if counter is None:
+        counter = meter.create_counter(name)
+        _COUNTERS[name] = counter
+    if attributes:
+        counter.add(value, attributes)
+    else:
+        counter.add(value)
+
+
+class _TimedSpan:
+    """Span helper that also reports elapsed seconds as a span attribute."""
+
+    def __init__(self, name: str, attributes: Optional[Dict[str, Any]] = None):
+        self._name = name
+        self._attributes = dict(attributes or {})
+        self._cm = span(name, self._attributes)
+        self._t0: Optional[float] = None
+
+    def __enter__(self):
+        self._cm.__enter__()
+        self._t0 = time.perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        if self._t0 is not None:
+            elapsed = round(time.perf_counter() - self._t0, 6)
+            current = trace.get_current_span() if _OTEL_AVAILABLE else None
+            if current is not None and current.is_recording():
+                current.set_attribute("predcache.elapsed_s", elapsed)
+        return self._cm.__exit__(exc_type, exc, tb)

{predcache-0.1.0 → predcache-0.2.0}/src/predcache/windowing.py

@@ -12,6 +12,8 @@ from typing import Callable, List, Optional, Sequence
 
 import numpy as np
 
+from .observability import _TimedSpan
+
 __all__ = ["normalize_absolute", "FeatureWindowAssembler"]
 
 
@@ -81,10 +83,18 @@ class FeatureWindowAssembler:
         """Stack feature rows for every window; returns (X, keys)."""
         if self.row_fn is None:
             raise ValueError("row_fn is required to build features")
-        rows: List[np.ndarray] = []
-        for win in self.windows(df):
-            rows.append(np.asarray(self.row_fn(win), dtype=np.float32))
-        if not rows:
-            return np.zeros((0, 0), dtype=np.float32), []
-        keys = self.keys(df, key_col) if key_col else self.keys(df)
-        return np.stack(rows, axis=0), keys
+        with _TimedSpan(
+            "predcache.features",
+            {
+                "predcache.windows": max(0, len(df) - self.warmup),
+                "predcache.window": self.window,
+                "predcache.warmup": self.warmup,
+            },
+        ):
+            rows: List[np.ndarray] = []
+            for win in self.windows(df):
+                rows.append(np.asarray(self.row_fn(win), dtype=np.float32))
+            if not rows:
+                return np.zeros((0, 0), dtype=np.float32), []
+            keys = self.keys(df, key_col) if key_col else self.keys(df)
+            return np.stack(rows, axis=0), keys

{predcache-0.1.0 → predcache-0.2.0/src/predcache.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: predcache
-Version: 0.1.0
+Version: 0.2.0
 Summary: Persistent timestamp-keyed prediction cache and batched inference runner for ML models
 Author-email: Anton Uralskii <uralskyanton@gmail.com>
 License: MIT
@@ -28,9 +28,13 @@ Requires-Dist: numpy>=1.21
 Provides-Extra: parquet
 Requires-Dist: pandas>=1.5; extra == "parquet"
 Requires-Dist: pyarrow>=10; extra == "parquet"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20; extra == "otel"
 Provides-Extra: test
 Requires-Dist: pytest>=7; extra == "test"
 Requires-Dist: pandas>=1.5; extra == "test"
+Requires-Dist: opentelemetry-api>=1.20; extra == "test"
+Requires-Dist: opentelemetry-sdk>=1.20; extra == "test"
 Dynamic: license-file
 
 # predcache
@@ -104,9 +108,50 @@ out = cache.get_or_compute(
   box; register custom backends with `register_backend(name, dump, load)`.
 - **Batched inference runner** — framework-agnostic `(start, stop) -> scores`
   contract, progress callbacks, tuned default batch size (500).
+- **OpenTelemetry instrumentation** — optional spans + counters for cache hits,
+  computed predictions, batched inference and feature assembly (see below).
 - **L-inf normalization** helper matching the source system's
   `normalize_vector_absolute`.
 
+## Observability (OpenTelemetry)
+
+`predcache` emits spans and counters for every expensive operation. The
+`opentelemetry-api` package is **optional**: without it predcache runs
+identically with zero overhead; with it installed, signals flow to whatever
+Tracer/Meter provider your application configured.
+
+```bash
+pip install predcache[otel]        # pull in opentelemetry-api
+```
+
+```python
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+
+trace.set_tracer_provider(TracerProvider())
+trace.get_tracer_provider().add_span_processor(
+    BatchSpanProcessor(ConsoleSpanExporter())
+)
+
+from predcache import PredictionCache
+
+cache = PredictionCache("preds.pkl")
+cache.get_or_compute(keys, compute_fn)
+# -> span "predcache.get_or_compute" with predcache.requested / .computed /
+#    .hits / .elapsed_s attributes, + predictions.computed counter
+```
+
+| Signal | Name | Attributes |
+|---|---|---|
+| span | `predcache.get_or_compute` | `predcache.requested`, `.computed`, `.hits`, `.elapsed_s` |
+| span | `predcache.inference` | `predcache.rows`, `.batch_size`, `.elapsed_s` |
+| span | `predcache.features` | `predcache.windows`, `.window`, `.warmup`, `.elapsed_s` |
+| counter | `predcache.predictions.computed` / `.hits` | — |
+| counter | `predcache.inference.batches` / `.rows` | — |
+
+Set `PREDCACHE_OTEL=0` to disable emission entirely (hot loops, test runs).
+
 ## Origin
 
 This package is the generalized core of the prediction-serving layer of

{predcache-0.1.0 → predcache-0.2.0}/src/predcache.egg-info/SOURCES.txt

@@ -4,10 +4,12 @@ pyproject.toml
 src/predcache/__init__.py
 src/predcache/batched.py
 src/predcache/cache.py
+src/predcache/observability.py
 src/predcache/windowing.py
 src/predcache.egg-info/PKG-INFO
 src/predcache.egg-info/SOURCES.txt
 src/predcache.egg-info/dependency_links.txt
 src/predcache.egg-info/requires.txt
 src/predcache.egg-info/top_level.txt
+tests/test_observability.py
 tests/test_predcache.py

predcache-0.2.0/src/predcache.egg-info/requires.txt

@@ -0,0 +1,14 @@
+numpy>=1.21
+
+[otel]
+opentelemetry-api>=1.20
+
+[parquet]
+pandas>=1.5
+pyarrow>=10
+
+[test]
+pytest>=7
+pandas>=1.5
+opentelemetry-api>=1.20
+opentelemetry-sdk>=1.20

predcache-0.2.0/tests/test_observability.py

@@ -0,0 +1,141 @@
+"""Observability tests: spans + counters with the in-memory exporter.
+
+These run only when opentelemetry is installed (the ``otel`` test extra);
+they are skipped cleanly otherwise. The no-op path is covered by forcing
+``PREDCACHE_OTEL=0``.
+
+Note: opentelemetry's SDK forbids overriding an already-set global
+Tracer/MeterProvider, so these tests share ONE module-scoped provider and
+read spans/metrics cumulatively (counting only the spans each test adds).
+"""
+
+import pytest
+
+pytest.importorskip("opentelemetry", reason="observability tests need opentelemetry-api/sdk")
+
+from opentelemetry import trace as _trace
+from opentelemetry import metrics as _metrics
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import InMemoryMetricReader
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+import predcache
+from predcache import BatchedInferenceRunner, FeatureWindowAssembler, PredictionCache
+
+
+@pytest.fixture(scope="module")
+def span_exporter():
+    """One provider for the module; returns the shared in-memory exporter."""
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    try:
+        _trace.set_tracer_provider(provider)
+    except Exception:
+        # A provider was already set by another test module — use a proxy
+        # tracer from the existing provider but keep collecting into ours.
+        pass
+    # Re-point predcache's lazy tracer at this provider.
+    import predcache.observability as obs
+
+    obs._TRACER = trace = _trace.get_tracer("predcache-test")
+    yield exporter
+    obs._TRACER = None  # restore lazy resolution
+
+
+@pytest.fixture(scope="module")
+def metric_reader():
+    reader = InMemoryMetricReader()
+    provider = MeterProvider(metric_readers=[reader])
+    try:
+        _metrics.set_meter_provider(provider)
+    except Exception:
+        pass
+    import predcache.observability as obs
+
+    obs._METER = _metrics.get_meter("predcache-test")
+    # predcache caches counters per meter; reset the cache so the new meter
+    # creates fresh counters instead of reusing ones from another provider.
+    obs._COUNTERS.clear()
+    yield reader
+    obs._METER = None
+    obs._COUNTERS.clear()
+
+
+def _names(exporter):
+    return [s.name for s in exporter.get_finished_spans()]
+
+
+def test_get_or_compute_emits_span_with_attributes(span_exporter, metric_reader, tmp_path):
+    n_before = len(_names(span_exporter))
+    cache = PredictionCache(str(tmp_path / "c.pkl"))
+    cache.get_or_compute(["a", "b"], compute_fn=lambda missing: {k: 1 for k in missing})
+    cache.get_or_compute(["a", "b", "c"], compute_fn=lambda missing: {k: 2 for k in missing})
+
+    spans = span_exporter.get_finished_spans()[n_before:]
+    names = [s.name for s in spans]
+    assert names.count("predcache.get_or_compute") == 2
+
+    second = spans[-1]
+    attrs = dict(second.attributes)
+    assert attrs["predcache.requested"] == 3
+    assert attrs["predcache.computed"] == 1
+    assert attrs["predcache.hits"] == 2
+    assert "predcache.elapsed_s" in attrs
+
+
+def test_runner_emits_inference_span_and_metrics(span_exporter, metric_reader):
+    n_before = len(_names(span_exporter))
+    runner = BatchedInferenceRunner(
+        n_samples=10, inference_fn=lambda s, e: [[float(i)] for i in range(s, e)], batch_size=4
+    )
+    runner.run()
+
+    spans = span_exporter.get_finished_spans()[n_before:]
+    inf = [s for s in spans if s.name == "predcache.inference"]
+    assert len(inf) == 1
+    attrs = dict(inf[0].attributes)
+    assert attrs["predcache.rows"] == 10
+    assert attrs["predcache.batch_size"] == 4
+    assert "predcache.elapsed_s" in attrs
+
+
+def test_features_span(span_exporter, metric_reader):
+    import pandas as pd
+
+    n_before = len(_names(span_exporter))
+    df = pd.DataFrame({"time": [f"t{i}" for i in range(6)], "close": range(6)})
+    asm = FeatureWindowAssembler(window=3, warmup=1, row_fn=lambda win: [float(win["close"].iloc[0])])
+    X, keys = asm.build(df, key_col="time")
+    assert len(keys) == 5
+
+    spans = span_exporter.get_finished_spans()[n_before:]
+    feat = [s for s in spans if s.name == "predcache.features"]
+    assert len(feat) == 1
+    attrs = dict(feat[0].attributes)
+    assert attrs["predcache.windows"] == 5
+    assert attrs["predcache.window"] == 3
+
+
+def test_env_kill_switch_disables_emission(span_exporter, metric_reader, tmp_path, monkeypatch):
+    monkeypatch.setenv("PREDCACHE_OTEL", "0")
+    try:
+        assert predcache.otel_available() is False
+        n_before = len(_names(span_exporter))
+        cache = PredictionCache(str(tmp_path / "c2.pkl"))
+        cache.get_or_compute(["x"], compute_fn=lambda missing: {k: 9 for k in missing})
+        assert len(_names(span_exporter)) == n_before
+    finally:
+        monkeypatch.delenv("PREDCACHE_OTEL", raising=False)
+
+
+def test_package_works_without_otel(monkeypatch, tmp_path):
+    """The no-op path: PREDCACHE_OTEL=0 must not change cache behavior."""
+    monkeypatch.setenv("PREDCACHE_OTEL", "0")
+    cache = PredictionCache(str(tmp_path / "c3.pkl"))
+    r1 = cache.get_or_compute(["k1"], compute_fn=lambda missing: {k: 42 for k in missing})
+    r2 = cache.get_or_compute(["k1"], compute_fn=lambda missing: {k: -1 for k in missing})
+    assert r1 == {"k1": 42}
+    assert r2 == {"k1": 42}  # served from cache, compute_fn not called

predcache-0.1.0/src/predcache.egg-info/requires.txt

@@ -1,9 +0,0 @@
-numpy>=1.21
-
-[parquet]
-pandas>=1.5
-pyarrow>=10
-
-[test]
-pytest>=7
-pandas>=1.5