exactpower 0.1.0__tar.gz

exactpower-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.

exactpower-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: exactpower
+Version: 0.1.0
+Summary: Exact power of Fisher's exact test for a planned 2x2 study (free core)
+Author: Groundplane Labs
+License: MIT
+Project-URL: Homepage, https://groundplane0.gumroad.com/l/tyevqe
+Keywords: power analysis,sample size,fisher exact test,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
+
+# exactpower
+
+Free core of ExactPower: exact power of Fisher's exact test for a planned 2x2 study.
+
+**The problem**
+You are planning a study with two groups and a yes/no outcome, and you need to pick a sample size before you collect data. The usual power calculators use approximations that drift exactly where small samples matter most. Search terms: exact power Fisher test Python, sample size Fisher exact test, power analysis 2x2 Python.
+
+**What it does**
+`exact_power_fisher(n1, n2, p1, p2)` computes the exact rejection probability of the two-sided Fisher exact test under your planned design. Give it the group sizes and the event rates you expect, and it enumerates every possible outcome. No approximation, no simulation. The free version handles n1 + n2 up to 1000.
+
+**Limits**
+Free version: two-sided power only, n1 + n2 <= 1000. Larger studies are refused outright instead of hanging. No sample-size inversion, no Monte Carlo power estimator, no plots, no CLI.
+
+**Install**
+
+```bash
+pip install exactpower
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from exactpower import exact_power_fisher
+print(exact_power_fisher(60, 60, 0.55, 0.30))
+```
+
+This is the free core: two-sided exact power for a planned 2x2 design, capped at n1 + n2 <= 1000. The full version ($30, one-time) goes to n1 + n2 = 5000 and adds sample-size inversion, Monte Carlo power for r-by-c tables, and one-sided power: https://groundplane0.gumroad.com/l/tyevqe

exactpower-0.1.0/README.md

@@ -0,0 +1,27 @@
+# exactpower
+
+Free core of ExactPower: exact power of Fisher's exact test for a planned 2x2 study.
+
+**The problem**
+You are planning a study with two groups and a yes/no outcome, and you need to pick a sample size before you collect data. The usual power calculators use approximations that drift exactly where small samples matter most. Search terms: exact power Fisher test Python, sample size Fisher exact test, power analysis 2x2 Python.
+
+**What it does**
+`exact_power_fisher(n1, n2, p1, p2)` computes the exact rejection probability of the two-sided Fisher exact test under your planned design. Give it the group sizes and the event rates you expect, and it enumerates every possible outcome. No approximation, no simulation. The free version handles n1 + n2 up to 1000.
+
+**Limits**
+Free version: two-sided power only, n1 + n2 <= 1000. Larger studies are refused outright instead of hanging. No sample-size inversion, no Monte Carlo power estimator, no plots, no CLI.
+
+**Install**
+
+```bash
+pip install exactpower
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from exactpower import exact_power_fisher
+print(exact_power_fisher(60, 60, 0.55, 0.30))
+```
+
+This is the free core: two-sided exact power for a planned 2x2 design, capped at n1 + n2 <= 1000. The full version ($30, one-time) goes to n1 + n2 = 5000 and adds sample-size inversion, Monte Carlo power for r-by-c tables, and one-sided power: https://groundplane0.gumroad.com/l/tyevqe

