lebre 0.1.0__py3-none-any.whl

lebre/__init__.py

@@ -0,0 +1,13 @@
+"""LEBRE — online one-step-ahead forecasting with statistically tested structural changes, at a cost of a few hundred
+floating-point operations per step.
+
+This package implements **LEBRE v0.52-r1** (canonical configuration) exactly as specified and evaluated in the research
+record https://doi.org/10.5281/zenodo.23049103. In the reference environment (Windows, CPython 3.11, NumPy 2.2.5) the forecasts are bit-for-bit identical to the frozen
+research code; elsewhere they agree up to floating-point rounding, with identical structural decisions in the tests.
+"""
+from .model import Event, Forecast, Lebre
+
+__version__ = "0.1.0"
+ALGORITHM_VERSION = "LEBRE v0.52-r1"
+
+__all__ = ["Lebre", "Forecast", "Event", "__version__", "ALGORITHM_VERSION"]

lebre/_core.py

@@ -0,0 +1,451 @@
+"""Core of LEBRE v0.52-r1 (canonical configuration only).
+
+Extracted from the frozen research implementation `lebre_v052h.LebreV052H` with the canonical configuration
+{scale_floor 0.1, peak_persist, evidence psiE1, lazy_halves, screen_skip_active, track_groups, mu 0.05, stagger,
+screen_spread, peak_split, peak_until 200, chal_warm 250, gap_hold, out_contract}. Branches used only by research
+ablations were removed; every arithmetic expression on the canonical path is kept in the same order, so the forecasts
+are bit-for-bit identical (checked by the regression tests).
+
+The only structural change is that one research `step(x, y)` is split into `predict(x)` (everything computed before
+the target is read) and `observe(y)` (everything after); `step` = `predict` then `observe`.
+"""
+import math
+
+import numpy as np
+
+from ._engine import ChangeEngine
+from ._memory import Memory, MemoryW
+
+POLES = (0.8, 0.95)
+BANDS = ((1, 1), (2, 3), (4, 7), (8, 15), (16, 31))
+
+# canonical constants (identical to the research defaults + canonical configuration)
+M_MAX, M_SLOTS, MU, ALPHA = 4, 2, 0.05, 0.05
+EPS = {"add": 0.002, "swap": 0.002, "rem": -0.002, "split": 0.002}
+CLIP_K, DECIDE_EVERY, N_MIN, T_MAX, COOLDOWN, REM_PERIOD = 2.0, 10, 100, 5000, 2000, 2000
+LAM, ETA, ALPHA_COV, GAMMA_Q, EVERY, CLIP_X = 0.99, 0.5, 0.1, 0.1, 8, 8.0
+CHAL_WARM, SCREEN_EVERY, SCREEN_W, SCREEN_Q, SPLIT_Q, RLS_P0 = 250, 4, 0.02, 15.09, 6.63, 10.0
+PEAK_UNTIL, SCALE_FLOOR, OUT_MARGIN, OUT_RHO = 200, 0.1, 0.5, 1e-3
+
+
+def halves(seg):
+    lo, hi = seg; mid = (lo + hi) // 2
+    return (lo, mid), (mid + 1, hi)
+
+
+class Core:
+    def __init__(self, d, season=None, season2=None):
+        self.ylast = 0.0; self.ym = 0.0; self.yv = 1.0
+        d = d + 1                                                    # the target's own past is one more input
+        self.d, self.L = d, BANDS[-1][1]
+        self.M = MemoryW(season, season2) if season2 else Memory(season)
+        self.quar_until = -1
+        self.y_sm = None; self.y_sv = 0.0; self.n_y = 0
+        self.g_m = np.zeros(d); self.g_c = np.eye(d)
+        self.units = [("in", i) for i in range(d)] + [("res",)]
+        nb = len(BANDS)
+        self.H = np.zeros((self.L + 2, d))                           # H[k] = x_{t-k}
+        self.bs = np.zeros((nb, d))                                  # running sums of the octave bands
+        self.seg = {}                                                # (i, lo, hi) -> running sum of an active segment
+        self.r = np.zeros(len(POLES))
+        self.base = np.zeros(d + 1)
+        self.active = {}                                             # unit -> {"segs": [(lo, hi)...] | None, "w": array}
+        self.contrib_ema = {}
+        self.a_c0 = np.ones(d); self.a_c1 = np.zeros(d); self.res_prev = 0.0
+        self.sc_xy = np.zeros((nb, d)); self.sc_xx = np.ones((nb, d)) * 1e-3; self.sc_yy = np.ones(d)
+        self.sr_xy = np.zeros(len(POLES)); self.sr_xx = np.ones(len(POLES)) * 1e-3; self.sr_yy = 1.0
+        self.sp = {}                                                 # split key -> [xy, xx, yy] EMA
+        self.engine = ChangeEngine(ALPHA, 2 * len(self.units), M_SLOTS, N_MIN, T_MAX)
+        self.last_tested = {}; self.last_rem = {}
+        self.events = []; self.t = 0
+        self.e2 = None; self.sig = 1.0; self.e2r = None; self.sigr = 1.0; self.res2 = None
+        self.D = 0.0; self.wS = 0.5
+        self.qhat = None; self.qacc = 0.0; self.hits_obs = 0; self.hits_ok = 0
+        self.fp = {"memory": 0.0, "structure": 0.0, "experiments": 0.0, "screening": 0.0, "control": 0.0}
+        self.last_obs = None; self.env_hi = None; self.env_lo = None; self.env_m = None; self.env_n = 0; self.n_clipped = 0
+        self._pending = None
+
+    # ---------------- segment sums
+    def _track(self, i, seg):
+        k = (i, seg[0], seg[1])
+        if k not in self.seg:
+            self.seg[k] = float(self.H[seg[0]:seg[1] + 1, i].sum())
+            self.fp["structure"] += seg[1] - seg[0] + 1
+
+    def _mean(self, i, seg):
+        k = (i, seg[0], seg[1])
+        if k in self.seg:
+            return self.seg[k] / (seg[1] - seg[0] + 1)
+        self.fp["structure"] += seg[1] - seg[0] + 1
+        return float(self.H[seg[0]:seg[1] + 1, i].sum()) / (seg[1] - seg[0] + 1)
+
+    def _retrack(self):
+        """keep exactly the active segments as running sums (halves are summed on demand)"""
+        need = set()
+        for u, st in self.active.items():
+            if u[0] == "in":
+                for sg in st["segs"]:
+                    need.add((u[1],) + sg)
+        for k in need:
+            self._track(k[0], k[1:])
+        for k in [k for k in self.seg if k not in need]:
+            del self.seg[k]
+
+    # ---------------- features (values available before y_t)
+    def block(self, unit):
+        if unit[0] == "in":
+            i = unit[1]
+            st = self.active.get(unit)
+            if st is None:
+                return np.array([self.bs[b, i] / (hi - lo + 1) for b, (lo, hi) in enumerate(BANDS)])
+            return np.array([self._mean(i, sg) for sg in st["segs"]])
+        return self.r.copy()
+
+    def cfeat(self, key):
+        if key[0] == "split":
+            i, sg = key[1], key[2:]
+            return np.array([self._mean(i, h) for h in halves(sg)])
+        f = self.block(key)
+        return np.append(f, self.H[0, key[1]]) if key[0] == "in" else f
+
+    def _cf(self, ex):
+        key = ex.add_key
+        if key[0] == "in" and ex.kstar:
+            f = self.cfeat(key)
+            return np.concatenate([f[:-1], [self.H[ex.kstar, key[1]]], f[-1:]])
+        return self.cfeat(key)
+
+    def _seg_contrib(self, key):
+        i, sg = key[1], key[2:]
+        st = self.active[("in", i)]
+        return float(st["w"][st["segs"].index(sg)]) * self._mean(i, sg)
+
+    def response(self, unit):
+        st = self.active[unit]
+        return [(sg, float(w) / (sg[1] - sg[0] + 1)) for sg, w in zip(st["segs"], st["w"])]
+
+    def _struct_pred(self, x):
+        xb = np.concatenate(([1.0], x))
+        s = float(self.base @ xb) + sum(float(st["w"] @ self.block(u)) for u, st in self.active.items())
+        self.fp["structure"] += 2 * (self.d + 1) + sum(3 * len(st["w"]) for st in self.active.values())
+        return s, xb
+
+    def _a(self):
+        return np.clip(self.a_c1 / np.maximum(self.a_c0, 1e-6), -0.999, 0.999)
+
+    def _shift(self, x):
+        self.H = np.roll(self.H, 1, axis=0); self.H[0] = x
+        for b, (lo, hi) in enumerate(BANDS):
+            self.bs[b] += self.H[lo] - self.H[hi + 1]
+        for k in self.seg:
+            i, lo, hi = k
+            self.seg[k] += self.H[lo, i] - self.H[hi + 1, i]
+        self.fp["structure"] += 2 * len(BANDS) * self.d + 2 * len(self.seg)
+
+    # ---------------- one step, split in two halves
+    def predict(self, x):
+        """everything computed before y_t is read; returns the (bounded) forecast"""
+        if self._pending is not None:
+            raise RuntimeError("predict() called twice without observe()")
+        v = self.ylast
+        x = np.append(np.asarray(x, float), (v - self.ym) / math.sqrt(self.yv + 1e-6))
+        dlt = v - self.ym; self.ym += 1e-4 * dlt
+        self.yv = max((1 - 1e-4) * self.yv + 1e-4 * (v - self.ym) * dlt, 1e-4); self.fp["structure"] += 9
+        x = np.nan_to_num(x)
+        if np.any(np.abs(x) > CLIP_X):
+            self.quar_until = self.t + self.L
+        x = np.clip(x, -CLIP_X, CLIP_X)
+        self._shift(x)
+        m = self.M.predict()
+        s, xb = self._struct_pred(x)
+        f = m + self.wS * (s - m)
+        if self.env_n >= 50:
+            w_ = OUT_MARGIN * (self.env_hi - self.env_lo)
+            fc = min(max(f, self.env_lo - w_), self.env_hi + w_) if math.isfinite(f) else self.last_obs
+            self.n_clipped += fc != f; f = fc; self.fp["control"] += 5
+        ref = s
+        outs, rrs = [], []
+        for ex in self.engine.slots:
+            if ex.kind == "split":
+                c = self._seg_contrib(ex.add_key)
+                outs.append(ref - c + float(ex.w @ self._cf(ex))); rrs.append(c)
+                continue
+            a = float(ex.w @ self._cf(ex)) if ex.add_key else 0.0
+            r = float(self.active[ex.rem_key]["w"] @ self.block(ex.rem_key)) if ex.rem_key else 0.0
+            outs.append(ref + a - r); rrs.append(r)
+        self.fp["experiments"] += 6 * len(outs)
+        self._pending = (xb, m, s, f, ref, outs, rrs)
+        return f
+
+    def observe(self, y, quarantine=False):
+        """everything after y_t is read (None or NaN = missing target)"""
+        if self._pending is None:
+            raise RuntimeError("observe() called without a preceding predict()")
+        xb, m, s, f, ref, outs, rrs = self._pending; self._pending = None
+        y_ok = y is not None and np.isfinite(y)
+        mem_learn = y_ok and not quarantine
+        learn = mem_learn and not (self.t <= self.quar_until)
+        if y_ok:
+            e = y - f; er = y - ref
+            self.e2r = er * er if self.e2r is None else self.e2r + (1 - LAM) * (er * er - self.e2r)
+            if self.y_sm is None:
+                self.y_sm = y; self.n_y = 0
+            self.n_y += 1; ry = max(1e-4, 1.0 / self.n_y)
+            dy = y - self.y_sm; self.y_sm += ry * dy; self.y_sv += ry * (dy * (y - self.y_sm) - self.y_sv)
+            floor = SCALE_FLOOR * math.sqrt(max(self.y_sv, 0.0)) if self.t >= 200 else 0.0
+            B = CLIP_K * max(self.sigr, floor)
+            self.fp["control"] += 8
+            lf = min(er * er / (B * B), 1.0)
+            res = y - s
+            if learn:
+                for ex, g, back in zip(self.engine.slots, outs, rrs):
+                    ex.k += 1
+                    if ex.k > CHAL_WARM or not ex.add_key:
+                        ex.observe(lf - min((y - g) ** 2 / (B * B), 1.0) - ex.eps)
+                    if ex.add_key:                                   # RLS on the residual the change would explain
+                        rr = res + back
+                        if ex.add_key[0] == "in" and ex.k <= PEAK_UNTIL:
+                            self._peak_stats(ex, rr)
+                        fx = self._cf(ex)
+                        lam_ = 1.0
+                        Pf = ex.P @ fx; kg = Pf / (lam_ + fx @ Pf)
+                        ex.w = ex.w + kg * (rr - ex.w @ fx); ex.P = (ex.P - np.outer(kg, Pf)) / lam_
+                        self.fp["experiments"] += 4 * len(fx) ** 2 + 6 * len(fx)
+                self.fp["experiments"] += 8 * len(outs)
+                blocks = {u: self.block(u) for u in self.active}
+                bpow = sum(float(b @ b) for b in blocks.values())
+                den = float(xb @ xb) + bpow + 1e-6
+                g_ = MU * res / den
+                self.base += g_ * xb
+                for u, b in blocks.items():
+                    st = self.active[u]; st["w"] = st["w"] + g_ * b
+                    c = abs(float(st["w"] @ b))
+                    self.contrib_ema[u] = c if u not in self.contrib_ema else self.contrib_ema[u] + 0.01 * (c - self.contrib_ema[u])
+                self.fp["structure"] += 4 * (len(xb) + sum(len(b) for b in blocks.values())) + 4
+                self._screen_spread(res)
+                self.res_prev = res
+                self.res2 = res * res if self.res2 is None else self.res2 + (1 - LAM) * (res * res - self.res2)
+            es, em = y - s, y - m
+            self.D = LAM * self.D + (es * es - em * em) / (self.sig ** 2 + 1e-12)
+            self.fp["control"] += 7
+            if self.t % EVERY == 0:
+                z = ETA * self.D
+                self.wS = 1.0 / (1.0 + math.exp(z)) if z < 700 else 0.0
+                self.fp["control"] += 4
+            self.e2 = e * e if self.e2 is None else self.e2 + (1 - LAM) * (e * e - self.e2)
+            if self.qhat is None:
+                self.qhat = 1.645 * math.sqrt(self.e2)
+            miss = 1.0 if abs(e) > self.qhat else 0.0
+            self.hits_obs += 1; self.hits_ok += miss == 0.0
+            self.qacc += miss - ALPHA_COV
+            if self.t % EVERY == 0:
+                self.sig = math.sqrt(max(self.e2, 1e-300)); self.sigr = math.sqrt(max(self.e2r, 1e-300))
+                self.qhat = max(0.0, self.qhat + GAMMA_Q * self.sig * self.qacc); self.qacc = 0.0
+            self.fp["control"] += 10
+            u_ = e / self.sig
+        else:
+            u_ = 0.0
+        if not y_ok and self.last_obs is not None:
+            self.M.update(self.last_obs, m, learn=False)             # hold: history gets the last observed value
+        else:
+            self.M.update(y if y_ok else None, m, learn=mem_learn)
+        if y_ok:
+            self.last_obs = float(y)
+            if self.env_hi is None:
+                self.env_hi = self.env_lo = self.env_m = float(y)
+            self.env_n += 1; r_ = OUT_RHO
+            self.env_m += max(r_, 1.0 / self.env_n) * (y - self.env_m)
+            self.env_hi = max(float(y), self.env_hi - r_ * (self.env_hi - self.env_m))
+            self.env_lo = min(float(y), self.env_lo - r_ * (self.env_lo - self.env_m))
+            self.fp["control"] += 10
+        if y_ok:
+            self.ylast = float(y)
+        self.r = np.array(POLES) * self.r + (1 - np.array(POLES)) * u_
+        self.fp["structure"] += 3 * len(POLES)
+        if self.t % DECIDE_EVERY == 0 and self.t > 0:
+            self._decide()
+        self.t += 1
+
+    def _peak_stats(self, ex, rr):
+        i = ex.add_key[1]; a = self._a()[i]
+        u = self.H[1:self.L + 1, i] - a * self.H[2:self.L + 2, i]       # prewhitened lags 1..L
+        pr = rr - a * getattr(ex, "rprev", 0.0); ex.rprev = rr
+        if getattr(ex, "cxy", None) is None:
+            prev = ex.hyp.peak_stats
+            if prev is not None:
+                ex.cxy, ex.cxx = prev
+            else:
+                ex.cxy = np.zeros(self.L); ex.cxx = np.full(self.L, 1e-9)
+            ex.hyp.peak_stats = (ex.cxy, ex.cxx)                        # same arrays: updated in place
+        msk = (np.arange(self.L) + ex.k) % 2 == 0
+        ex.cxy[msk] += pr * u[msk]; ex.cxx[msk] += u[msk] * u[msk]
+        self.fp["experiments"] += 3 * self.L + 4
+        if ex.k == PEAK_UNTIL:
+            k = int(np.argmax(ex.cxy ** 2 / ex.cxx)) + 1
+            if k > 1:                                                   # lag 1 is already its own band
+                ex.kstar = k
+                n = len(ex.w)
+                w = np.insert(ex.w, n - 1, 0.0)
+                P = np.insert(np.insert(ex.P, n - 1, 0.0, axis=0), n - 1, 0.0, axis=1); P[n - 1, n - 1] = RLS_P0
+                ex.w, ex.P = w, P
+
+    # ---------------- screening (each part on its own phase, every SCREEN_EVERY steps)
+    def _screen_spread(self, res):
+        w, se, t = SCREEN_W, SCREEN_EVERY, self.t
+        act = {u[1] for u in self.active if u[0] == "in"}
+        due = [i for i in range(self.d) if (t + i) % se == 0]
+        x, x1, ra = self.H[0], self.H[1], 1e-3 * se
+        for i in due:
+            self.a_c0[i] += ra * (x[i] * x[i] - self.a_c0[i]); self.a_c1[i] += ra * (x[i] * x1[i] - self.a_c1[i])
+            self.fp["screening"] += 6
+            if i in act:
+                continue
+            a = float(self._a()[i]); pres = res - a * self.res_prev
+            for b, (lo, hi) in enumerate(BANDS):
+                ub = (self.bs[b, i] - a * (self.bs[b, i] - self.H[lo, i] + self.H[hi + 1, i])) / (hi - lo + 1)
+                self.sc_xy[b, i] += w * (pres * ub - self.sc_xy[b, i]); self.sc_xx[b, i] += w * (ub * ub - self.sc_xx[b, i])
+            self.sc_yy[i] += w * (pres * pres - self.sc_yy[i])
+            self.fp["screening"] += 11 * len(BANDS) + 5
+        if t % se == self.d % se:                                   # residual latent unit
+            self.sr_xy += w * (res * self.r - self.sr_xy); self.sr_xx += w * (self.r * self.r - self.sr_xx)
+            self.sr_yy += w * (res * res - self.sr_yy); self.fp["screening"] += 12 * len(POLES)
+        if t % se == (self.d + 1) % se:                             # equivalence groups (reporting only)
+            gw = 1e-3 * se
+            self.g_m += gw * (x - self.g_m); xc = x - self.g_m
+            self.g_c += gw * (np.outer(xc, xc) - self.g_c)
+            self.fp["screening"] += 3 * self.d * (self.d + 1) // 2 + 2 * self.d
+        for j, key in enumerate(self.split_keys()):
+            if (t + j) % se:
+                continue
+            i, sg = key[1], key[2:]
+            l_, r_ = halves(sg); dv = self._mean(i, l_) - self._mean(i, r_)
+            st = self.sp.setdefault(key, [0.0, 1e-3, 1.0])
+            st[0] += w * (res * dv - st[0]); st[1] += w * (dv * dv - st[1]); st[2] += w * (res * res - st[2])
+            self.fp["screening"] += 14
+
+    def equivalents(self, unit, thr=0.95):
+        if unit[0] != "in":
+            return set()
+        i = unit[1]; sd = np.sqrt(np.maximum(np.diag(self.g_c), 1e-12))
+        r = np.abs(self.g_c[i]) / (sd[i] * sd)
+        return {int(j) for j in np.flatnonzero(r >= thr)}
+
+    def split_keys(self):
+        out = []
+        for u, st in self.active.items():
+            if u[0] == "in":
+                out += [("split", u[1]) + sg for sg in st["segs"] if sg[1] > sg[0]]
+        return out
+
+    def screen_stat(self, key):
+        k = SCREEN_W / (2 - SCREEN_W)
+        if key[0] == "split":
+            st = self.sp.get(key)
+            return 0.0 if st is None else st[0] ** 2 / (st[1] * st[2] + 1e-12) / k
+        if key[0] == "in":
+            i = key[1]
+            c2 = self.sc_xy[:, i] ** 2 / (self.sc_xx[:, i] * self.sc_yy[i] + 1e-12)
+        else:
+            c2 = self.sr_xy ** 2 / (self.sr_xx * self.sr_yy + 1e-12)
+        return float(c2.sum()) / k
+
+    # ---------------- lifecycle
+    @staticmethod
+    def unit_of(key):
+        return ("in", key[1]) if key[0] == "split" else key
+
+    def _open(self, kind, add_key, rem_key):
+        hkey = ("out", rem_key) if kind == "rem" else ("in", add_key)
+        ex = self.engine.open(kind, add_key, rem_key, hkey, EPS[kind], self.t)
+        if add_key:
+            n_ = len(self.cfeat(add_key)); ex.w = np.zeros(n_); ex.P = RLS_P0 * np.eye(n_)
+            if kind == "split":                                      # start from the parent's weight on both halves
+                st = self.active[self.unit_of(add_key)]
+                ex.w[:] = float(st["w"][st["segs"].index(add_key[2:])])
+        for k in (add_key, rem_key):
+            if k:
+                self.last_tested[k] = self.t
+
+    def _decide(self):
+        changed = set()
+        for decision, ex, le in self.engine.review():
+            if decision == "accepted":
+                self._accept(ex, le)
+                changed |= {self.unit_of(k) for k in (ex.add_key, ex.rem_key) if k}
+            else:
+                self.events.append((self.t, "closed", ex.kind, ex.add_key, ex.rem_key, round(le, 2), ex.n))
+        if changed:   # experiments about units that just changed no longer describe the live model
+            keep = []
+            for ex in self.engine.slots:
+                if {self.unit_of(k) for k in (ex.add_key, ex.rem_key) if k} & changed:
+                    self.events.append((self.t, "superseded", ex.kind, ex.add_key, ex.rem_key, None, ex.n))
+                else:
+                    keep.append(ex)
+            self.engine.slots = keep
+            self._retrack()
+            self.sp = {k: v for k, v in self.sp.items() if k in set(self.split_keys())}
+        self._fill()
+
+    def _accept(self, ex, le):
+        if ex.kind == "split":
+            u = self.unit_of(ex.add_key); st = self.active[u]; sg = ex.add_key[2:]
+            j = st["segs"].index(sg); l_, r_ = halves(sg)
+            st["segs"] = st["segs"][:j] + [l_, r_] + st["segs"][j + 1:]
+            st["w"] = np.concatenate([st["w"][:j], ex.w, st["w"][j + 1:]])
+            merged = {}                                              # a half equal to the peak segment: one weight
+            for sg_, w_ in zip(st["segs"], st["w"]):
+                merged[sg_] = merged.get(sg_, 0.0) + float(w_)
+            st["segs"], st["w"] = list(merged), np.array(list(merged.values()))
+        else:
+            if ex.rem_key and ex.rem_key in self.active:
+                del self.active[ex.rem_key]; self.contrib_ema.pop(ex.rem_key, None)
+            if ex.add_key:
+                if ex.add_key[0] == "in":
+                    segs = list(BANDS) + ([(ex.kstar, ex.kstar)] if ex.kstar else [])
+                    self.active[ex.add_key] = {"segs": segs, "w": ex.w[:-1].copy()}
+                    self.base[1 + ex.add_key[1]] += float(ex.w[-1])
+                else:
+                    self.active[ex.add_key] = {"segs": None, "w": ex.w.copy()}
+        self.engine.consume(ex)
+        self._retrack()
+        self.events.append((self.t, "accepted", ex.kind, ex.add_key, ex.rem_key, round(le, 2), ex.hyp.n))
+
+    def _fill(self):
+        busy = {self.unit_of(k) for k in self.engine.busy_keys()}
+        while self.engine.free_slots() > 0:
+            due = [a for a in self.active if a not in busy and self.t - self.last_rem.get(a, -10 ** 9) >= REM_PERIOD
+                   and self.t - self.last_tested.get(a, -10 ** 9) >= N_MIN]
+            if due:
+                a = due[0]; self.last_rem[a] = self.t; self._open("rem", None, a); busy.add(a); continue
+            if any(ex.add_key and ex.k <= CHAL_WARM for ex in self.engine.slots):
+                break                                                # one warm-up at a time
+            cands = []
+            pool = [u for u in self.units if u not in self.active and u not in busy
+                    and self.t - self.last_tested.get(u, -10 ** 9) >= COOLDOWN]
+            if pool:
+                c = max(pool, key=self.screen_stat)
+                if self.screen_stat(c) >= SCREEN_Q:
+                    cands.append((self.screen_stat(c) / SCREEN_Q, "unit", c))
+            sp = [k for k in self.split_keys() if self.unit_of(k) not in busy
+                  and self.t - self.last_tested.get(k, -10 ** 9) >= COOLDOWN]
+            if sp:
+                c = max(sp, key=self.screen_stat)
+                if self.screen_stat(c) >= SPLIT_Q:
+                    cands.append((self.screen_stat(c) / SPLIT_Q, "split", c))
+            if not cands:
+                break
+            _, typ, c = max(cands)
+            if typ == "split":
+                self._open("split", c, None)
+            elif len(self.active) < M_MAX:
+                self._open("add", c, None)
+            else:
+                a = min((k for k in self.active if k not in busy), key=lambda k: self.contrib_ema.get(k, float("inf")), default=None)
+                if a is None:
+                    break
+                self._open("swap", c, a); busy.add(a)
+            busy.add(self.unit_of(c))
+            self.fp["control"] += (len(self.units) + len(self.sp)) / DECIDE_EVERY
+
+    def fp_total(self):
+        return sum(self.fp.values()) + self.M.fp + self.engine.fp

