barnard-exact 0.1.0__tar.gz

barnard_exact-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Groundplane Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

barnard_exact-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: barnard-exact
+Version: 0.1.0
+Summary: Barnard's and Boschloo's exact tests for 2x2 tables (free core)
+Author: Groundplane Labs
+License: MIT
+Project-URL: Homepage, https://groundplane0.gumroad.com/l/conxfk
+Keywords: barnard test,boschloo test,exact test,fisher exact test,statistics,biostatistics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# barnard-exact
+
+Free core of Barnard: Barnard's and Boschloo's exact tests for 2x2 tables.
+
+**The problem**
+You ran a small 2x2 experiment and Fisher's exact test came back just above your threshold. Fisher's test conditions on the total number of successes, which your experiment never fixed in advance, and that conditioning throws away power. scipy does not implement the unconditional alternatives. Search terms: Barnard test Python pip, Boschloo test Python, Barnard exact test 2x2.
+
+**What it does**
+`barnard_test(table)` and `boschloo_test(table)` compute the exact unconditional two-sided p-values, maximized over the nuisance parameter, with ties classified in exact integer arithmetic. Boschloo's never returns a larger p-value than Fisher's exact test. Both are validated against published reference values. The free version handles total N up to 200.
+
+**Limits**
+Free version: total N <= 200. Larger tables are refused outright instead of hanging. No CLI, no plots, no batch mode.
+
+**Install**
+
+```bash
+pip install barnard-exact
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from barnard_exact import barnard_test, boschloo_test
+print(barnard_test([[7, 12], [3, 18]]))
+print(boschloo_test([[7, 12], [3, 18]]))
+```
+
+This is the free core: Barnard's and Boschloo's exact tests for 2x2 tables, capped at total N <= 200. The full version ($30, one-time) is uncapped: https://groundplane0.gumroad.com/l/conxfk

barnard_exact-0.1.0/README.md

@@ -0,0 +1,28 @@
+# barnard-exact
+
+Free core of Barnard: Barnard's and Boschloo's exact tests for 2x2 tables.
+
+**The problem**
+You ran a small 2x2 experiment and Fisher's exact test came back just above your threshold. Fisher's test conditions on the total number of successes, which your experiment never fixed in advance, and that conditioning throws away power. scipy does not implement the unconditional alternatives. Search terms: Barnard test Python pip, Boschloo test Python, Barnard exact test 2x2.
+
+**What it does**
+`barnard_test(table)` and `boschloo_test(table)` compute the exact unconditional two-sided p-values, maximized over the nuisance parameter, with ties classified in exact integer arithmetic. Boschloo's never returns a larger p-value than Fisher's exact test. Both are validated against published reference values. The free version handles total N up to 200.
+
+**Limits**
+Free version: total N <= 200. Larger tables are refused outright instead of hanging. No CLI, no plots, no batch mode.
+
+**Install**
+
+```bash
+pip install barnard-exact
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from barnard_exact import barnard_test, boschloo_test
+print(barnard_test([[7, 12], [3, 18]]))
+print(boschloo_test([[7, 12], [3, 18]]))
+```
+
+This is the free core: Barnard's and Boschloo's exact tests for 2x2 tables, capped at total N <= 200. The full version ($30, one-time) is uncapped: https://groundplane0.gumroad.com/l/conxfk