exactpower-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "exactpower"
+version = "0.1.0"
+description = "Exact power of Fisher's exact test for a planned 2x2 study (free core)"
+readme = "README.md"
+authors = [{name = "Groundplane Labs"}]
+license = {text = "MIT"}
+requires-python = ">=3.9"
+dependencies = ["numpy", "scipy"]
+keywords = ["power analysis", "sample size", "fisher exact test", "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/tyevqe"
+
+[tool.setuptools.packages.find]
+where = ["src"]

exactpower-0.1.0/setup.cfg

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

exactpower-0.1.0/src/exactpower/__init__.py

@@ -0,0 +1,7 @@
+"""exactpower: exact power of Fisher's exact test (free core)."""
+
+from ._power import FREE_MAX_TOTAL_N, exact_power_fisher
+
+__version__ = "0.1.0"
+
+__all__ = ["exact_power_fisher", "FREE_MAX_TOTAL_N", "__version__"]

exactpower-0.1.0/src/exactpower/_fisher.py

@@ -0,0 +1,65 @@
+"""Vectorized floating-point kernels for the free exactpower core.
+
+:func:`hypergeom_pmf` builds the hypergeometric null pmf in log-space
+(via ``scipy.special.gammaln``) with the mode subtracted before
+exponentiating, so the result is finite and correctly normalized for
+large N.  :func:`minlike_pvalues` turns a pmf into two-sided
+(minimum-likelihood) p-values, grouping probabilities that agree to
+1e-9 relative as ties (the hypergeometric pmf has exact rational ties
+that floating point renders as differing by ~1e-17).
+"""
+
+import numpy as np
+from scipy.special import gammaln
+
+__all__ = ["hypergeom_pmf", "minlike_pvalues"]
+
+
+def hypergeom_pmf(N, K, n):
+    """Pmf of X ~ Hypergeometric(N, K, n) over its full support.
+
+    Returns ``(xs, pmf)`` with ``xs`` the support points (int array) and
+    ``pmf`` the probabilities (float array, sums to 1).
+    """
+    lo = max(0, n + K - N)
+    hi = min(n, K)
+    xs = np.arange(lo, hi + 1)
+    if xs.size == 1:
+        return xs, np.ones(1)
+    x = xs.astype(np.float64)
+    # log P(X = x) = log C(K, x) + log C(N-K, n-x) - log C(N, n).
+    # All gammaln arguments are >= 1 on the support, so this is safe.
+    logp = (
+        gammaln(K + 1) - gammaln(x + 1) - gammaln(K - x + 1)
+        + gammaln(N - K + 1) - gammaln(n - x + 1) - gammaln(N - K - n + x + 1)
+        - (gammaln(N + 1) - gammaln(n + 1) - gammaln(N - n + 1))
+    )
+    logp -= logp.max()
+    pmf = np.exp(logp)
+    total = pmf.sum()
+    if not np.isfinite(total) or total <= 0.0:  # pragma: no cover
+        raise ArithmeticError("hypergeom_pmf failed to normalize")
+    pmf /= total
+    return xs, pmf
+
+
+def minlike_pvalues(pmf):
+    """Two-sided (minimum-likelihood) p-value for each support point.
+
+    For support point i, returns the total probability of all support
+    points whose probability is <= pmf[i].  Probabilities that agree to
+    1e-9 relative are treated as tied.
+    """
+    pmf = np.asarray(pmf, dtype=float)
+    order = np.argsort(pmf)
+    s = pmf[order]
+    prev = s[:-1]
+    cur = s[1:]
+    same = cur <= prev * (1.0 + 1e-9) + 1e-300
+    gid = np.concatenate(([0], np.cumsum(~same)))
+    gsum = np.bincount(gid, weights=s)
+    gc = np.cumsum(gsum)
+    p_sorted = gc[gid]
+    inv = np.empty_like(order)
+    inv[order] = np.arange(len(s))
+    return p_sorted[inv]

exactpower-0.1.0/src/exactpower/_power.py

@@ -0,0 +1,133 @@
+"""Exact power of Fisher's exact test for a planned 2x2 study (free core).
+
+The power law
+-------------
+Group sizes ``n1`` and ``n2`` are fixed by the study design; the event
+counts are random.  The alternative is the **binomial-product law**
+
+    A ~ Binomial(n1, p1),  B ~ Binomial(n2, p2),  independent,
+
+i.e. the exact law of the data in a two-group comparative study.  The
+test itself conditions on the total number of events, as Fisher's test
+always does; the power does not, because the total is not fixed by the
+design.
+
+Exact power is then the expected rejection probability under the
+alternative:
+
+    power = sum_{a=0..n1} sum_{b=0..n2}
+            Bin(n1,p1)(a) * Bin(n2,p2)(b) * 1{p_F(a, b) <= alpha},
+
+where ``p_F(a, b)`` is the two-sided Fisher p-value of the 2x2 table
+``[[a, n1-a], [b, n2-b]]``.
+
+Computation groups outcome pairs by the total event count m1 = a + b;
+for each m1 the hypergeometric null pmf is built once and the two-sided
+p-values come from a sort/cumulative-sum pass.
+"""
+
+import numpy as np
+from scipy.stats import binom
+
+from ._fisher import hypergeom_pmf, minlike_pvalues
+from ._validate import (
+    check_alpha,
+    check_alternative,
+    check_group_size,
+    check_prob,
+)
+
+__all__ = ["exact_power_fisher", "FREE_MAX_TOTAL_N"]
+
+#: Hard cap on n1 + n2 in the free version.  Beyond this the function
+#: raises ValueError immediately instead of attempting the calculation.
+FREE_MAX_TOTAL_N = 1000
+
+_PAID_URL = "https://groundplane0.gumroad.com/l/tyevqe"
+
+
+def _resolve_probs(p1, p2, odds_ratio):
+    """Turn (p1, p2) or (odds_ratio, p2) into a validated (p1, p2) pair."""
+    if odds_ratio is not None:
+        if p1 is not None:
+            raise ValueError("specify either p1 or odds_ratio, not both")
+        if p2 is None:
+            raise ValueError("odds_ratio requires p2 (the reference-group probability)")
+        import math
+
+        if not isinstance(odds_ratio, (int, float)) or isinstance(odds_ratio, bool):
+            raise ValueError(f"odds_ratio must be a positive number, got {odds_ratio!r}")
+        odds_ratio = float(odds_ratio)
+        if math.isnan(odds_ratio) or not (odds_ratio > 0.0) or math.isinf(odds_ratio):
+            raise ValueError(f"odds_ratio must be a positive finite number, got {odds_ratio!r}")
+        p2 = check_prob(p2, "p2")
+        # OR = [p1/(1-p1)] / [p2/(1-p2)]  =>  p1 = OR*p2 / (1-p2+OR*p2)
+        p1 = odds_ratio * p2 / (1.0 - p2 + odds_ratio * p2)
+        return p1, p2
+    if p1 is None or p2 is None:
+        raise ValueError("specify p1 and p2, or odds_ratio together with p2")
+    return check_prob(p1, "p1"), check_prob(p2, "p2")
+
+
+def exact_power_fisher(n1, n2, p1=None, p2=None, alpha=0.05,
+                       alternative="two-sided", *, odds_ratio=None):
+    """Exact power of Fisher's exact test for comparing two proportions.
+
+    Parameters
+    ----------
+    n1, n2 : int
+        Group sizes (number of subjects per group), each >= 1.  The
+        free version requires ``n1 + n2 <= 1000``.
+    p1, p2 : float
+        Assumed true event probabilities in group 1 and group 2, each
+        in [0, 1].  Alternatively pass ``odds_ratio`` with ``p2`` and
+        leave ``p1`` unset.
+    alpha : float, default 0.05
+        Significance level, strictly between 0 and 1.
+    alternative : {"two-sided"}, default "two-sided"
+        Only the two-sided test is included in the free version.
+        One-sided power is part of the full version.
+    odds_ratio : float, optional
+        Assumed true odds ratio ``[p1/(1-p1)] / [p2/(1-p2)]``, a
+        positive finite number.  Requires ``p2``; ``p1`` is derived
+        from it.
+
+    Returns
+    -------
+    float
+        The exact rejection probability under the binomial-product
+        alternative described in the module docstring.
+
+    Raises
+    ------
+    ValueError
+        On any invalid input, when ``n1 + n2`` exceeds 1000, or when a
+        one-sided alternative is requested.
+    """
+    n1 = check_group_size(n1, "n1")
+    n2 = check_group_size(n2, "n2")
+    if n1 + n2 > FREE_MAX_TOTAL_N:
+        raise ValueError(
+            f"Free version is capped at n1 + n2 <= {FREE_MAX_TOTAL_N}. "
+            f"The full version ($30, one-time) goes to n1 + n2 = 5000: {_PAID_URL}"
+        )
+    alternative = check_alternative(alternative)
+    if alternative != "two-sided":
+        raise ValueError(
+            f"Free version includes two-sided power only (got {alternative!r}). "
+            f"The full version ($30, one-time) adds one-sided power: {_PAID_URL}"
+        )
+    p1, p2 = _resolve_probs(p1, p2, odds_ratio)
+    alpha = check_alpha(alpha)
+
+    b1 = binom.pmf(np.arange(n1 + 1), n1, p1)
+    b2 = binom.pmf(np.arange(n2 + 1), n2, p2)
+    N = n1 + n2
+    power = 0.0
+    for m1 in range(N + 1):
+        xs, pmf = hypergeom_pmf(N, m1, n1)
+        pvals = minlike_pvalues(pmf)
+        # outcome pairs (a, b) with a + b = m1: a ranges over the support
+        w = b1[xs] * b2[m1 - xs]
+        power += w[pvals <= alpha].sum()
+    return float(power)

exactpower-0.1.0/src/exactpower/_validate.py

@@ -0,0 +1,78 @@
+"""Input validation helpers for the free exactpower core.
+
+Every public function validates loudly and refuses to compute on bad
+input: a ValueError is always better than a silent wrong number.
+"""
+
+import math
+import numbers
+
+import numpy as np
+
+__all__ = [
+    "check_prob",
+    "check_alpha",
+    "check_alternative",
+    "check_group_size",
+]
+
+
+def _is_integral(x):
+    if isinstance(x, bool):
+        return False
+    if isinstance(x, numbers.Integral):
+        return True
+    if isinstance(x, numbers.Real):
+        return float(x).is_integer()
+    return False
+
+
+def check_count(n, name):
+    """Validate a sample-size / count argument.
+
+    Accepts ints, numpy integers, and integral floats (10.0); anything
+    else (10.5, -3, "10", NaN) raises ValueError.
+    """
+    if isinstance(n, np.ndarray):
+        raise ValueError(f"{name} must be a single integer, got an array")
+    if not _is_integral(n):
+        raise ValueError(
+            f"{name} must be an integer count, got {n!r}"
+        )
+    n = int(n) if isinstance(n, numbers.Integral) else int(n)
+    return n
+
+
+def check_group_size(n, name):
+    n = check_count(n, name)
+    if n < 1:
+        raise ValueError(f"{name} must be >= 1, got {n}")
+    return n
+
+
+def check_prob(p, name):
+    """Validate a probability in [0, 1]."""
+    if isinstance(p, bool) or not isinstance(p, numbers.Real):
+        raise ValueError(f"{name} must be a number in [0, 1], got {p!r}")
+    p = float(p)
+    if math.isnan(p) or not (0.0 <= p <= 1.0):
+        raise ValueError(f"{name} must be in [0, 1], got {p!r}")
+    return p
+
+
+def check_alpha(alpha):
+    if isinstance(alpha, bool) or not isinstance(alpha, numbers.Real):
+        raise ValueError(f"alpha must be a number in (0, 1), got {alpha!r}")
+    alpha = float(alpha)
+    if math.isnan(alpha) or not (0.0 < alpha < 1.0):
+        raise ValueError(f"alpha must be strictly between 0 and 1, got {alpha!r}")
+    return alpha
+
+
+def check_alternative(alternative):
+    if alternative not in ("two-sided", "less", "greater"):
+        raise ValueError(
+            "alternative must be 'two-sided', 'less' or 'greater', "
+            f"got {alternative!r}"
+        )
+    return alternative

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

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: exactpower
+Version: 0.1.0
+Summary: Exact power of Fisher's exact test for a planned 2x2 study (free core)
+Author: Groundplane Labs
+License: MIT
+Project-URL: Homepage, https://groundplane0.gumroad.com/l/tyevqe
+Keywords: power analysis,sample size,fisher exact test,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
+
+# exactpower
+
+Free core of ExactPower: exact power of Fisher's exact test for a planned 2x2 study.
+
+**The problem**
+You are planning a study with two groups and a yes/no outcome, and you need to pick a sample size before you collect data. The usual power calculators use approximations that drift exactly where small samples matter most. Search terms: exact power Fisher test Python, sample size Fisher exact test, power analysis 2x2 Python.
+
+**What it does**
+`exact_power_fisher(n1, n2, p1, p2)` computes the exact rejection probability of the two-sided Fisher exact test under your planned design. Give it the group sizes and the event rates you expect, and it enumerates every possible outcome. No approximation, no simulation. The free version handles n1 + n2 up to 1000.
+
+**Limits**
+Free version: two-sided power only, n1 + n2 <= 1000. Larger studies are refused outright instead of hanging. No sample-size inversion, no Monte Carlo power estimator, no plots, no CLI.
+
+**Install**
+
+```bash
+pip install exactpower
+```
+
+Needs Python 3.9 or newer, NumPy, and SciPy.
+
+```python
+from exactpower import exact_power_fisher
+print(exact_power_fisher(60, 60, 0.55, 0.30))
+```
+
+This is the free core: two-sided exact power for a planned 2x2 design, capped at n1 + n2 <= 1000. The full version ($30, one-time) goes to n1 + n2 = 5000 and adds sample-size inversion, Monte Carlo power for r-by-c tables, and one-sided power: https://groundplane0.gumroad.com/l/tyevqe

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

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/exactpower/__init__.py
+src/exactpower/_fisher.py
+src/exactpower/_power.py
+src/exactpower/_validate.py
+src/exactpower.egg-info/PKG-INFO
+src/exactpower.egg-info/SOURCES.txt
+src/exactpower.egg-info/dependency_links.txt
+src/exactpower.egg-info/requires.txt
+src/exactpower.egg-info/top_level.txt
+tests/test_free.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+exactpower

exactpower-0.1.0/tests/test_free.py

@@ -0,0 +1,131 @@
+"""Tests for the free exactpower core.
+
+Correctness is checked against the paid package (imported from its own
+source tree under an alias, never copied).  Cap behavior and input
+validation are checked directly.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+import exactpower
+
+HERE = Path(__file__).resolve().parent
+PAID_SRC = HERE.parent.parent.parent / "exact-power" / "src" / "exactpower"
+
+
+def _load_paid():
+    spec = importlib.util.spec_from_file_location(
+        "paid_exactpower",
+        PAID_SRC / "__init__.py",
+        submodule_search_locations=[str(PAID_SRC)],
+    )
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["paid_exactpower"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+paid = _load_paid()
+
+PAID_URL = "https://groundplane0.gumroad.com/l/tyevqe"
+
+CASES = [
+    (60, 60, 0.55, 0.30, 0.05),
+    (30, 30, 0.8, 0.2, 0.05),
+    (100, 50, 0.4, 0.35, 0.01),
+    (10, 10, 0.9, 0.1, 0.05),
+    (200, 200, 0.52, 0.48, 0.05),
+    (45, 60, 0.7, 0.5, 0.10),
+]
+
+
+def test_matches_paid_exactly():
+    for n1, n2, p1, p2, alpha in CASES:
+        free = exactpower.exact_power_fisher(n1, n2, p1, p2, alpha=alpha)
+        ref = paid.exact_power_fisher(n1, n2, p1, p2, alpha=alpha)
+        assert free == pytest.approx(ref, rel=1e-12), (n1, n2, p1, p2, alpha)
+
+
+def test_odds_ratio_matches_paid():
+    free = exactpower.exact_power_fisher(60, 60, None, 0.30, odds_ratio=2.85)
+    ref = paid.exact_power_fisher(60, 60, None, 0.30, odds_ratio=2.85)
+    assert free == pytest.approx(ref, rel=1e-12)
+
+
+def test_over_cap_refuses_loudly():
+    with pytest.raises(ValueError, match="n1 \\+ n2 <= 1000"):
+        exactpower.exact_power_fisher(600, 600, 0.55, 0.45)
+    with pytest.raises(ValueError, match="n1 \\+ n2 <= 1000"):
+        exactpower.exact_power_fisher(1, 1000, 0.55, 0.45)
+    try:
+        exactpower.exact_power_fisher(600, 600, 0.55, 0.45)
+    except ValueError as e:
+        assert PAID_URL in str(e)
+        assert "30" in str(e)
+
+
+def test_at_cap_still_works():
+    p = exactpower.exact_power_fisher(500, 500, 0.55, 0.45)
+    assert 0.0 <= p <= 1.0
+    assert p == pytest.approx(paid.exact_power_fisher(500, 500, 0.55, 0.45), rel=1e-12)
+
+
+def test_one_sided_refused_with_paid_pointer():
+    with pytest.raises(ValueError, match="two-sided"):
+        exactpower.exact_power_fisher(60, 60, 0.55, 0.30, alternative="greater")
+    try:
+        exactpower.exact_power_fisher(60, 60, 0.55, 0.30, alternative="less")
+    except ValueError as e:
+        assert PAID_URL in str(e)
+
+
+def test_bad_alternative_string_raises():
+    with pytest.raises(ValueError):
+        exactpower.exact_power_fisher(60, 60, 0.55, 0.30, alternative="bogus")
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        (0, 60, 0.55, 0.30),        # n1 < 1
+        (60, -5, 0.55, 0.30),       # negative n2
+        (60.5, 60, 0.55, 0.30),     # fractional n1
+        (60, 60, 1.5, 0.30),        # p1 > 1
+        (60, 60, 0.55, -0.1),       # p2 < 0
+        (60, 60, float("nan"), 0.30),
+        (60, 60, 0.55, 0.30, 0.0),  # alpha = 0 (positional alpha)
+        (60, 60, 0.55, 0.30, 1.0),  # alpha = 1
+        ("60", 60, 0.55, 0.30),     # string n1
+    ],
+)
+def test_garbage_raises(args):
+    n1, n2, p1, p2 = args[0], args[1], args[2], args[3]
+    alpha = args[4] if len(args) > 4 else 0.05
+    with pytest.raises(ValueError):
+        exactpower.exact_power_fisher(n1, n2, p1, p2, alpha=alpha)
+
+
+def test_paid_only_symbols_absent():
+    for name in (
+        "sample_size_fisher",
+        "SampleSizeNotAchieved",
+        "power_mc",
+        "MCPowerResult",
+        "fisher_exact_2x2",
+        "fisher_exact_rc",
+        "count_tables",
+    ):
+        assert not hasattr(exactpower, name), name
+    assert set(exactpower.__all__) == {
+        "exact_power_fisher",
+        "FREE_MAX_TOTAL_N",
+        "__version__",
+    }
+
+
+def test_free_cap_constant():
+    assert exactpower.FREE_MAX_TOTAL_N == 1000