lebre/_engine.py

@@ -0,0 +1,105 @@
+"""Evidence engine of LEBRE v0.52-r1: persistent hypotheses with a one-sided sub-exponential mixture e-process,
+e-LOND-type acceptance levels fixed at creation, and experiment slots closed by a scan rule.
+
+Extracted from the frozen research implementation (change_engine.py, evidence="psiE1"); arithmetic is unchanged.
+"""
+import math
+
+import numpy as np
+
+
+def _gamma_const(n=10 ** 6):
+    k = np.arange(1, n + 1, dtype=float)
+    s = float(np.sum(1.0 / (k * np.log(k + 1) ** 2)))
+    return 1.0 / (s + 1.0 / math.log(n + 1))          # tail bound of the integral
+
+
+GAMMA_C = _gamma_const()
+
+
+def gamma_k(k):
+    return GAMMA_C / (k * math.log(k + 1) ** 2)
+
+
+class Hypothesis:
+    """Weak null: over the steps at which this change was tested, the challenger did not improve the clipped loss of the
+    reference by more than eps on average. One-sided mixture e-process with c = 1 + max(eps, 0) and predictable
+    centring gamma_i = min(past mean, 0) (valid because d_i - gamma_i >= -c)."""
+    LAMBDAS_FRAC = 0.9 * 2.0 ** -np.arange(8)            # lambda grid as a fraction of 1/c (uniform mixture)
+
+    def __init__(self, eps, alpha_level, idx):
+        self.eps = eps
+        self.c = 1.0 + max(eps, 0.0)
+        self.alpha = alpha_level; self.log_thr = math.log(1.0 / alpha_level); self.idx = idx
+        self.S = 0.0; self.V = 0.0; self.n = 0; self.mean = 0.0
+        self.lam = self.LAMBDAS_FRAC / self.c
+        self.psi = (-np.log(1 - self.c * self.lam) - self.c * self.lam) / self.c ** 2
+        self.peak_stats = None
+
+    def observe(self, d):
+        gamma = max(-self.c, min(0.0, self.mean))
+        self.S += d; self.V += (d - gamma) ** 2; self.n += 1
+        dm = d - self.mean; self.mean += dm / self.n
+
+    def log_e(self):
+        a = self.lam * self.S - self.psi * self.V
+        m = a.max()
+        return float(m + math.log(np.mean(np.exp(a - m))))
+
+
+class Experiment:
+    """One episode on a slot; evidence goes to the persistent hypothesis. The challenger's parameters (w, P, k, kstar)
+    are owned and updated by the model."""
+
+    def __init__(self, kind, add_key, rem_key, hyp, t0):
+        self.kind, self.add_key, self.rem_key, self.hyp, self.t0 = kind, add_key, rem_key, hyp, t0
+        self.S = 0.0; self.n = 0; self.k = 0; self.kstar = None
+        self.eps = hyp.eps
+
+    def observe(self, d):
+        self.hyp.observe(d); self.S += d; self.n += 1
+
+
+class ChangeEngine:
+    def __init__(self, alpha, family_size, m_slots, n_min, T_max):
+        self.alpha, self.P, self.m_slots, self.n_min, self.T_max = alpha, family_size, m_slots, n_min, T_max
+        self.hyps = {}; self.n_hyp = 0; self.n_accepted = 0; self.k_started = 0
+        self.slots = []; self.fp = 0.0
+
+    def hypothesis(self, hkey, eps):
+        if hkey not in self.hyps:
+            self.n_hyp += 1
+            g = 1.0 / (2 * self.P) if self.n_hyp <= self.P else 0.5 * gamma_k(self.n_hyp - self.P)   # sum <= 1
+            self.hyps[hkey] = Hypothesis(eps, min(self.alpha * g * (self.n_accepted + 1), 0.5), self.n_hyp)
+        return self.hyps[hkey]
+
+    def open(self, kind, add_key, rem_key, hkey, eps, t):
+        self.k_started += 1
+        ex = Experiment(kind, add_key, rem_key, self.hypothesis(hkey, eps), t)
+        self.slots.append(ex)
+        return ex
+
+    def free_slots(self):
+        return self.m_slots - len(self.slots)
+
+    def review(self):
+        """[(decision, experiment, log_e)] with decision in {'accepted', 'closed'}; keeps the others running."""
+        out, keep = [], []
+        for ex in self.slots:
+            le = ex.hyp.log_e(); self.fp += 3 * len(ex.hyp.lam)
+            if le >= ex.hyp.log_thr:
+                out.append(("accepted", ex, le))
+            elif ex.n >= self.T_max or (ex.n >= self.n_min and ex.S <= 0.0):   # scan rule: not ahead -> free the slot
+                out.append(("closed", ex, le))
+            else:
+                keep.append(ex)
+        self.slots = keep
+        return out
+
+    def consume(self, ex):
+        """an accepted change: count the discovery and retire its hypothesis (a new instance if ever retested)."""
+        self.n_accepted += 1
+        self.hyps = {k: h for k, h in self.hyps.items() if h is not ex.hyp}
+
+    def busy_keys(self):
+        return {k for ex in self.slots for k in (ex.add_key, ex.rem_key) if k}

