ebin 1.0__py3-none-any.whl

ebin/pipeline.py

@@ -0,0 +1,173 @@
+"""End-to-end driver: fit every cell line, read out the activity, write tables."""
+
+import os
+import pickle
+import time
+
+import numpy as np
+import pandas as pd
+
+from .data import load_groups, prep
+from .fit import fit_effects
+from .initialize import init_from_fit
+from .activity import posterior_activity
+
+# every per-object scalar the readout produces; all of it goes to the table
+TABLE_FIELDS = ("activity", "activity_sd", "activity_map",
+                "mu", "mu_sd", "sigma", "sigma_sd", "q1", "q2", "q3",
+                "abundance", "n_eff", "tot")
+
+FIELD_DESC = {
+    "activity": "posterior-mean E[bin] (the activity target)",
+    "activity_sd": "posterior SD of E[bin] (per-object confidence)",
+    "activity_map": "plug-in MAP E[bin] (point estimate, reference)",
+    "mu": "posterior-mean effect location (gauge units)",
+    "mu_sd": "posterior SD of mu (standard error)",
+    "sigma": "posterior-mean effect scale (gauge units)",
+    "sigma_sd": "posterior SD of sigma (standard error)",
+    "q1": "1st quartile of the posterior-mean effect distribution",
+    "q2": "2nd quartile (median = mu) of the effect distribution",
+    "q3": "3rd quartile of the posterior-mean effect distribution",
+    "abundance": "posterior-mean profiled abundance / size factor a_n",
+    "n_eff": "posterior effective grid support (larger = more uncertain)",
+    "tot": "total observed reads for this object",
+    "bin_prob": "posterior-mean probability of falling in each bin",
+}
+
+
+class StoredFit:
+    """The part of a fit the readout needs, as loaded from disk."""
+
+    def __init__(self, d):
+        self.__dict__.update(d)
+
+
+def light(res):
+    """A ``FitResult`` without the optimizer history: everything the readout
+    reads, plus the fitted per-object effect law and abundance."""
+    return dict(R=res.R, P=res.P, rates=res.rates, log_w=res.log_w,
+                cuts=res.cuts, Pi=res.Pi, mu=res.mu, sigma=res.sigma, a=res.a,
+                observed=res.observed, phi=res.phi, loglik=res.loglik,
+                converged=res.converged, extras=res.extras, config=res.config)
+
+
+def save_fits(path, fits):
+    with open(path, "wb") as f:
+        pickle.dump(fits, f)
+
+
+def load_fits(path):
+    with open(path, "rb") as f:
+        return {g: StoredFit(d) for g, d in pickle.load(f).items()}
+
+
+def activity_table(data, groups=None, *, out=None, fits_out=None,
+                   warm_from=None, readout=None, fields=TABLE_FIELDS,
+                   verbose=True, **fit_kw):
+    """Fit each cell line and assemble the activity table.
+
+    data       : path to the count table, or a DataFrame / dict of GroupData.
+    groups     : cell lines to run, in output order (default: all, file order).
+    out        : CSV path; rewritten after every line so a long run can be
+                 inspected while it goes.
+    fits_out   : pickle path for the fitted parameters (reusable readouts).
+    warm_from  : pickle of earlier fits to warm-start from (same data, e.g.
+                 refitting under the Gamma abundance prior).
+    readout    : kwargs for ``posterior_activity`` (defaults reproduce the
+                 shipped readout: the fit's own priors on a 121 x 33 grid).
+    fields     : which per-object scalars to write; all of them by default.
+    fit_kw     : passed to ``fit_effects``.
+
+    Returns (table, results) where ``table`` has (cell line, field) columns and
+    ``results`` maps cell line -> the full readout dict (including the (N, B)
+    ``bin_prob``, which is too wide for the table).
+    """
+    gdata = data if isinstance(data, dict) else load_groups(data, groups=groups,
+                                                            verbose=verbose)
+    order = [g for g in (groups or gdata) if g in gdata]
+    if not order:
+        raise ValueError(f"no cell lines to fit (have {sorted(gdata)})")
+    warm = load_fits(warm_from) if warm_from else {}
+    index = gdata[order[0]].index
+
+    fits, results, cols = {}, {}, {}
+    for i, g in enumerate(order):
+        t0 = time.time()
+        X, mask, _ = prep(gdata[g])
+        init = init_from_fit(warm[g].__dict__) if g in warm else None
+        res = fit_effects(X, mask=mask, init=init, verbose=False, **fit_kw)
+        act = posterior_activity(res, X, mask, **(readout or {}))
+        fits[g], results[g] = light(res), act
+        for f in fields:
+            cols[(g, f)] = pd.Series(act[f], index=index)
+        if out:
+            _write_table(cols, index, out)
+        if fits_out:
+            save_fits(fits_out, fits)
+        if verbose:
+            a = act["activity"]
+            print(f"[{i+1}/{len(order)}] {g}: n={int(np.isfinite(a).sum())} "
+                  f"loglik={res.loglik:.1f} conv={res.converged} "
+                  f"phi={res.phi:.4f} activity mean={np.nanmean(a):.3f} "
+                  f"({time.time()-t0:.0f}s)", flush=True)
+    return _write_table(cols, index, out), results
+
+
+def readout_table(data, fits_path, groups=None, *, out=None, readout=None,
+                  fields=TABLE_FIELDS, verbose=True):
+    """Redo the readout from saved fits -- no refit.
+
+    Useful for trying a different readout grid or prior, or for rebuilding the
+    table (or the netCDF) without paying for the fits again.
+    """
+    gdata = data if isinstance(data, dict) else load_groups(data, groups=groups,
+                                                            verbose=verbose)
+    fits = load_fits(fits_path)
+    order = [g for g in (groups or fits) if g in fits and g in gdata]
+    if not order:
+        raise ValueError(f"no cell lines in both the data and {fits_path}")
+    index = gdata[order[0]].index
+
+    results, cols = {}, {}
+    for g in order:
+        X, mask, _ = prep(gdata[g])
+        act = posterior_activity(fits[g], X, mask, **(readout or {}))
+        results[g] = act
+        for f in fields:
+            cols[(g, f)] = pd.Series(act[f], index=index)
+        if verbose:
+            print(f"  {g}: activity median "
+                  f"{np.nanmedian(act['activity']):.3f}", flush=True)
+    return _write_table(cols, index, out), results
+
+
+def _write_table(cols, index, out=None):
+    tab = pd.DataFrame(cols, index=index)
+    tab.columns = pd.MultiIndex.from_tuples(tab.columns,
+                                            names=["group", "score"])
+    if out:
+        os.makedirs(os.path.dirname(os.path.abspath(out)), exist_ok=True)
+        tab.to_csv(out)
+    return tab
+
+
+def write_netcdf(path, results, index, order=None, attrs=None):
+    """Write the readout to netCDF: every (cell_type, seq) field plus the
+    per-bin distribution bin_prob (cell_type, seq, bin)."""
+    import xarray as xr
+
+    order = list(order or results)
+    B = results[order[0]]["bin_prob"].shape[1]
+    binp = np.stack([results[g]["bin_prob"] for g in order]).astype(np.float32)
+    ds = xr.Dataset(
+        {"bin_prob": (("cell_type", "seq", "bin"), binp,
+                      {"description": FIELD_DESC["bin_prob"]}),
+         **{f: (("cell_type", "seq"),
+                np.stack([results[g][f] for g in order]).astype(np.float32),
+                {"description": FIELD_DESC[f]})
+            for f in TABLE_FIELDS}},
+        coords={"cell_type": order, "seq": np.asarray(index),
+                "bin": np.arange(1, B + 1)},
+        attrs=attrs or {})
+    ds.to_netcdf(path)
+    return ds

