canbiplotme 0.3.0__py3-none-any.whl

canbiplotme/stage2.py

@@ -0,0 +1,336 @@
+"""Second stage: canonical biplot of estimates measured with error (port of ``cbme``)."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from itertools import combinations
+
+import numpy as np
+import pandas as pd
+
+from .data import MEData
+
+
+@dataclass
+class Settings:
+    dim: int = 2
+    T_errors: str = "independent"
+    mean_errors: str = "joint"
+    eps: float = 1e-6
+    metric: str = "mean"
+    weights: str = "n"
+    S_idx: list | None = None
+    T_fixed: np.ndarray | None = None
+
+
+class CBMEFit:
+    """Result of :func:`cbme`. Attributes mirror the R object.
+
+    ``T``, ``T_raw``, ``T_eigen_raw``, ``mu`` (G x K), ``mu_cov`` (G x K x K),
+    ``mu0``, ``n``, ``W``, ``Vbar``, ``H``, ``mbar``, ``lambda_`` (eigenvalues),
+    ``V`` (canonical directions), ``A`` (group markers), ``Afull``, ``C``
+    (component markers), ``cos2``, ``quality``, ``ind`` (individuals with every
+    component identified), ``ind_ids``, ``stats`` and ``D2``.
+    """
+
+    def __init__(self, core: dict, data: MEData, settings: Settings, cache: dict):
+        self.__dict__.update(core)
+        self.data = data
+        self.settings = settings
+        self.cache = cache
+
+    def _update(self, core: dict):
+        self.__dict__.update(core)
+
+    # convenient labelled views -------------------------------------------
+    def markers(self) -> pd.DataFrame:
+        cols = [f"Dim{d + 1}" for d in range(self.A.shape[1])]
+        out = pd.DataFrame(self.A, index=self.data.levels, columns=cols)
+        out["quality"] = self.quality
+        return out
+
+    def component_markers(self) -> pd.DataFrame:
+        return pd.DataFrame(self.C, index=self.data.components,
+                            columns=[f"Dim{d + 1}" for d in range(self.C.shape[1])])
+
+    def means(self) -> pd.DataFrame:
+        return pd.DataFrame(self.mu, index=self.data.levels, columns=self.data.components)
+
+    def se_means(self) -> pd.DataFrame:
+        se = np.sqrt(np.einsum("gkk->gk", self.mu_cov))
+        return pd.DataFrame(se, index=self.data.levels, columns=self.data.components)
+
+    def summary(self) -> dict:
+        lam = self.lambda_
+        return {
+            "eigen": pd.DataFrame({"lambda": lam, "inertia": np.cumsum(lam) / lam.sum()},
+                                  index=range(1, len(lam) + 1)),
+            "heterogeneity": pd.DataFrame({"T": np.diag(self.T), "T_raw": np.diag(self.T_raw),
+                                           "Vbar": np.diag(self.Vbar)}, index=self.data.components),
+            "T_eigen_raw": self.T_eigen_raw,
+            "condition_W": np.linalg.cond(self.W),
+            "means": self.means(), "se_means": self.se_means(),
+            "structure": pd.DataFrame(self.cos2[:, :self.A.shape[1]], index=self.data.components),
+            "D2": self.D2, "stats": self.stats,
+        }
+
+    def plot(self, *args, **kwargs):
+        from .plot import plot_cbme
+        return plot_cbme(self, *args, **kwargs)
+
+    def __repr__(self) -> str:
+        L = min(len(self.n) - 1, self.W.shape[0])
+        lam = self.lambda_[:L]
+        s = ["Canonical biplot of estimates measured with error",
+             f"{int(sum(self.n))} individuals, {len(self.n)} groups, {self.W.shape[0]} components", "",
+             "Eigenvalues: " + ", ".join(f"{v:.3f}" for v in lam),
+             "Cumulative inertia: " + ", ".join(f"{v:.3f}" for v in np.cumsum(lam) / lam.sum()), "",
+             "Statistics: " + ", ".join(f"{k} = {v:.4g}" for k, v in self.stats.items()), "",
+             "Group markers:", self.markers().round(3).to_string(), "",
+             "Component markers:", self.component_markers().round(3).to_string()]
+        return "\n".join(s)
+
+
+def cbme(x: MEData, dim: int = 2, T_errors: str = "independent", mean_errors: str = "joint",
+         eps: float = 1e-6, metric: str = "mean", weights: str = "n", S_vars=None,
+         T_fixed=None) -> CBMEFit:
+    """Canonical biplot of estimates measured with error (chapter 3 of the thesis).
+
+    Estimates the heterogeneity T by moments (Definition 3.3.1) and projects it
+    onto the PSD cone, computes the precision-weighted group means and their
+    covariance (Definition 3.3.2), the metric W = T + Vbar, the between matrix H
+    and the canonical solution H v = lambda W v with v'Wv = 1.
+
+    Parameters mirror the R function ``cbme``.
+    """
+    if T_errors not in ("independent", "joint"):
+        raise ValueError("T_errors must be 'independent' or 'joint'")
+    if mean_errors not in ("joint", "independent"):
+        raise ValueError("mean_errors must be 'joint' or 'independent'")
+    if metric not in ("mean", "median", "group"):
+        raise ValueError("metric must be 'mean', 'median' or 'group'")
+    if weights not in ("n", "equal"):
+        raise ValueError("weights must be 'n' or 'equal'")
+    st = Settings(dim=dim, T_errors=T_errors, mean_errors=mean_errors, eps=eps, metric=metric,
+                  weights=weights, T_fixed=None if T_fixed is None else np.asarray(T_fixed, float))
+    if not x.has_joint:
+        st.T_errors = "independent"
+        st.mean_errors = "independent"
+    if S_vars is not None:
+        st.S_idx = [x.components.index(v) if isinstance(v, str) else int(v) for v in S_vars]
+    cache = make_cache(x)
+    core = fit_core(x, x.beta, np.arange(x.N), st, cache)
+    return CBMEFit(core, x, st, cache)
+
+
+def make_cache(x: MEData) -> dict:
+    pos = np.zeros(x.N, dtype=int)
+    for lev in x.levels:
+        idx = np.where(x.group == lev)[0]
+        pos[idx] = np.arange(len(idx))
+    Om = {lev: x.group_omega(lev) for lev in x.levels} if x.has_joint else None
+    out = {"pos": pos, "Omega": Om}
+    if x.block is not None and x.has_joint:
+        bpos = np.zeros(x.N, dtype=int)
+        for b in x.block_levels:
+            idx = np.where(x.block == b)[0]
+            bpos[idx] = np.arange(len(idx))
+        out["bpos"] = bpos
+        out["OmB"] = {b: x.block_omega(b) for b in x.block_levels}
+    return out
+
+
+def _omega_cross(x: MEData, cache: dict, r1: np.ndarray, r2: np.ndarray) -> np.ndarray:
+    b = x.block[r1[0]]
+    K = x.K
+    c1 = (cache["bpos"][r1][:, None] * K + np.arange(K)[None, :]).ravel()
+    c2 = (cache["bpos"][r2][:, None] * K + np.arange(K)[None, :]).ravel()
+    return cache["OmB"][b][np.ix_(c1, c2)]
+
+
+def _omega_rows(x: MEData, cache: dict, rows: np.ndarray) -> np.ndarray:
+    lev = x.group[rows[0]]
+    K = x.K
+    cols = (cache["pos"][rows][:, None] * K + np.arange(K)[None, :]).ravel()
+    return cache["Omega"][lev][np.ix_(cols, cols)]
+
+
+def fit_core(x: MEData, beta: np.ndarray, rows: np.ndarray, st: Settings, cache: dict,
+             fill_missing: bool = True) -> dict:
+    K = x.K
+    rows = np.asarray(rows)
+    grp = x.group[rows]
+    levs = x.levels
+    Va = x.V[rows]
+    ok = np.isfinite(beta)
+    joint_T = st.T_errors == "joint"
+    joint_m = st.mean_errors == "joint"
+    Om = None
+    if joint_T or joint_m:
+        Om = {}
+        for lev in levs:
+            r = np.where(grp == lev)[0]
+            Om[lev] = _omega_rows(x, cache, rows[r]) if len(r) else None
+    # ---- heterogeneity (Definition 3.3.1) ----
+    if st.T_fixed is None:
+        Traw = np.zeros((K, K))
+        for k in range(K):
+            for l in range(k, K):
+                S = E = den = 0.0
+                for lev in levs:
+                    r = np.where((grp == lev) & ok[:, k] & ok[:, l])[0]
+                    m = len(r)
+                    if m < 2:
+                        continue
+                    dk = beta[r, k] - beta[r, k].mean()
+                    dl = beta[r, l] - beta[r, l].mean()
+                    S += np.sum(dk * dl)
+                    if joint_T:
+                        rg = np.where(grp == lev)[0]
+                        j = np.searchsorted(rg, r)
+                        Okl = Om[lev][np.ix_(j * K + k, j * K + l)]
+                        Okl = np.where(np.isfinite(Okl), Okl, 0.0)
+                        E += np.trace(Okl) - Okl.sum() / m
+                    else:
+                        E += (1 - 1 / m) * np.sum(Va[r, k, l])
+                    den += m - 1
+                Traw[k, l] = Traw[l, k] = (S - E) / den if den > 0 else 0.0
+        ev, evec = np.linalg.eigh(Traw)
+        ev, evec = ev[::-1], evec[:, ::-1]
+        T = evec @ np.diag(np.maximum(ev, st.eps)) @ evec.T
+        T_eig = ev
+    else:
+        T = Traw = st.T_fixed
+        T_eig = np.linalg.eigvalsh(T)[::-1]
+    # ---- weights and means (Definition 3.3.2) ----
+    w = np.zeros((len(rows), K))
+    for k in range(K):
+        w[ok[:, k], k] = 1.0 / (T[k, k] + Va[ok[:, k], k, k])
+    bz = np.where(ok, beta, 0.0)
+    mu0 = (w * bz).sum(0) / w.sum(0)
+    G = len(levs)
+    mu = np.full((G, K), np.nan)
+    cv = np.zeros((G, K, K))
+    n = np.array([np.sum(grp == lev) for lev in levs], dtype=float)
+    for gi, lev in enumerate(levs):
+        r = np.where(grp == lev)[0]
+        if not len(r):
+            continue
+        wg = w[r]
+        sw = wg.sum(0)
+        with np.errstate(invalid="ignore", divide="ignore"):
+            mu[gi] = np.where(sw > 0, (wg * bz[r]).sum(0) / np.where(sw > 0, sw, 1), np.nan)
+        for k in range(K):
+            for l in range(k, K):
+                if sw[k] == 0 or sw[l] == 0:
+                    cv[gi, k, l] = cv[gi, l, k] = np.nan
+                    continue
+                num = T[k, l] * np.sum(wg[:, k] * wg[:, l])
+                if joint_m:
+                    jj = np.arange(len(r))
+                    Okl = Om[lev][np.ix_(jj * K + k, jj * K + l)]
+                    Okl = np.where(np.isfinite(Okl), Okl, 0.0)
+                    num += wg[:, k] @ Okl @ wg[:, l]
+                else:
+                    vv = np.where(np.isfinite(Va[r, k, l]), Va[r, k, l], 0.0)
+                    num += np.sum(wg[:, k] * wg[:, l] * vv)
+                cv[gi, k, l] = cv[gi, l, k] = num / (sw[k] * sw[l])
+    # covariance between the means of two groups of the same error block
+    cx = None
+    if joint_m and "OmB" in cache:
+        cx = np.zeros((G, G, K, K))
+        blk = x.block[rows]
+        blk_g = [blk[grp == lev][0] if np.any(grp == lev) else None for lev in levs]
+        for gi in range(G - 1):
+            for hi in range(gi + 1, G):
+                if blk_g[gi] is None or blk_g[gi] != blk_g[hi]:
+                    continue
+                rg = np.where(grp == levs[gi])[0]
+                rh = np.where(grp == levs[hi])[0]
+                Ogh = _omega_cross(x, cache, rows[rg], rows[rh])
+                Ogh = np.where(np.isfinite(Ogh), Ogh, 0.0)
+                wg, wh = w[rg], w[rh]
+                sg, sh = wg.sum(0), wh.sum(0)
+                for k in range(K):
+                    for l in range(K):
+                        if sg[k] == 0 or sh[l] == 0:
+                            cx[gi, hi, k, l] = np.nan
+                            continue
+                        blkm = Ogh[np.ix_(np.arange(len(rg)) * K + k, np.arange(len(rh)) * K + l)]
+                        cx[gi, hi, k, l] = wg[:, k] @ blkm @ wh[:, l] / (sg[k] * sh[l])
+                cx[hi, gi] = cx[gi, hi].T
+    missing = np.isnan(mu)
+    if fill_missing and missing.any():
+        # a component without individuals in a group takes the common mean (section 3.6.6)
+        for gi in np.where(missing.any(1))[0]:
+            for k in np.where(missing[gi])[0]:
+                mu[gi, k] = mu0[k]
+                cv[gi, k, :] = 0.0
+                cv[gi, :, k] = 0.0
+                cv[gi, k, k] = T[k, k]
+    # ---- metric ----
+    Vbar = np.zeros((K, K))
+    for k in range(K):
+        for l in range(K):
+            r = np.where(ok[:, k] & ok[:, l])[0]
+            v = Va[r, k, l]
+            if st.metric == "mean":
+                Vbar[k, l] = v.mean()
+            elif st.metric == "median":
+                Vbar[k, l] = np.median(v)
+            else:
+                gm = [v[grp[r] == lev].mean() for lev in levs if np.any(grp[r] == lev)]
+                Vbar[k, l] = np.mean(gm)
+    Vbar = (Vbar + Vbar.T) / 2
+    W = T + Vbar
+    # ---- between matrix and canonical solution ----
+    nw = n if st.weights == "n" else np.full(G, n.sum() / G)
+    keep = n > 0
+    mbar = (mu[keep] * nw[keep, None]).sum(0) / nw[keep].sum()
+    Dm = mu - mbar
+    Dm[~keep] = 0.0
+    H = (Dm * np.sqrt(nw)[:, None]).T @ (Dm * np.sqrt(nw)[:, None]) / (keep.sum() - 1)
+    L = np.linalg.cholesky(W)
+    Li = np.linalg.inv(L)
+    ev, evec = np.linalg.eigh(Li @ H @ Li.T)
+    ev, evec = ev[::-1], evec[:, ::-1]
+    Vc = Li.T @ evec
+    s = np.sign(Vc[np.abs(Vc).argmax(0), np.arange(K)])
+    s[s == 0] = 1
+    s[min(st.dim, K):] = 1          # sign fixed only for the first `dim` axes, as in the thesis
+    Vc = Vc * s
+    lam = np.maximum(ev, 0.0)
+    d = st.dim
+    Afull = Dm @ Vc
+    A = Afull[:, :d]
+    WV = W @ Vc
+    C = WV[:, :d]
+    cos2 = WV ** 2 / np.diag(W)[:, None]
+    with np.errstate(invalid="ignore", divide="ignore"):
+        quality = (A ** 2).sum(1) / (Afull ** 2).sum(1)
+    comp = np.where(ok.sum(1) == K)[0]
+    ind = (beta[comp] - mbar) @ Vc[:, :d]
+    stats = {"trace": lam.sum(), "lambda1": lam[0], "Pi2": lam[:min(2, K)].sum() / lam.sum()}
+    if st.S_idx is not None:
+        p = cos2[:, 0] / cos2[:, 0].sum()
+        c2 = cos2[:, :min(2, K)]
+        stats["S"] = p[st.S_idx].sum()
+        stats["S_plane"] = c2[st.S_idx].sum() / c2.sum()
+    D2 = pairwise_D2(mu, cv, levs, cx)
+    return {"T": T, "T_raw": Traw, "T_eigen_raw": T_eig, "mu": mu, "mu_cov": cv, "mu_cross": cx, "mu0": mu0,
+            "missing_components": missing, "n": n, "W": W, "Vbar": Vbar, "H": H, "mbar": mbar,
+            "lambda_": lam, "V": Vc, "A": A, "Afull": Afull, "C": C, "cos2": cos2,
+            "quality": quality, "ind": ind, "ind_ids": [x.id[i] for i in rows[comp]],
+            "stats": stats, "D2": D2, "weights_means": w}
+
+
+def pairwise_D2(mu: np.ndarray, cv: np.ndarray, levs, cx=None) -> pd.Series:
+    out = {}
+    for a, b in combinations(range(mu.shape[0]), 2):
+        dlt = mu[a] - mu[b]
+        S = cv[a] + cv[b]
+        if cx is not None:
+            C = np.where(np.isfinite(cx[a, b]), cx[a, b], 0.0)
+            S = S - C - C.T
+        ok = np.isfinite(dlt) & np.isfinite(np.diag(S))
+        out[f"{levs[a]}-{levs[b]}"] = float(dlt[ok] @ np.linalg.solve(S[np.ix_(ok, ok)], dlt[ok]))
+    return pd.Series(out)

canbiplotme-0.3.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: canbiplotme
+Version: 0.3.0
+Summary: Canonical biplot for grouped estimates measured with error (Python port of the R package gcbiplot, Gravity Canonical Biplot)
+Author-email: Carlos Freire-Cadme <cfreirec@unemi.edu.ec>
+License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/cfreirec/canbiplotme
+Project-URL: Source, https://github.com/cfreirec/canbiplotme
+Project-URL: Issues, https://github.com/cfreirec/canbiplotme/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.8
+Requires-Dist: pandas>=1.4
+Provides-Extra: gravity
+Requires-Dist: pyfixest>=0.30; extra == "gravity"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.5; extra == "plot"
+Provides-Extra: all
+Requires-Dist: pyfixest>=0.30; extra == "all"
+Requires-Dist: matplotlib>=3.5; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# canbiplotme
+
+Canonical biplot for grouped estimates measured with error — Python port of the
+R package **gcbiplot** (Gravity Canonical Biplot, formerly canbiplotME; Freire-Cadme, 2026, doctoral thesis *Biplot canónico y
+modelo gravitacional de comercio: regímenes comerciales y exportadores medidos con error*).
+
+The individuals of a canonical (MANOVA) biplot are estimated coefficient vectors,
+each with its own measurement-error covariance, correlated within groups and with
+components that may be undefined for some individuals.
+
+```bash
+pip install canbiplotme            # core
+pip install canbiplotme[all]       # + pyfixest (first stage) and matplotlib
+```
+
+## Reproducing the thesis
+
+```python
+import canbiplotme as cb
+x = cb.load_gcb_trade()                               # 115 exporters, 6 regimes, 5 frictions
+fit = cb.gcb(x, S_vars=["log_dist", "comlang_off"])   # trace 18.579
+t = cb.gcb_test(fit, B=1999, seed=20251025 + 17000000)
+print(t)                                              # p(trace) = 0.096; 2 of 15 pairs (Holm)
+```
+
+With an integer `seed`, `gcb_test` draws replicate `b` with `cb.RRNG(seed + b)`,
+a generator that reproduces R's `set.seed()` and `rnorm()`: the replicates are
+those of `gcbiplot::gcb_test()` and of the thesis (differences below 1e-11).
+The `gcb*` names are aliases of the `cbme*` ones.
+
+## Minimal example
+
+```python
+import canbiplotme as cb
+x = cb.load_sim_me()
+fit = cb.cbme(x, S_vars=["z1", "z2"])        # second stage
+tt = cb.cbme_test(fit, B=1999, seed=1)       # G0 bootstrap: trace, largest root, pairs (Holm), S
+rg = cb.cbme_regions(fit, seed=1)            # regions R1-R4
+fit.plot(rg, region="R3")
+cb.cbme_influence(fit, B_ref=200)            # jackknife + reference
+cb.cbme_simulate_tests(fit, nsim=1000, B=199)  # validate the size in your own design
+```
+
+First stage from trade flows (needs `pyfixest`):
+
+```python
+d = cb.load_sim_trade()
+s1 = cb.gravity_by_individual(d, "flow", "orig", "dest", "year", ["ldist", "lang", "fta"], "regime", controls=["contig"])
+bt = cb.pairs_bootstrap(s1, d, R=199)
+cnt = cb.support_counts(d, "orig", "dest", ["lang", "fta"])
+idn = cb.identify_d6(s1.beta, bt["V"], s1.id, cnt, ["lang", "fta"], components=s1.spec["frictions"])
+fit = cb.cbme(cb.as_me_data(s1, bt, idn))
+```
+
+## Validation against R
+
+`tests/test_vs_r.py` compares with fixtures produced by the R package
+(`tests/fixtures/make_fixtures.R`):
+
+* second stage (heterogeneity, means and covariances, metric, eigenvalues,
+  markers, structure correlations, statistics, D²) in four configurations: max.
+  difference ~1e-14;
+* regions R1–R3 and jackknife ρ: < 1e-10;
+* first stage with pyfixest vs fixest: coefficients < 1e-7, also on a resampled
+  bootstrap dataset and in the dynamic extension. Clustered covariances differ by
+  ~0.1 % because of the small-sample degrees-of-freedom convention of each library
+  (the analysis uses the bootstrap covariance).
+
+Random draws (bootstrap, G0) use NumPy's generator, so p-values agree with R in
+distribution, not replicate by replicate. The REML comparator `cbme_reml` reproduces `metafor::rma.mv` (T < 6e-7, means
+< 2e-6, LRT < 1e-8). `cbme_permutation_test` is the permutation comparator.
+
+`mvmeta` is a general multivariate random-effects meta-analysis and
+meta-regression (unstructured between-study covariance, missing outcomes,
+REML / ML / fixed), validated against `mixmeta` 1.2.2: coefficients, Psi,
+covariance of the coefficients, log-likelihood and Cochran's Q agree to
+< 1e-6 (REML with a badly scaled moderator, where the surface is flat: 4e-5 in
+the coefficients at the same log-likelihood).

canbiplotme-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+canbiplotme/__init__.py,sha256=EDN7iB98LAPX5Ln8_4d2h9-X9oL2iR25v8LV0V-Ke0E,1957
+canbiplotme/data.py,sha256=xw4M6FVCdMw99QFUjpf8omeESD5cLSxwPZulboPMZos,13222
+canbiplotme/dynamic.py,sha256=SuwBZ8P9vjOXeVqfAvEyT8C1H2ATH6Eyy2Y8aecT7eg,4778
+canbiplotme/inference.py,sha256=8kYyC2lijrlUEgWCoXstqySGZQ9MTEnb42zhTj5XWsk,11833
+canbiplotme/meta.py,sha256=Ng_sUbBVssWDanG4DCZvjiICA3vD_mS5w-zR1k71kFA,5234
+canbiplotme/plot.py,sha256=j7gw5TcuiCJzco9xUDSGcliwiElxy4loCgkoNGBNc30,2506
+canbiplotme/regions.py,sha256=SNsXGRKRerGqEwZ2D6elUKxqmiDuBokEJBVW9kktiqU,3888
+canbiplotme/reml.py,sha256=S1F5bTd1nAK73034WsjfK_uPSt-nYis4tgg9GpKN7Q4,5196
+canbiplotme/rng.py,sha256=f5jfFbhsGwgnynwaETjxwvVa1CnZfUEBlxZnpD7EIfU,4747
+canbiplotme/simulation.py,sha256=nhTnsw3c4qhEuueEHuh2Nme5LgWrLfhViiGjZyE-fFU,3644
+canbiplotme/stage1.py,sha256=rdvTsTL3Db1o2Y6-mVv4BjrfsulGMk0-fxItN_TajbE,8197
+canbiplotme/stage2.py,sha256=515qOD9RcCtuWWB3YnMuyV7_WMLhB5TPTxGkgEzwy2Y,14193
+canbiplotme/datasets/__init__.py,sha256=gcX9ECNBsGZ4f-SIZF-lz73wdTQEjGaXXSpNwp27lQE,2688
+canbiplotme/datasets/gcb_trade.npz,sha256=oSWUy9DPjpHzCuP-3rSIaH8TkNtLhsmkZ40BO5lCfdQ,699067
+canbiplotme/datasets/gcb_trade_a21.npz,sha256=m7dBHbpJkzx-hTxE-6fxX8DjbwrM0B5OEjx5ML8LVZo,699580
+canbiplotme/datasets/sim_me.npz,sha256=xXLuoNkXmQKtn41lrk7-4gZJCEi-l4JP72N03_PYgsY,128338
+canbiplotme/datasets/sim_trade.csv,sha256=9qegJSkU9iTOqbtbQxbtCbjKQbwduZX1QQASoR_AQnk,120664
+canbiplotme-0.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+canbiplotme-0.3.0.dist-info/METADATA,sha256=kA395qIeHJS3ttzbufwKdpPd87hfWgSnLOdCStiNeTk,4773
+canbiplotme-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+canbiplotme-0.3.0.dist-info/top_level.txt,sha256=VsxDhM0lVq9n4PGzIucb_XheIKROJ7Zzhbgbz_ysxAI,12
+canbiplotme-0.3.0.dist-info/RECORD,,

canbiplotme-0.3.0.dist-info/WHEEL

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