lebre/_memory.py

@@ -0,0 +1,70 @@
+"""Memory expert M of LEBRE v0.52-r1: forecast of the target from its own past, relative to the last value
+(mean reversion, last difference, seasonal naive and one-cycle increment, per-phase profile of increments, optional
+second declared cycle), learned by NLMS with scale-relative floors.
+
+Extracted from the frozen research implementation (lebre_v052.Memory and lebre_v052h.MemoryW); arithmetic is unchanged.
+"""
+import numpy as np
+
+
+class Memory:
+    def __init__(self, season=None, mu=0.05, a_prof=0.1, a_mean=0.01, eps_rel=1e-3):
+        self.s, self.mu, self.ap, self.am, self.eps_rel = season, mu, a_prof, a_mean, eps_rel
+        self.feats = ("mean", "d1", "sn", "si", "prof") if season else ("mean", "d1")
+        self.Lb = 2 * season + 2 if season else 3
+        self.buf = np.zeros(self.Lb); self.n = 0
+        self.mew = None; self.G = np.zeros(season) if season else None
+        self.w = np.zeros(len(self.feats)); self.phi = None; self.pp_ema = None; self.y2 = None; self.fp = 0.0
+
+    def _b(self, k):
+        return self.buf[(self.n - k) % self.Lb]
+
+    def predict(self):
+        if self.n < self.Lb:
+            self.phi = None
+            return self._b(1) if self.n else 0.0
+        last, s = self._b(1), self.s
+        v = [(self.mew - last) if self.mew is not None else 0.0, last - self._b(2)]
+        if s:
+            v += [self._b(s) - last, self._b(s - 1) - self._b(s), self.G[self.n % s]]
+        self.phi = np.array(v); self.fp += 3 * len(v) + 1
+        return last + float(self.w @ self.phi)
+
+    def update(self, y, y_hat, learn=True):
+        if y is None or not np.isfinite(y):
+            y, learn = y_hat, False
+        if learn and self.phi is not None:
+            pp = float(self.phi @ self.phi)
+            self.pp_ema = pp if self.pp_ema is None else self.pp_ema + 0.01 * (pp - self.pp_ema)
+            self.y2 = y * y if self.y2 is None else self.y2 + 1e-4 * (y * y - self.y2)
+            den = pp + self.eps_rel * self.pp_ema + 1e-4 * self.y2
+            if den > 0:
+                self.w += (self.mu * (y - y_hat) / den) * self.phi; self.fp += 4 * len(self.w) + 6
+        if learn and self.s and self.n >= 1:
+            ph = self.n % self.s; self.G[ph] += self.ap * ((y - self._b(1)) - self.G[ph]); self.fp += 4
+        if learn:
+            self.mew = y if self.mew is None else self.mew + self.am * (y - self.mew); self.fp += 3
+        self.buf[self.n % self.Lb] = y; self.n += 1
+
+
+class MemoryW(Memory):
+    """memory with a second declared cycle (e.g. the week, 168 h, on top of the day, 24 h)"""
+
+    def __init__(self, season, season2, **kw):
+        super().__init__(season, **kw)
+        self.s2 = season2
+        self.feats = self.feats + ("sn2", "si2")
+        self.Lb = max(self.Lb, season2 + 2)
+        self.buf = np.zeros(self.Lb); self.w = np.zeros(len(self.feats))
+
+    def predict(self):
+        if self.n < self.Lb:
+            self.phi = None
+            return self._b(1) if self.n else 0.0
+        last, s = self._b(1), self.s
+        v = [(self.mew - last) if self.mew is not None else 0.0, last - self._b(2)]
+        if s:
+            v += [self._b(s) - last, self._b(s - 1) - self._b(s), self.G[self.n % s]]
+        v += [self._b(self.s2) - last, self._b(self.s2 - 1) - self._b(self.s2)]
+        self.phi = np.array(v); self.fp += 3 * len(v) + 1
+        return last + float(self.w @ self.phi)