ebin/plots.py

@@ -0,0 +1,251 @@
+"""Diagnostic plots for a fitted activity table.
+
+Each function takes the table returned by ``activity_table`` (or read back from
+the CSV with ``pd.read_csv(path, index_col=0, header=[0, 1])``), draws one panel
+per cell line, and returns the figure.  matplotlib is imported lazily, so it is
+only needed if you plot.
+"""
+
+import numpy as np
+import pandas as pd
+
+from .data import load_groups, prep
+
+
+def _plt():
+    import matplotlib
+    import matplotlib.pyplot as plt
+    return matplotlib, plt
+
+
+def _lines(table, groups=None):
+    have = list(dict.fromkeys(table.columns.get_level_values(0)))
+    return [g for g in (groups or have) if g in have]
+
+
+def _grid(n, ncols=5, size=(3.2, 2.7)):
+    _, plt = _plt()
+    ncols = max(1, min(ncols, n))
+    nrows = int(np.ceil(n / ncols))
+    fig, axes = plt.subplots(nrows, ncols, squeeze=False,
+                             figsize=(size[0] * ncols, size[1] * nrows))
+    for ax in axes.ravel()[n:]:
+        ax.axis("off")
+    return fig, list(axes.ravel()[:n])
+
+
+def _finish(fig, out, layout=True):
+    if layout:
+        fig.tight_layout()
+    if out:
+        fig.savefig(out, dpi=150, bbox_inches="tight")
+        print(f"[saved] {out}")
+    return fig
+
+
+def raw_mass_center(counts, groups=None):
+    """Depth-normalized empirical E[bin] straight from the counts.
+
+    Every (replicate, bin) column is divided by its own library size — the
+    bins are separately sequenced, so this is the normalization that has to
+    happen before the bins are comparable — then replicates are summed and each
+    sequence's profile is normalized to give ``sum_b b * p_b``.  No model:
+    this is the yardstick to check the fitted activity against.
+    """
+    gdata = counts if isinstance(counts, dict) else \
+        load_groups(counts, groups=groups, verbose=False)
+    out, index = {}, None
+    for g, gd in gdata.items():
+        X, mask, _ = prep(gd)
+        Xz = np.where(mask, np.nan_to_num(X), 0.0)
+        p = Xz / np.maximum(Xz.sum(0)[None], 1e-9)      # per-channel depth
+        y = p.sum(1)                                    # over replicates, (N,B)
+        s = y.sum(1)
+        b = np.arange(1, X.shape[2] + 1, dtype=float)
+        out[g] = np.where(s > 0, (y * b).sum(1) / np.maximum(s, 1e-30), np.nan)
+        index = gd.index
+    return pd.DataFrame(out, index=index)
+
+
+def gc_content(sequences):
+    """GC fraction of each sequence."""
+    s = pd.Index(sequences).astype(str).str.upper()
+    letters = s.str.count("[ACGTN]").to_numpy()
+    if not np.all(letters == s.str.len().to_numpy()):
+        raise ValueError("sequences must be DNA strings; pass sequences= "
+                         "explicitly if the table index is not the sequence")
+    return ((s.str.count("G") + s.str.count("C")) / s.str.len()).to_numpy()
+
+
+def marginal_density(mu, sigma, x, weights=None, chunk=4096):
+    """(pdf, cdf) of the marginal effect law on the grid ``x``.
+
+    The marginal is the N-component normal mixture the model actually
+    parameterizes -- one component per sequence, not an averaged-out curve:
+
+        G(x) = sum_n w_n * Phi((x - mu_n) / sigma_n),   sum_n w_n = 1.
+
+    ``weights`` default to uniform, which is what the fit uses; pass e.g. the
+    fitted abundances to weight sequences by how many cells they contribute.
+    Accumulated in chunks, so the N x len(x) array never materializes.
+    """
+    from scipy.stats import norm
+    mu = np.asarray(mu, float)
+    sigma = np.asarray(sigma, float)
+    ok = np.isfinite(mu) & np.isfinite(sigma) & (sigma > 0)
+    w = np.ones(mu.size) if weights is None else np.asarray(weights, float)
+    ok &= np.isfinite(w)
+    mu, sigma, w = mu[ok], sigma[ok], w[ok]
+    w = w / w.sum()
+    pdf = np.zeros_like(x)
+    cdf = np.zeros_like(x)
+    for i in range(0, mu.size, chunk):
+        s = slice(i, i + chunk)
+        z = (x[None, :] - mu[s, None]) / sigma[s, None]
+        pdf += (w[s, None] * norm.pdf(z) / sigma[s, None]).sum(0)
+        cdf += (w[s, None] * norm.cdf(z)).sum(0)
+    return pdf, cdf
+
+
+def plot_marginal_distribution(table, groups=None, n_bins=4, cuts=None,
+                               weights=None, out=None, ncols=5, grid=1500,
+                               pad=3.0):
+    """The marginal effect law of each cell line, sliced into the sorting bins.
+
+    The curve is the N-component mixture the model estimates,
+    G(x) = sum_n w_n Phi((x - mu_n)/sigma_n) — one normal per sequence, drawn
+    as the density it defines — and the bins are its quantile cells.  Each bin's
+    slice is filled in its own colour, and the x ticks are the cut points (the
+    quartiles of G for B = 4) labelled with their values.  Every slice holds
+    1/B of the mass by construction, so unequal-looking areas mean the density
+    is concentrated there, not that the bins are unbalanced.
+
+    cuts    : {cell line: array} to draw the fit's own cut points; by default
+        they are read off G itself, which is how the fit defines them.
+    weights : {cell line: array} of mixture weights; uniform by default, as in
+        the fit.
+    """
+    matplotlib, plt = _plt()
+    lines = _lines(table, groups)
+    B = n_bins
+    colors = plt.get_cmap("viridis")(np.linspace(0.15, 0.9, B))
+    probs = np.arange(1, B) / B
+
+    fig, axes = _grid(len(lines), ncols, (3.4, 2.8))
+    for ax, g in zip(axes, lines):
+        mu = table[(g, "mu")].to_numpy(float)
+        sd = table[(g, "sigma")].to_numpy(float)
+        m = np.isfinite(mu) & np.isfinite(sd)
+        lo = np.percentile(mu[m], 0.2) - pad * np.median(sd[m])
+        hi = np.percentile(mu[m], 99.8) + pad * np.median(sd[m])
+        x = np.linspace(lo, hi, grid)
+        w = None if weights is None else np.asarray(weights[g], float)[m]
+        pdf, cdf = marginal_density(mu[m], sd[m], x, weights=w)
+        q = np.asarray(cuts[g]) if cuts is not None else np.interp(probs, cdf, x)
+
+        edges = np.concatenate([[x[0]], q, [x[-1]]])
+        for b in range(B):
+            sel = (x >= edges[b]) & (x <= edges[b + 1])
+            ax.fill_between(x[sel], pdf[sel], color=colors[b], linewidth=0)
+        ax.plot(x, pdf, color="0.15", lw=1.0)
+        for v in q:
+            ax.axvline(v, color="0.15", lw=0.8, ls="--")
+        ax.set_xticks(q)
+        ax.set_xticklabels([f"{v:.2f}" for v in q], fontsize=7, rotation=45,
+                           ha="right", rotation_mode="anchor")
+        ax.set_xlim(lo, hi)
+        ax.set_ylim(bottom=0)
+        ax.set_yticks([])
+        ax.set_title(f"{g}  (n={int(m.sum())})", fontsize=9)
+    # reserve a strip at the top for the bin legend (a fixed ~0.35 inch,
+    # whatever the number of rows)
+    top = 1.0 - 0.35 / fig.get_figheight()
+    fig.tight_layout(rect=(0, 0, 1, top))
+    fig.legend(handles=[matplotlib.patches.Patch(color=colors[b],
+                                                 label=f"bin {b + 1}")
+                        for b in range(B)],
+               loc="upper center", ncol=B, fontsize=8, frameon=False,
+               bbox_to_anchor=(0.5, 1.0))
+    return _finish(fig, out, layout=False)
+
+
+def plot_activity_vs_raw(table, counts, groups=None, out=None, ncols=5):
+    """Fitted activity against the depth-normalized raw mass centre, coloured
+    by the fitted abundance.
+
+    The two agree for well-measured sequences; the low-abundance ones are where
+    the model shrinks and the raw estimate is noise."""
+    from scipy.stats import spearmanr
+    _, plt = _plt()
+    lines = _lines(table, groups)
+    raw = raw_mass_center(counts, lines).reindex(table.index)
+    ab = np.concatenate([table[(g, "abundance")].to_numpy(float) for g in lines])
+    ab = np.log10(np.clip(ab[np.isfinite(ab)], 1e-4, None))
+    # a shared scale so panels are comparable; 5-95% because the a_min floor
+    # piles up a long left tail that would otherwise eat the whole colormap
+    vmin, vmax = np.percentile(ab, [5, 95])
+
+    fig, axes = _grid(len(lines), ncols)
+    sc = None
+    for ax, g in zip(axes, lines):
+        x = raw[g].to_numpy(float)
+        y = table[(g, "activity")].to_numpy(float)
+        c = np.log10(np.clip(table[(g, "abundance")].to_numpy(float), 1e-4, None))
+        m = np.isfinite(x) & np.isfinite(y) & np.isfinite(c)
+        sc = ax.scatter(x[m], y[m], c=c[m], s=2, alpha=0.4, linewidths=0,
+                        cmap="viridis", vmin=vmin, vmax=vmax, rasterized=True)
+        lim = [min(np.nanmin(x[m]), np.nanmin(y[m])),
+               max(np.nanmax(x[m]), np.nanmax(y[m]))]
+        ax.plot(lim, lim, color="0.4", lw=0.8, ls="--")
+        rho = spearmanr(x[m], y[m]).statistic
+        ax.set_title(f"{g}  rho={rho:.3f}", fontsize=9)
+        ax.set_xlabel("raw E[bin] (depth-normalized)", fontsize=7)
+        ax.set_ylabel("activity", fontsize=7)
+        ax.tick_params(labelsize=7)
+    if sc is not None:
+        fig.colorbar(sc, ax=axes, shrink=0.6, label="log10 abundance")
+    if out:
+        fig.savefig(out, dpi=150, bbox_inches="tight")
+        print(f"[saved] {out}")
+    return fig
+
+
+def plot_gc_vs_abundance(table, sequences=None, groups=None, out=None,
+                         ncols=5, n_trend=25):
+    """GC content against the fitted abundance, with the binned median trend.
+
+    A strong trend means the size factor is picking up a sequencing/cloning
+    bias rather than a biological one."""
+    from scipy.stats import spearmanr
+    _, plt = _plt()
+    lines = _lines(table, groups)
+    gc = gc_content(table.index if sequences is None else sequences)
+
+    fig, axes = _grid(len(lines), ncols)
+    for ax, g in zip(axes, lines):
+        y = table[(g, "abundance")].to_numpy(float)
+        m = np.isfinite(y) & np.isfinite(gc) & (y > 0)
+        ax.scatter(gc[m], y[m], s=2, alpha=0.3, linewidths=0, color="#3b6ea5",
+                   rasterized=True)
+        edges = np.quantile(gc[m], np.linspace(0, 1, n_trend + 1))
+        idx = np.clip(np.digitize(gc[m], edges[1:-1]), 0, n_trend - 1)
+        med = np.array([np.median(y[m][idx == k]) if (idx == k).any() else np.nan
+                        for k in range(n_trend)])
+        ax.plot(0.5 * (edges[:-1] + edges[1:]), med, color="#c0392b", lw=1.4)
+        ax.set_yscale("log")
+        ax.set_title(f"{g}  rho={spearmanr(gc[m], y[m]).statistic:.3f}",
+                     fontsize=9)
+        ax.set_xlabel("GC content", fontsize=7)
+        ax.set_ylabel("abundance", fontsize=7)
+        ax.tick_params(labelsize=7)
+    return _finish(fig, out)
+
+
+def plot_all(table, counts, outdir=".", groups=None):
+    """Write all three diagnostics into ``outdir``."""
+    import os
+    os.makedirs(outdir, exist_ok=True)
+    p = lambda n: os.path.join(outdir, n)
+    plot_marginal_distribution(table, groups, out=p("marginal_effect_law.png"))
+    plot_activity_vs_raw(table, counts, groups, out=p("activity_vs_raw.png"))
+    plot_gc_vs_abundance(table, groups=groups, out=p("gc_vs_abundance.png"))