barnard_exact-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "barnard-exact"
+version = "0.1.0"
+description = "Barnard's and Boschloo's exact tests for 2x2 tables (free core)"
+readme = "README.md"
+authors = [{name = "Groundplane Labs"}]
+license = {text = "MIT"}
+requires-python = ">=3.9"
+dependencies = ["numpy", "scipy"]
+keywords = ["barnard test", "boschloo test", "exact test", "fisher exact test", "statistics", "biostatistics"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://groundplane0.gumroad.com/l/conxfk"
+
+[tool.setuptools.packages.find]
+where = ["src"]

barnard_exact-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

barnard_exact-0.1.0/src/barnard_exact/__init__.py

@@ -0,0 +1,7 @@
+"""barnard_exact: Barnard's and Boschloo's exact tests for 2x2 tables (free core)."""
+
+from ._exact import FREE_MAX_N, barnard_test, boschloo_test
+
+__version__ = "0.1.0"
+
+__all__ = ["barnard_test", "boschloo_test", "FREE_MAX_N", "__version__"]

barnard_exact-0.1.0/src/barnard_exact/_core.py

@@ -0,0 +1,284 @@
+"""Core machinery for unconditional exact tests of 2x2 tables (free core).
+
+Implements the classical mathematics behind the tests:
+
+* Barnard's exact test: order all tables with the observed row totals by
+  the pooled Wald statistic
+
+      T = (x1/n1 - x2/n2) / sqrt(p_pool (1-p_pool) (1/n1 + 1/n2)),
+
+  with p_pool = (x1 + x2) / (n1 + n2).  The two-sided p-value is
+
+      max_{pi in [0,1]} P(|T| >= |t_obs| | pi),
+
+  where under the null each row is Binomial(n_i, pi) independently.
+
+* Boschloo's exact test: use Fisher's exact two-sided p-value of each
+  table as the test statistic B.  The p-value is
+
+      max_{pi in [0,1]} P(B <= b_obs | pi)
+
+  with the same binomial-product probabilities.
+
+Because the rejection region is fixed (the test statistic does not depend
+on the nuisance parameter pi), the tail probability being maximized is a
+*polynomial* in pi (degree n1+n2).  It is maximized by a fine grid plus
+local Brent refinement of the best candidates.
+"""
+
+import math
+
+import numpy as np
+from scipy.optimize import minimize_scalar
+
+__all__ = [
+    "_validate_table",
+    "_barnard_region_twosided_exact",
+    "_fisher_twosided_grid",
+    "_exact_fisher_le",
+    "_TailProb",
+    "_maximize_over_pi",
+]
+
+
+def _validate_table(table):
+    """Validate a 2x2 table of counts; return (a, b, c, d, n1, n2) as ints.
+
+    Anything that is not a 2x2 array of nonnegative integers (fractional
+    entries, negatives, NaN/inf, wrong shape, non-numeric input) raises
+    ValueError loudly.  Nothing is silently coerced or truncated.
+    """
+    try:
+        T = np.asarray(table)
+    except Exception as exc:
+        raise ValueError(f"table could not be interpreted as an array: {exc}")
+    if T.dtype == object:
+        # e.g. ragged input like [[1, 2], [3]]; asarray gives object dtype
+        raise ValueError("table must be a 2x2 array of counts")
+    if T.dtype.kind == "b":
+        raise ValueError("table entries must be integer counts, not booleans")
+    if T.dtype.kind == "c":
+        raise ValueError("table entries must be real counts, not complex")
+    if T.dtype.kind not in "iuf":
+        raise ValueError("table entries must be numeric counts")
+    if T.ndim != 2 or T.shape != (2, 2):
+        raise ValueError(f"table must be 2x2, got shape {T.shape}")
+    if not np.all(np.isfinite(T)):
+        raise ValueError("table entries must be finite (no NaN or inf)")
+    if np.any(T < 0):
+        raise ValueError("table entries must be nonnegative")
+    if not np.all(np.equal(np.mod(T, 1), 0)):
+        raise ValueError("table entries must be integers (no fractional counts)")
+    a, b, c, d = (int(v) for v in T.flat)
+    return a, b, c, d, a + b, c + d
+
+
+def _log_binom_coefs(n):
+    """log C(n, k) for k = 0..n (float array)."""
+    ks = np.arange(n + 1, dtype=float)
+    return (
+        math.lgamma(n + 1)
+        - np.array([math.lgamma(k + 1) for k in ks])
+        - np.array([math.lgamma(n - k + 1) for k in ks])
+    )
+
+
+def _fisher_twosided_grid(n1, n2):
+    """Two-sided Fisher exact p-value for every table with row totals n1, n2.
+
+    Each table (x1, x2) is scored under its own column margin s = x1 + x2:
+    with the hypergeometric law Hypergeometric(N, n1, s), the p-value is the
+    total probability of tables whose probability is <= the observed table's
+    (Fisher's "minimum likelihood" ordering).  Tie classification uses exact
+    integer arithmetic on the weights C(n1,x1)*C(n2,s-x1), so no
+    floating-point tolerance decides extremeness.
+    """
+    N = n1 + n2
+    lg1 = _log_binom_coefs(n1)
+    lg2 = _log_binom_coefs(n2)
+    lgN = math.lgamma(N + 1)
+    F = np.empty((n1 + 1, n2 + 1))
+    for s in range(N + 1):
+        lo = max(0, s - n2)
+        hi = min(n1, s)
+        xs = np.arange(lo, hi + 1)
+        x2s = s - xs
+        lp = lg1[xs] + lg2[x2s] - (lgN - math.lgamma(s + 1) - math.lgamma(N - s + 1))
+        # Exact tie weights (integers): P(x) <= P(y)  <=>  w(x) >= w(y).
+        w = [math.comb(n1, int(x)) * math.comb(n2, int(s - x)) for x in xs]
+        order = sorted(range(len(xs)), key=lambda i: w[i])
+        pmf = np.exp(lp - lp.max())
+        pmf /= pmf.sum()
+        spo = pmf[order]
+        cso = np.cumsum(spo)
+        fp = np.empty(len(xs))
+        j = 0
+        while j < len(xs):
+            k = j
+            while k + 1 < len(xs) and w[order[k + 1]] == w[order[j]]:
+                k += 1
+            # tied tables share the largest cumulative probability
+            fp[[order[t] for t in range(j, k + 1)]] = cso[k]
+            j = k + 1
+        F[xs, x2s] = fp
+    return F
+
+
+def _exact_fisher_margin(n1, n2, s, direction):
+    """Exact rational Fisher p-values for every x1 on column margin s.
+
+    Returns ``(A, D)`` with ``p(x1) == A[x1] / D`` exactly, as Python
+    integers.  ``direction`` is ``"minlike"`` (two-sided
+    minimum-likelihood ordering).  Used to resolve cross-margin ties that
+    floating point cannot decide.
+    """
+    N = n1 + n2
+    lo, hi = max(0, s - n2), min(n1, s)
+    ys = list(range(lo, hi + 1))
+    ws = [math.comb(n1, y) * math.comb(n2, s - y) for y in ys]
+    D = math.comb(N, s)
+    A = {}
+    if direction == "minlike":
+        # group tied weights: A(w) = sum of weights <= w (minimum-
+        # likelihood ordering sums the probabilities of tables no more
+        # likely than the observed one)
+        pairs = sorted(zip(ws, ys), key=lambda t: t[0])
+        run = 0
+        i = 0
+        while i < len(pairs):
+            j = i
+            while j < len(pairs) and pairs[j][0] == pairs[i][0]:
+                j += 1
+            run += sum(w for w, _ in pairs[i:j])
+            for _, y in pairs[i:j]:
+                A[y] = run
+            i = j
+    else:
+        raise ValueError("direction must be 'minlike'")
+    return A, D
+
+
+def _exact_fisher_le(n1, n2, mask, a_obs, s_obs, direction):
+    """Decide ``F(t) <= F(obs)`` exactly for cells where ``mask`` is True.
+
+    Compares exact rational Fisher p-values by integer
+    cross-multiplication (``A_t * D_obs <= A_obs * D_s``), so
+    cross-margin ties are never misclassified by floating-point noise.
+    Cells where ``mask`` is False are False in the output.
+    """
+    A_obs_d, D_obs = _exact_fisher_margin(n1, n2, s_obs, direction)
+    A_obs = A_obs_d[a_obs]
+    out = np.zeros_like(mask)
+    cache = {}
+    for x1, x2 in np.argwhere(mask):
+        x1, x2 = int(x1), int(x2)
+        s = x1 + x2
+        if s not in cache:
+            cache[s] = _exact_fisher_margin(n1, n2, s, direction)
+        A_d, D_s = cache[s]
+        if A_d[x1] * D_obs <= A_obs * D_s:
+            out[x1, x2] = True
+    return out
+
+
+def _wald_t2_num_den(x1, x2, n1, n2):
+    """Exact integer numerator/denominator of the squared pooled Wald statistic.
+
+    T(x1, x2)^2 = num / den, where with s = x1 + x2 and N = n1 + n2::
+
+        num = (x1*n2 - x2*n1)^2
+        den = s * (N - s)
+
+    (the factors N, n1, n2 cancel in any ratio comparison).  A zero
+    denominator means T = 0 (the numerator is zero too in that case).
+    All values are Python integers: comparisons of squared statistics are
+    exact, so tied tables are never misclassified by floating-point noise.
+    """
+    s = x1 + x2
+    return (x1 * n2 - x2 * n1) ** 2, s * (n1 + n2 - s)
+
+
+def _barnard_region_twosided_exact(a, b, c, d, n1, n2):
+    """|T| >= |t_obs| region via exact integer arithmetic (no float ties)."""
+    num0, den0 = _wald_t2_num_den(a, c, n1, n2)
+    x1 = np.arange(n1 + 1, dtype=object)[:, None]
+    x2 = np.arange(n2 + 1, dtype=object)[None, :]
+    num1, den1 = _wald_t2_num_den(x1, x2, n1, n2)
+    if num0 == 0 or den0 == 0:
+        # t_obs == 0: every table is at least as extreme
+        return np.ones((n1 + 1, n2 + 1), dtype=bool)
+    with np.errstate(all="ignore"):
+        # den1 == 0  ->  T = 0 < |t_obs|  ->  excluded
+        region = np.logical_and(den1 != 0, num1 * den0 >= num0 * den1)
+    return np.asarray(region, dtype=bool)
+
+
+class _TailProb:
+    """Tail probability P(region | pi) as a callable of pi in [0, 1].
+
+    Precomputes the log binomial coefficients and the sufficient statistic
+    S = x1 + x2 over the rejection region, so each evaluation is a single
+    vectorized log-sum-exp: O(|region|) work.  pi = 0 and pi = 1 are handled
+    exactly (only the all-failure / all-success table has mass there).
+    """
+
+    def __init__(self, n1, n2, region):
+        self._n = n1 + n2
+        x1 = np.arange(n1 + 1)[:, None]
+        x2 = np.arange(n2 + 1)[None, :]
+        lg1 = _log_binom_coefs(n1)[:, None]
+        lg2 = _log_binom_coefs(n2)[None, :]
+        self._K = (lg1 + lg2)[region].astype(float)
+        self._S = (x1 + x2)[region].astype(float)
+        self._p0 = 1.0 if bool((self._S == 0).any()) else 0.0
+        self._p1 = 1.0 if bool((self._S == self._n).any()) else 0.0
+
+    def __call__(self, pi):
+        if self._K.size == 0:
+            return 0.0
+        if pi <= 0.0:
+            return self._p0
+        if pi >= 1.0:
+            return self._p1
+        lp = self._K + self._S * math.log(pi) + (self._n - self._S) * math.log1p(-pi)
+        m = float(lp.max())
+        return float(np.exp(lp - m).sum() * math.exp(m))
+
+
+def _maximize_over_pi(tail, n_grid=2001, n_refine=32):
+    """max_{pi in [0,1]} tail(pi): dense grid plus Brent local refinement.
+
+    The tail probability is a polynomial in pi (the rejection region is
+    fixed), so it is smooth; still, narrow peaks are possible, hence the
+    fine grid plus bounded Brent refinement around the best candidates.
+    Deterministic: same input always gives the same output.
+    """
+    pis = np.linspace(0.0, 1.0, n_grid)
+    vals = np.empty(n_grid)
+    for i, pi in enumerate(pis):
+        vals[i] = tail(pi)
+    best = float(vals.max())
+    h = 1.0 / (n_grid - 1)
+    order = np.argsort(vals, kind="stable")
+    blocked = np.zeros(n_grid, dtype=bool)
+    done = 0
+    for i in order[::-1]:
+        if done >= n_refine:
+            break
+        if blocked[i]:
+            continue
+        blocked[max(0, i - 2) : i + 3] = True
+        done += 1
+        lo = max(0.0, pis[i] - 3 * h)
+        hi = min(1.0, pis[i] + 3 * h)
+        if hi <= lo:
+            continue
+        res = minimize_scalar(
+            lambda p: -tail(p),
+            bounds=(lo, hi),
+            method="bounded",
+            options={"xatol": 1e-13, "maxiter": 300},
+        )
+        if math.isfinite(res.fun) and -res.fun > best:
+            best = -res.fun
+    return min(1.0, max(0.0, best))

barnard_exact-0.1.0/src/barnard_exact/_exact.py

@@ -0,0 +1,138 @@
+"""Barnard's and Boschloo's exact unconditional tests for 2x2 tables (free core).
+
+Both tests condition only on the row totals (the two sample sizes) and
+treat the column totals as random.  Under the null hypothesis of equal
+success probabilities, each row is Binomial(n_i, pi) independently, with
+the common success probability pi an unknown *nuisance parameter*.  The
+p-value is the worst case over pi in [0, 1] of the tail probability.
+
+:func:`barnard_test` orders tables by the pooled Wald statistic and is
+two-sided by test-statistic ordering: the p-value is
+max_pi P(|T| >= |t_obs| | pi).
+
+:func:`boschloo_test` uses Fisher's exact two-sided p-value of each table
+as the test statistic B; the p-value is max_pi P(B <= b_obs | pi).
+Boschloo's test is uniformly at least as powerful as Fisher's exact test:
+on every table its p-value is <= Fisher's.
+"""
+
+import numpy as np
+
+from ._core import (
+    _barnard_region_twosided_exact,
+    _exact_fisher_le,
+    _fisher_twosided_grid,
+    _maximize_over_pi,
+    _TailProb,
+    _validate_table,
+)
+
+__all__ = ["barnard_test", "boschloo_test", "FREE_MAX_N"]
+
+#: Hard cap on the total sample size (n1 + n2) in the free version.
+#: Beyond this the functions raise ValueError immediately instead of
+#: attempting the calculation.
+FREE_MAX_N = 200
+
+_PAID_URL = "https://groundplane0.gumroad.com/l/conxfk"
+
+
+def _check_free_cap(n1, n2):
+    if n1 + n2 > FREE_MAX_N:
+        raise ValueError(
+            f"Free version is capped at total N <= {FREE_MAX_N}. "
+            f"The full version ($30, one-time) is uncapped: {_PAID_URL}"
+        )
+
+
+def _unconditional_pvalue(table, region_fn):
+    """Shared engine: build the rejection region, maximize over pi."""
+    a, b, c, d, n1, n2 = _validate_table(table)
+    _check_free_cap(n1, n2)
+    if n1 == 0 or n2 == 0:
+        # A group with no observations carries no information about its
+        # success probability; there is nothing to test.
+        return 1.0
+    region = region_fn(a, b, c, d, n1, n2)
+    tail = _TailProb(n1, n2, region)
+    return _maximize_over_pi(tail)
+
+
+def _barnard_region_twosided(a, b, c, d, n1, n2):
+    # Exact integer tie classification: tables tied with the observed
+    # table are always counted as "as extreme".
+    return _barnard_region_twosided_exact(a, b, c, d, n1, n2)
+
+
+def _band_region(F, f_obs, a, b, c, n1, n2, direction):
+    # Float comparison is reliable outside a 1e-9 relative band (the float
+    # error in these normalized sums is ~1e-14).  Cells inside the band,
+    # true cross-margin ties plus float dust, are decided by exact
+    # integer arithmetic.
+    lo = f_obs * (1.0 - 1e-9)
+    hi = f_obs * (1.0 + 1e-9)
+    region = F <= lo
+    band = (F > lo) & (F <= hi)
+    if band.any():
+        region = region | _exact_fisher_le(n1, n2, band, a, a + c, direction)
+    return region
+
+
+def _boschloo_region_twosided(a, b, c, d, n1, n2):
+    F = _fisher_twosided_grid(n1, n2)
+    return _band_region(F, F[a, c], a, b, c, n1, n2, "minlike")
+
+
+def barnard_test(table):
+    """Barnard's exact unconditional test for a 2x2 table (two-sided).
+
+    Parameters
+    ----------
+    table : array_like, shape (2, 2)
+        Observed counts ``[[a, b], [c, d]]`` (nonnegative integers).
+        Rows are the two groups; only the row totals are conditioned on.
+        The free version requires total N = n1 + n2 <= 200.
+
+    Returns
+    -------
+    float
+        Two-sided exact p-value: max over the nuisance parameter pi in
+        [0, 1] of the null probability (independent Binomial(n1, pi) x
+        Binomial(n2, pi)) of tables whose absolute pooled Wald statistic
+        is at least as large as the observed table's.
+
+    Notes
+    -----
+    Two-sidedness is by test-statistic ordering (|T| >= |t_obs|), not by
+    doubling a one-sided p-value.  Tables with a zero row total return 1.0
+    (no information).
+    """
+    return _unconditional_pvalue(table, _barnard_region_twosided)
+
+
+def boschloo_test(table):
+    """Boschloo's exact unconditional test for a 2x2 table (two-sided).
+
+    Parameters
+    ----------
+    table : array_like, shape (2, 2)
+        Observed counts ``[[a, b], [c, d]]`` (nonnegative integers).
+        Rows are the two groups; only the row totals are conditioned on.
+        The free version requires total N = n1 + n2 <= 200.
+
+    Returns
+    -------
+    float
+        Two-sided exact p-value: max over pi in [0, 1] of the null
+        probability of tables whose Fisher exact two-sided p-value is no
+        larger than the observed table's.  Always <= the Fisher exact
+        two-sided p-value of the same table.
+
+    Notes
+    -----
+    Fisher's two-sided p-value here uses the minimum-likelihood ordering
+    (sum of hypergeometric probabilities <= the observed table's), with
+    ties classified in exact integer arithmetic.  Tables with a zero row
+    total return 1.0.
+    """
+    return _unconditional_pvalue(table, _boschloo_region_twosided)

barnard_exact-0.1.0/src/barnard_exact.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: barnard-exact
+Version: 0.1.0
+Summary: Barnard's and Boschloo's exact tests for 2x2 tables (free core)
+Author: Groundplane Labs
+License: MIT
+Project-URL: Homepage, https://groundplane0.gumroad.com/l/conxfk
+Keywords: barnard test,boschloo test,exact test,fisher exact test,statistics,biostatistics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# barnard-exact
+
+Free core of Barnard: Barnard's and Boschloo's exact tests for 2x2 tables.
+
+**The problem**
+You ran a small 2x2 experiment and Fisher's exact test came back just above your threshold. Fisher's test conditions on the total number of successes, which your experiment never fixed in advance, and that conditioning throws away power. scipy does not implement the unconditional alternatives. Search terms: Barnard test Python pip, Boschloo test Python, Barnard exact test 2x2.
+
+**What it does**
+`barnard_test(table)` and `boschloo_test(table)` compute the exact unconditional two-sided p-values, maximized over the nuisance parameter, with ties classified in exact integer arithmetic. Boschloo's never returns a larger p-value than Fisher's exact test. Both are validated against published reference values. The free version handles total N up to 200.
+
+**Limits**
+Free version: total N <= 200. Larger tables are refused outright instead of hanging. No CLI, no plots, no batch mode.
+
+**Install**
+
+```bash
+pip install barnard-exact
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from barnard_exact import barnard_test, boschloo_test
+print(barnard_test([[7, 12], [3, 18]]))
+print(boschloo_test([[7, 12], [3, 18]]))
+```
+
+This is the free core: Barnard's and Boschloo's exact tests for 2x2 tables, capped at total N <= 200. The full version ($30, one-time) is uncapped: https://groundplane0.gumroad.com/l/conxfk

barnard_exact-0.1.0/src/barnard_exact.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/barnard_exact/__init__.py
+src/barnard_exact/_core.py
+src/barnard_exact/_exact.py
+src/barnard_exact.egg-info/PKG-INFO
+src/barnard_exact.egg-info/SOURCES.txt
+src/barnard_exact.egg-info/dependency_links.txt
+src/barnard_exact.egg-info/requires.txt
+src/barnard_exact.egg-info/top_level.txt
+tests/test_free.py

barnard_exact-0.1.0/src/barnard_exact.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+numpy
+scipy

barnard_exact-0.1.0/src/barnard_exact.egg-info/top_level.txt

@@ -0,0 +1 @@
+barnard_exact

barnard_exact-0.1.0/tests/test_free.py

@@ -0,0 +1,133 @@
+"""Tests for the free barnard_exact core.
+
+Correctness is checked against the paid package (imported from its own
+source tree, never copied).  Cap behavior and input validation are
+checked directly.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import barnard_exact
+
+HERE = Path(__file__).resolve().parent
+PAID_SRC = HERE.parent.parent.parent / "barnard" / "src" / "barnard"
+
+
+def _load_paid():
+    spec = importlib.util.spec_from_file_location(
+        "paid_barnard",
+        PAID_SRC / "__init__.py",
+        submodule_search_locations=[str(PAID_SRC)],
+    )
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["paid_barnard"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+paid = _load_paid()
+
+PAID_URL = "https://groundplane0.gumroad.com/l/conxfk"
+
+TABLES = [
+    [[2, 3], [3, 2]],
+    [[7, 12], [3, 18]],
+    [[1, 9], [11, 3]],
+    [[8, 2], [1, 5]],
+    [[0, 5], [5, 0]],
+    [[10, 0], [0, 10]],
+    [[40, 10], [30, 20]],
+    [[0, 0], [5, 5]],      # zero row total -> 1.0
+    [[25, 25], [25, 25]],
+]
+
+
+def test_matches_paid_exactly():
+    for t in TABLES:
+        for free_fn, paid_fn in (
+            (barnard_exact.barnard_test, paid.barnard_test),
+            (barnard_exact.boschloo_test, paid.boschloo_test),
+        ):
+            assert free_fn(t) == pytest.approx(paid_fn(t), rel=1e-9), t
+
+
+def test_matches_paid_on_random_tables():
+    rng = np.random.default_rng(3)
+    for _ in range(15):
+        t = rng.integers(0, 40, size=(2, 2)).tolist()
+        assert barnard_exact.barnard_test(t) == pytest.approx(
+            paid.barnard_test(t), rel=1e-9
+        )
+        assert barnard_exact.boschloo_test(t) == pytest.approx(
+            paid.boschloo_test(t), rel=1e-9
+        )
+
+
+def test_over_cap_refuses_loudly():
+    big = [[61, 40], [55, 45]]  # N = 201
+    for fn in (barnard_exact.barnard_test, barnard_exact.boschloo_test):
+        with pytest.raises(ValueError, match="total N <= 200"):
+            fn(big)
+        try:
+            fn(big)
+        except ValueError as e:
+            assert PAID_URL in str(e)
+            assert "30" in str(e)
+
+
+def test_at_cap_still_works():
+    t = [[60, 40], [55, 45]]  # N = 200
+    assert barnard_exact.barnard_test(t) == pytest.approx(
+        paid.barnard_test(t), rel=1e-9
+    )
+    assert barnard_exact.boschloo_test(t) == pytest.approx(
+        paid.boschloo_test(t), rel=1e-9
+    )
+
+
+@pytest.mark.parametrize(
+    "bad",
+    [
+        [[1.5, 2], [3, 4]],      # fractional
+        [[-1, 2], [3, 4]],       # negative
+        [[1, 2, 3], [4, 5, 6]],  # wrong shape
+        [[1, 2]],                # not 2x2
+        [[float("nan"), 2], [3, 4]],
+        [[float("inf"), 2], [3, 4]],
+        [[True, False], [True, True]],  # booleans
+        "not a table",
+    ],
+)
+def test_garbage_raises(bad):
+    for fn in (barnard_exact.barnard_test, barnard_exact.boschloo_test):
+        with pytest.raises(ValueError):
+            fn(bad)
+
+
+def test_paid_only_symbols_absent():
+    assert set(barnard_exact.__all__) == {
+        "barnard_test",
+        "boschloo_test",
+        "FREE_MAX_N",
+        "__version__",
+    }
+    for name in ("_barnard_onesided", "_boschloo_onesided", "_fisher_twosided"):
+        assert not hasattr(barnard_exact, name), name
+
+
+def test_free_cap_constant():
+    assert barnard_exact.FREE_MAX_N == 200
+
+
+def test_pvalues_in_unit_interval():
+    rng = np.random.default_rng(9)
+    for _ in range(15):
+        t = rng.integers(0, 30, size=(2, 2)).tolist()
+        for fn in (barnard_exact.barnard_test, barnard_exact.boschloo_test):
+            p = fn(t)
+            assert 0.0 <= p <= 1.0