lebre/model.py

@@ -0,0 +1,188 @@
+"""Public API of the LEBRE online forecaster (implements LEBRE v0.52-r1)."""
+from __future__ import annotations
+
+import math
+import pickle
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Sequence
+
+import numpy as np
+
+from ._core import Core
+
+_FORMAT = "lebre-state"
+_FORMAT_VERSION = 1
+
+
+@dataclass(frozen=True)
+class Forecast:
+    """One-step-ahead forecast issued before the target of that step is observed."""
+    value: float
+    lower: float          # lower bound of the adaptive 90% interval (NaN until the interval is initialised)
+    upper: float          # upper bound of the adaptive 90% interval
+    t: int                # step index (0-based)
+
+
+@dataclass(frozen=True)
+class Event:
+    """Audit record of one structural experiment outcome."""
+    t: int                # step at which the decision was taken
+    outcome: str          # "accepted", "closed" (not accepted; evidence kept) or "superseded"
+    change: str           # "add", "remove", "swap" or "split"
+    added: Optional[str]  # unit that enters (None for a removal)
+    removed: Optional[str]  # unit that leaves (None unless remove/swap)
+    log_evidence: Optional[float]  # log of the e-process at the decision
+    samples: int          # evidence samples behind the decision
+
+
+class _CausalScaler:
+    """Causal exponential standardiser used in every LEBRE evaluation (rate 1e-4, from mean 0 / variance 1).
+    Missing input values (NaN) are passed on as missing and do not update the statistics."""
+
+    def __init__(self, d, alpha=1e-4, eps=1e-6):
+        self.alpha, self.eps = float(alpha), float(eps)
+        self.mean = np.zeros(d, dtype=np.float64); self.var = np.ones(d, dtype=np.float64)
+
+    def transform(self, x):
+        return (x - self.mean) / np.sqrt(self.var + self.eps)
+
+    def update(self, x):
+        ok = np.isfinite(x)
+        if ok.all():
+            delta = x - self.mean
+            self.mean += self.alpha * delta
+            self.var = (1.0 - self.alpha) * self.var + self.alpha * (x - self.mean) * delta
+            self.var = np.maximum(self.var, 1e-4)
+        else:
+            delta = np.where(ok, x - self.mean, 0.0)
+            new_mean = self.mean + self.alpha * delta
+            new_var = np.maximum((1.0 - self.alpha) * self.var + self.alpha * (np.where(ok, x, 0.0) - new_mean) * delta, 1e-4)
+            self.mean = np.where(ok, new_mean, self.mean); self.var = np.where(ok, new_var, self.var)
+
+
+class Lebre:
+    """Online one-step-ahead forecaster for a target driven by exogenous inputs.
+
+    Parameters
+    ----------
+    n_inputs : number of exogenous inputs (the target's own past is added internally).
+    season : period of the declared cycle in steps (e.g. 24 for hourly data with a daily cycle), or None.
+    season2 : optional second declared cycle (e.g. 168 for the weekly cycle of hourly building data), or None.
+    standardize : standardise the inputs causally (the evaluated configuration). Set False only if the inputs are
+        already standardised by the caller with past-only statistics.
+
+    Usage: for each step, ``f = model.predict(x)`` with the current inputs, then ``model.observe(y)`` once the target
+    is known (``None``/NaN for a missing target). ``step(x, y)`` does both. Every structural change is recorded in
+    ``events``.
+    """
+
+    def __init__(self, n_inputs: int, season: Optional[int] = None, season2: Optional[int] = None, standardize: bool = True):
+        if n_inputs < 1:
+            raise ValueError("n_inputs must be >= 1")
+        self.n_inputs, self.season, self.season2, self.standardize = int(n_inputs), season, season2, bool(standardize)
+        self._core = Core(self.n_inputs, season=season, season2=season2)
+        self._scaler = _CausalScaler(self.n_inputs) if standardize else None
+        self._last: Optional[Forecast] = None
+
+    # ------------------------------------------------------------------ stepping
+    def predict(self, x: Sequence[float]) -> Forecast:
+        """Forecast of the current target from the current inputs x (length n_inputs)."""
+        x = np.asarray(x, dtype=np.float64).reshape(-1)
+        if x.shape[0] != self.n_inputs:
+            raise ValueError(f"expected {self.n_inputs} inputs, got {x.shape[0]}")
+        if self._scaler is not None:
+            xs = self._scaler.transform(x); self._scaler.update(x)
+        else:
+            xs = x
+        c = self._core
+        q = c.qhat
+        f = c.predict(xs)
+        lo, hi = (f - q, f + q) if q is not None else (math.nan, math.nan)
+        self._last = Forecast(float(f), float(lo), float(hi), c.t)
+        return self._last
+
+    def observe(self, y: Optional[float], quarantine: bool = False) -> None:
+        """Reveal the target of the step just predicted. y = None or NaN marks a missing target; quarantine=True
+        marks a value that must not be learned from (e.g. flagged by the data source)."""
+        self._core.observe(None if y is None else float(y), quarantine=bool(quarantine))
+
+    def step(self, x: Sequence[float], y: Optional[float], quarantine: bool = False) -> Forecast:
+        """predict(x) then observe(y); returns the forecast made before y was used."""
+        f = self.predict(x)
+        self.observe(y, quarantine)
+        return f
+
+    # ------------------------------------------------------------------ audit and structure
+    def unit_name(self, key) -> str:
+        if key is None:
+            return None
+        if key[0] == "in":
+            return "own_past" if key[1] == self.n_inputs else f"x{key[1]}"
+        if key[0] == "res":
+            return "residual_state"
+        if key[0] == "split":
+            base = "own_past" if key[1] == self.n_inputs else f"x{key[1]}"
+            return f"{base}[{key[2]}-{key[3]}]"
+        return str(key)
+
+    @property
+    def events(self) -> list:
+        kind = {"add": "add", "rem": "remove", "swap": "swap", "split": "split"}
+        return [Event(int(t), out, kind[k], self.unit_name(a), self.unit_name(r), le, int(n))
+                for t, out, k, a, r, le, n in self._core.events]
+
+    @property
+    def structure(self) -> list:
+        """active units: names of the inputs (x0, x1, ..., own_past) and/or residual_state"""
+        return [self.unit_name(u) for u in sorted(self._core.active)]
+
+    def response(self, unit: str) -> list:
+        """recovered response of an active input: [((lag_lo, lag_hi), weight per lag), ...] in standardised units"""
+        for u in self._core.active:
+            if self.unit_name(u) == unit and u[0] == "in":
+                return self._core.response(u)
+        raise KeyError(f"{unit} is not an active input")
+
+    def equivalent_inputs(self, unit: str) -> list:
+        """inputs whose causal correlation with `unit` is >= 0.95 (the accepted input may stand for any of them)"""
+        for u in self._core.units:
+            if self.unit_name(u) == unit:
+                return [self.unit_name(("in", j)) for j in sorted(self._core.equivalents(u))]
+        raise KeyError(unit)
+
+    @property
+    def n_steps(self) -> int:
+        return self._core.t
+
+    @property
+    def coverage(self) -> float:
+        """empirical coverage of the 90% interval so far"""
+        c = self._core
+        return c.hits_ok / c.hits_obs if c.hits_obs else math.nan
+
+    @property
+    def cost_per_step(self) -> float:
+        """mean analytic floating-point operations per step so far (operation-count model of the research code)"""
+        return self._core.fp_total() / self._core.t if self._core.t else math.nan
+
+    # ------------------------------------------------------------------ persistence
+    def save(self, path) -> None:
+        """Save the full state (pickle). Only load files you trust: unpickling can execute code."""
+        with open(Path(path), "wb") as fh:
+            pickle.dump({"format": _FORMAT, "version": _FORMAT_VERSION, "model": self}, fh, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls, path) -> "Lebre":
+        """Load a state saved by `save`. Only load files you trust: unpickling can execute code."""
+        with open(Path(path), "rb") as fh:
+            obj = pickle.load(fh)
+        if not isinstance(obj, dict) or obj.get("format") != _FORMAT:
+            raise ValueError("not a LEBRE state file")
+        if obj.get("version") != _FORMAT_VERSION:
+            raise ValueError(f"unsupported state format version {obj.get('version')}")
+        return obj["model"]
+
+    def __repr__(self):
+        return (f"Lebre(n_inputs={self.n_inputs}, season={self.season}, season2={self.season2}, "
+                f"steps={self.n_steps}, structure={self.structure})")