ebin/truncation.py

@@ -0,0 +1,59 @@
+"""Zero handling: the probability that an object's observed cells are all zero.
+
+Two ways to treat the all-zero rows:
+
+* zero-TRUNCATION (``conditional=True``): drop them and condition every kept
+  object on Sum_{s,b} X > 0, i.e. subtract log(1 - P_n(0));
+* zero-INFLATION (``conditional=False``): fit them, with a probability phi that
+  an object is a structural zero.
+
+P_n(0) has a closed form -- for one cell it is the Poisson PGF evaluated at the
+NB zero mass,
+
+    sum_tau Pois(tau | Pi_b r) NB(0 | R tau, P) = exp(Pi_b r (P^R - 1)),
+
+so no tau summation is needed.
+"""
+
+import jax.numpy as jnp
+from jax.scipy.special import logsumexp
+
+
+def log1mexp(x):
+    """log(1 - e^x) for x < 0, stable on both ends."""
+    return jnp.where(x > -0.6931471805599453,          # -log 2
+                     jnp.log(-jnp.expm1(x)),
+                     jnp.log1p(-jnp.exp(x)))
+
+
+def log_zero_prob(R, P, Pi, rates, log_wmix, mask):
+    """(N,) log P(all observed cells of the object are zero), phi = 0.
+
+    Mirrors ``LoglikBuilder.object_loglik``: the rate mixture sits outside the
+    product over b, per (object, replicate).
+    """
+    rates = jnp.atleast_2d(rates)
+    log_wmix = jnp.atleast_2d(log_wmix)
+    zeta = P ** R - 1.0                                  # (S, B) <= 0
+    mzeta = jnp.where(mask, zeta[None, :, :], 0.0)       # (N, S, B)
+    a = jnp.einsum("nb,nsb->ns", Pi, mzeta)              # (N, S)
+    t = a[:, :, None] * rates[None, :, :] + log_wmix[None, :, :]
+    return logsumexp(t, axis=2).sum(axis=1)
+
+
+def log_zero_prob_abund(R, P, Pi, base_lambda, a_nodes, log_wa, mask):
+    """(N,) log P(all observed cells zero) with the abundance integrated out.
+
+    Given a_n = a the cells are independent, so log P(all zero | a) = a * c_n
+    with c_n = sum_{observed (s,b)} Pi_nb * base_lambda[s] * (P^R - 1)_{s,b} <= 0,
+    and marginally log P_n(0) = logsumexp_k [log_wa_k + a_k * c_n] -- the
+    discretized-Gamma MGF at c_n.  Exact: no tau truncation enters.
+    """
+    base_lambda = jnp.atleast_1d(jnp.asarray(base_lambda))
+    a_nodes = jnp.asarray(a_nodes)
+    zeta = P ** R - 1.0                                  # (S, B) <= 0
+    c = jnp.zeros(mask.shape[0], dtype=jnp.float64)
+    for s in range(mask.shape[1]):
+        contrib = Pi * (zeta[s] * base_lambda[s])[None, :]            # (N, B)
+        c = c + jnp.sum(jnp.where(mask[:, s, :], contrib, 0.0), axis=1)
+    return logsumexp(log_wa[None, :] + a_nodes[None, :] * c[:, None], axis=1)