lebre-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.5
+Name: lebre
+Version: 0.1.0
+Summary: Online one-step-ahead forecasting with statistically tested structural changes, at a cost of a few hundred operations per step (implements LEBRE v0.52-r1).
+Project-URL: Source, https://github.com/Iquitim/lebre
+Project-URL: Issues, https://github.com/Iquitim/lebre/issues
+Project-URL: Research record, https://github.com/Iquitim/lebre-research
+Project-URL: Research DOI, https://doi.org/10.5281/zenodo.23049103
+Author: Silvano Lima
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: TinyML,anytime-valid inference,e-process,exogenous inputs,online forecasting,time series
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# lebre
+
+[![tests](https://github.com/Iquitim/lebre/actions/workflows/tests.yml/badge.svg)](https://github.com/Iquitim/lebre/actions/workflows/tests.yml)
+
+Online one-step-ahead forecasting for a target driven by exogenous inputs, with **statistically tested structural changes**, at a cost of a few hundred floating-point operations per step.
+
+`lebre 0.1.0` implements **LEBRE v0.52-r1**, the frozen research version documented and evaluated in the research record:
+- repository: https://github.com/Iquitim/lebre-research
+- DOI: [10.5281/zenodo.23049103](https://doi.org/10.5281/zenodo.23049103)
+
+The package reproduces the research code **bit for bit in the reference environment** (Windows, CPython 3.11, NumPy 2.2.5), checked against references generated from the frozen code and on real evaluation series in the research repository. On other platforms and NumPy versions, floating-point rounding differs in the last bits (~1e-14): the regression tests then require identical structural decisions and forecasts equal within 1e-9 of their scale.
+
+```bash
+pip install lebre
+```
+
+## Usage
+
+```python
+from lebre import Lebre
+
+model = Lebre(n_inputs=3, season=24)        # season: declared cycle in steps (None if there is none)
+for x_t, y_t in stream:                     # x_t: current inputs (length 3), y_t: target (None/NaN if missing)
+    f = model.predict(x_t)                  # Forecast(value, lower, upper, t), issued before y_t is known
+    model.observe(y_t)
+    # or: f = model.step(x_t, y_t)
+
+model.structure                             # e.g. ['x0', 'own_past']
+model.response("x0")                        # recovered lag response: [((lag_lo, lag_hi), weight per lag), ...]
+model.events                                # audit log: Event(t, outcome, change, added, removed, log_evidence, samples)
+model.equivalent_inputs("x0")               # inputs indistinguishable from x0 (causal correlation >= 0.95)
+model.coverage, model.cost_per_step         # empirical 90%-interval coverage; analytic operations per step
+model.save("state.pkl"); model = Lebre.load("state.pkl")   # pickle: load only files you trust
+```
+
+See `examples/quickstart.py`.
+
+## What it does
+
+- **Live model:**
+  - a memory of the target's own past: level, declared cycle(s), per-phase profile;
+  - a linear regression on the current inputs;
+  - the two combined by dynamic model averaging.
+- **Structural changes run in shadow as experiments:** adding, removing or swapping a whole input, or refining its lag response by hierarchical splits of octave bands.
+- **Acceptance:** a change is accepted only when an anytime-valid e-process of predictive improvement crosses a level fixed by an online multiple-testing rule.
+- **Output safeguards:** target gaps are held (never filled with the model's own forecasts), and forecasts stay within an envelope of the observed values.
+- **Inputs:** they are standardised causally inside the model; set `standardize=False` only if you already do this with past-only statistics.
+
+## Scope and limits
+
+These are the limits of the evaluated version, stated honestly (details in the specification, §19):
+- evaluated on hydrology and building-energy series with 1–5 inputs, one step ahead;
+- it is **not** meant to be the most accurate forecaster: in the evaluations it tied a SARIMAX with inputs fitted per series and had ~25% higher error than Chronos-2 with covariates, at a tiny fraction of the cost;
+- the testing mechanism does not improve accuracy over switching all inputs on; its role is an audited, evidence-backed structure;
+- an accepted input means *it improved the forecast of the current model, with evidence*, not *it is the cause*: correlated substitutes can be accepted, and near-identical inputs are indistinguishable;
+- the e-values are valid under the stated assumptions; false-change control with the adaptive reference was verified empirically;
+- delays of very smooth inputs are often not discovered (information limit), though forecasts remain good;
+- the declared cost contract of the research version (mean ≤ 400, peak ≤ 1,000 operations per step) was narrowly not met.
+
+## Licence
+
+Apache-2.0. If you use it, please cite the research record (`CITATION.cff`).

lebre-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lebre/__init__.py,sha256=oZhnNgJrPezqjVmuxn-CnujBZg6GNceYfQu-M6x6NMw,746
+lebre/_core.py,sha256=OCmV4uvtG076uuo2_GPrI0LNYanbxlAHoY8-lBIDrf4,22735
+lebre/_engine.py,sha256=JYXu-XgjC4VPS4PGHnThlJppCwmd2xFHgBZQdkXIfKs,4294
+lebre/_memory.py,sha256=6tBnXjsw2DnfEqgZ4H-6zCMDmlTVYboPBP3CMKdf8nc,3362
+lebre/model.py,sha256=4eNh1ki9vOcRC79BoAg15iKBwdzo5W2yuFsiWKr_DS0,8825
+lebre/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lebre-0.1.0.dist-info/METADATA,sha256=BeHza04SMYQ7TY66tR6SurFzeabRRICnHyy5zke0oM4,5260
+lebre-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lebre-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+lebre-0.1.0.dist-info/RECORD,,

lebre-0.1.0.dist-info/WHEEL

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

lebre-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.