ebin-1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ebin
+Version: 1.0
+Summary: Posterior bin-expectation normalization for sorting-based MPRA
+Requires-Python: >=3.9
+Requires-Dist: jax>=0.4
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Provides-Extra: netcdf
+Requires-Dist: xarray; extra == "netcdf"
+Requires-Dist: h5netcdf; extra == "netcdf"

ebin-1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ebin/__init__.py,sha256=4WMcz10RxBu99SBaOXMw65P8HNFmTYQp2KKaYSERfhQ,1384
+ebin/__main__.py,sha256=VKOx4fl0ngX3ygb3E60WoZQsf9DpxHTqKlXLC2ol_Fs,3691
+ebin/activity.py,sha256=0efyOBp7kl3PbOINvQ8Hg3YK3EGuAckDOVvfVtNdoBA,7183
+ebin/data.py,sha256=JU35xOSWbp0Cs-YGxMCrjRQZEgES_bfq5x3aX79fsCQ,3594
+ebin/effects.py,sha256=SkqJka6ywb6k2DiSW__6v6p2ZKYApwcK8SIGuDm3_TE,6559
+ebin/fit.py,sha256=_Wz0g_-006kaKkf2m6yV6JXMUEhUOJ8unD9OU6IUNac,23008
+ebin/ftzkiller.py,sha256=esXm2i6MzWa6t9OEsA7-PYKiV9E3EFx6R2gfecU4f1M,2319
+ebin/gauss_rules.py,sha256=I_r9uF_k0Q-4rW2qVaWXgeZMZWgWVvMc_SYCVqChJvI,9196
+ebin/initialize.py,sha256=odJFSGmrQKhE0VRDtB_WJ8Ob04jqG5G5ViotZw02aWo,7317
+ebin/model.py,sha256=mJ82VEwFfAc_h1EHEre8QCHxUdtXMHlteGv80VzTVeg,8270
+ebin/pipeline.py,sha256=8pCiUc6D52JEtugMrHmPuMcjgCnbnESArJy7mfDiBs4,7282
+ebin/plots.py,sha256=M1RjMPS-I7qLNLZhVFqCodhOltZe_lNXcRNTYPvEoRw,10783
+ebin/truncation.py,sha256=z3_Qy0_rE9jacpVRlKcE6-cz9E9tdl8EHYgXjcqGl1Y,2459
+ebin-1.0.dist-info/METADATA,sha256=W48F-2s0jvd9zkpshf1tO5Q6o_g0FZ0EvpJQcrMytYs,336
+ebin-1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+ebin-1.0.dist-info/entry_points.txt,sha256=4flx-gzw4pc-7fdlcwV47IdTW0lZg0k5DPzmAEh3rpA,44
+ebin-1.0.dist-info/top_level.txt,sha256=8YXMFv4GwJ62SJPK-tp-2XWbwetQ0HlE0CGp9nbPfrI,5
+ebin-1.0.dist-info/RECORD,,

ebin-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ebin-1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ebin = ebin.__main__:main

ebin-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ebin