pcorr 0.5.1__tar.gz

pcorr-0.5.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark
+
+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.

pcorr-0.5.1/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: pcorr
+Version: 0.5.1
+Summary: Pairwise Pearson correlations with p-values and multiple-comparison correction
+Author: Mark
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Cyber200potato/pcorr
+Project-URL: Issues, https://github.com/Cyber200potato/pcorr/issues
+Keywords: correlation,pearson,p-value,statistics,multiple-comparisons
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: pandas>=1.2
+Requires-Dist: scipy>=1.6
+Provides-Extra: full
+Requires-Dist: statsmodels>=0.13; extra == "full"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: statsmodels>=0.13; extra == "test"
+Dynamic: license-file
+
+# pcorr
+
+Compute all pairwise Pearson/Spearman correlations between numeric columns in a `pandas.DataFrame` — like `pandas.DataFrame.corr()`, but with **p-values for each pair** and **multiple-comparison correction** in one call.
+
+## Installation
+
+```bash
+pip install -e .             # core: numpy, pandas, scipy
+pip install -e ".[full]"     # + statsmodels (fdr_bh, holm, sidak, ...)
+```
+
+Without statsmodels only `method="bonferroni"` and `method="none"` are available.
+
+If the package is published, you can install it as:
+
+```bash
+pip install pcorr
+pip install "pcorr[full]"
+```
+
+## Usage
+
+```python
+import pandas as pd
+from pcorr import corr_pairwise, corr_table, show_table
+
+df = pd.read_csv("data.csv")
+
+# Long (tidy) format: one row per pair
+table = corr_pairwise(df, method="fdr_bh", alpha=0.05)
+print(table)
+#   var1 var2    n      r  p_corrected  p_value  significant
+# 0    x    y  200  0.967       0.0000  0.0000         True
+# 1    x    z  200 -0.894       0.0000  0.0000         True
+# ...
+
+# Two square tables (r and p) rendered as lower-triangle output
+tables = corr_table(df, method="bonferroni")
+tables["r"]  # coefficients
+tables["p"]  # p-values (raw when method="none", otherwise corrected)
+
+# Convenience display (renders nicely in Jupyter, prints in console)
+show_table(df, method="bonferroni")
+```
+
+## API
+
+- `corr_pairwise(df, ...)` — tidy table: one row per column pair.
+- `corr_table(df, ...)` — two square tables (coefficients and p-values) in a lower-triangle style.
+- `show_table(df, ...)` — displays/prints `corr_table(...)`.
+- `corr_matrices(df, ...)` — alias for `corr_table(...)` (compatibility).
+
+## Output format
+
+### corr_pairwise
+
+Always returns:
+
+- `var1`, `var2` — column names
+- `n` — number of valid observations in the pair (after pairwise NaN deletion)
+- `r` — correlation coefficient
+- `significant` — `p < alpha` for the p-value used for significance
+
+P-value columns depend on `method`:
+
+- `method="none"` returns `p_value` (raw p-value)
+- any correction (e.g. `bonferroni`, `fdr_bh`, `holm`) returns `p_corrected` and `p_value` (raw)
+
+Raw p-values example:
+
+```python
+from pcorr import corr_pairwise
+out = corr_pairwise(df, method="none")
+```
+
+### corr_table / corr_matrices
+
+Returns a dict with two `DataFrame`s:
+
+- `tables["r"]` — coefficients (lower triangle filled), diagonal `"1"`, upper triangle blank
+- `tables["p"]` — p-values in the same layout, diagonal `"—"`
+  - raw p-values when `method="none"`
+  - corrected p-values for any correction method
+
+## Parameters
+
+| parameter  | meaning                                                         |
+|-----------|------------------------------------------------------------------|
+| `columns` | which columns to use (default: all numeric)                      |
+| `corr`    | `"pearson"` or `"spearman"`                                      |
+| `method`  | `bonferroni`, `fdr_bh`, `holm`, `sidak`, `none`, ...             |
+| `alpha`   | threshold for `significant`                                      |
+| `min_n`   | minimum valid observations per pair (pairwise NaN deletion)      |
+| `round_to`| rounding for r/p columns (None disables rounding)                |
+
+## Notes
+
+- Pairwise NaN deletion: each pair has its own `n`.
+- Constant columns and pairs with `n < min_n` are handled without crashing.
+- `corr_pairwise` is sorted by the p-value used for ranking (corrected when applicable).
+
+## P-value correction methods
+
+- `method="none"` and `method="bonferroni"` work without statsmodels.
+- Other methods use `statsmodels.stats.multitest.multipletests` and require statsmodels (install via the `full` extra).

pcorr-0.5.1/README.md

@@ -0,0 +1,105 @@
+# pcorr
+
+Compute all pairwise Pearson/Spearman correlations between numeric columns in a `pandas.DataFrame` — like `pandas.DataFrame.corr()`, but with **p-values for each pair** and **multiple-comparison correction** in one call.
+
+## Installation
+
+```bash
+pip install -e .             # core: numpy, pandas, scipy
+pip install -e ".[full]"     # + statsmodels (fdr_bh, holm, sidak, ...)
+```
+
+Without statsmodels only `method="bonferroni"` and `method="none"` are available.
+
+If the package is published, you can install it as:
+
+```bash
+pip install pcorr
+pip install "pcorr[full]"
+```
+
+## Usage
+
+```python
+import pandas as pd
+from pcorr import corr_pairwise, corr_table, show_table
+
+df = pd.read_csv("data.csv")
+
+# Long (tidy) format: one row per pair
+table = corr_pairwise(df, method="fdr_bh", alpha=0.05)
+print(table)
+#   var1 var2    n      r  p_corrected  p_value  significant
+# 0    x    y  200  0.967       0.0000  0.0000         True
+# 1    x    z  200 -0.894       0.0000  0.0000         True
+# ...
+
+# Two square tables (r and p) rendered as lower-triangle output
+tables = corr_table(df, method="bonferroni")
+tables["r"]  # coefficients
+tables["p"]  # p-values (raw when method="none", otherwise corrected)
+
+# Convenience display (renders nicely in Jupyter, prints in console)
+show_table(df, method="bonferroni")
+```
+
+## API
+
+- `corr_pairwise(df, ...)` — tidy table: one row per column pair.
+- `corr_table(df, ...)` — two square tables (coefficients and p-values) in a lower-triangle style.
+- `show_table(df, ...)` — displays/prints `corr_table(...)`.
+- `corr_matrices(df, ...)` — alias for `corr_table(...)` (compatibility).
+
+## Output format
+
+### corr_pairwise
+
+Always returns:
+
+- `var1`, `var2` — column names
+- `n` — number of valid observations in the pair (after pairwise NaN deletion)
+- `r` — correlation coefficient
+- `significant` — `p < alpha` for the p-value used for significance
+
+P-value columns depend on `method`:
+
+- `method="none"` returns `p_value` (raw p-value)
+- any correction (e.g. `bonferroni`, `fdr_bh`, `holm`) returns `p_corrected` and `p_value` (raw)
+
+Raw p-values example:
+
+```python
+from pcorr import corr_pairwise
+out = corr_pairwise(df, method="none")
+```
+
+### corr_table / corr_matrices
+
+Returns a dict with two `DataFrame`s:
+
+- `tables["r"]` — coefficients (lower triangle filled), diagonal `"1"`, upper triangle blank
+- `tables["p"]` — p-values in the same layout, diagonal `"—"`
+  - raw p-values when `method="none"`
+  - corrected p-values for any correction method
+
+## Parameters
+
+| parameter  | meaning                                                         |
+|-----------|------------------------------------------------------------------|
+| `columns` | which columns to use (default: all numeric)                      |
+| `corr`    | `"pearson"` or `"spearman"`                                      |
+| `method`  | `bonferroni`, `fdr_bh`, `holm`, `sidak`, `none`, ...             |
+| `alpha`   | threshold for `significant`                                      |
+| `min_n`   | minimum valid observations per pair (pairwise NaN deletion)      |
+| `round_to`| rounding for r/p columns (None disables rounding)                |
+
+## Notes
+
+- Pairwise NaN deletion: each pair has its own `n`.
+- Constant columns and pairs with `n < min_n` are handled without crashing.
+- `corr_pairwise` is sorted by the p-value used for ranking (corrected when applicable).
+
+## P-value correction methods
+
+- `method="none"` and `method="bonferroni"` work without statsmodels.
+- Other methods use `statsmodels.stats.multitest.multipletests` and require statsmodels (install via the `full` extra).

pcorr-0.5.1/pcorr/__init__.py

@@ -0,0 +1,19 @@
+"""pcorr — pairwise Pearson/Spearman correlations with p-values and correction.
+
+Combines the convenience of a pandas-style "all pairs" correlation matrix
+with scipy's per-pair p-values, plus optional multiple-comparison correction.
+"""
+
+from .core import corr_pairwise, corr_table, corr_matrices, show_table
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except ImportError:
+    from importlib_metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("pcorr")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = ["corr_pairwise", "corr_table", "corr_matrices", "show_table"]

pcorr-0.5.1/pcorr/core.py

@@ -0,0 +1,324 @@
+"""Pairwise Pearson/Spearman correlations with p-values and multiple-comparison correction."""
+
+from __future__ import annotations
+
+from itertools import combinations
+from typing import Iterable, Optional
+
+import numpy as np
+import pandas as pd
+from scipy.stats import pearsonr, spearmanr
+
+try:
+    from statsmodels.stats.multitest import multipletests
+    _HAS_STATSMODELS = True
+except ImportError:  # pragma: no cover
+    _HAS_STATSMODELS = False
+
+
+_SUPPORTED_METHODS = {
+    "bonferroni", "sidak", "holm", "holm-sidak", "simes-hochberg",
+    "hommel", "fdr_bh", "fdr_by", "fdr_tsbh", "fdr_tsbky", "none",
+}
+
+_CORR_FUNCS = {
+    "pearson": pearsonr,
+    "spearman": spearmanr,
+}
+
+
+def _select_columns(df: pd.DataFrame, columns: Optional[Iterable[str]]) -> list:
+    if columns is None:
+        cols = df.select_dtypes(include=np.number).columns.tolist()
+    else:
+        cols = list(columns)
+    if len(cols) < 2:
+        raise ValueError("Need at least 2 numeric columns to correlate.")
+    return cols
+
+
+def _apply_correction(pvals: np.ndarray, method: str, alpha: float):
+    """Return (corrected_pvals, rejected) handling NaNs gracefully."""
+    pvals = np.asarray(pvals, dtype=float)
+    corrected = np.full_like(pvals, np.nan)
+    rejected = np.zeros_like(pvals, dtype=bool)
+
+    if not _HAS_STATSMODELS:
+        raise ImportError(
+            "statsmodels is required for correction methods other than "
+            "'bonferroni' and 'none'. Install it with `pip install statsmodels`, "
+            "or use method='bonferroni'."
+        )
+
+    mask = ~np.isnan(pvals)
+    if mask.sum() == 0:
+        return corrected, rejected
+
+    rej, corr_p, _, _ = multipletests(pvals[mask], alpha=alpha, method=method)
+    corrected[mask] = corr_p
+    rejected[mask] = rej
+    return corrected, rejected
+
+
+def _bonferroni(pvals: np.ndarray, alpha: float):
+    """Pure-numpy Bonferroni so the core works without statsmodels."""
+    pvals = np.asarray(pvals, dtype=float)
+    mask = ~np.isnan(pvals)
+    n = int(mask.sum())
+    corrected = np.full_like(pvals, np.nan)
+    corrected[mask] = np.minimum(pvals[mask] * n, 1.0)
+    rejected = np.zeros_like(pvals, dtype=bool)
+    rejected[mask] = corrected[mask] < alpha
+    return corrected, rejected
+
+
+def corr_pairwise(
+    df: pd.DataFrame,
+    columns: Optional[Iterable[str]] = None,
+    corr: str = "pearson",
+    method: str = "none",
+    alpha: float = 0.05,
+    min_n: int = 3,
+    round_to: Optional[int] = 4,
+) -> pd.DataFrame:
+    """Compute pairwise correlations in long (tidy) format.
+
+    The p-value column adapts to `method`:
+      * method="none"  -> a single column `p_value` (uncorrected).
+      * any correction -> columns `p_corrected` then `p_value` (raw).
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Input data. Pairwise NaN deletion is applied per column pair.
+    columns : iterable of str, optional
+        Columns to correlate. Defaults to all numeric columns.
+    corr : {"pearson", "spearman"}, default "pearson"
+        Correlation coefficient to compute.
+    method : str, default "none"
+        Multiple-comparison correction. "none" reports raw p-values only.
+        "bonferroni" works with scipy alone; other statsmodels methods
+        (e.g. "fdr_bh", "holm", "sidak") require statsmodels.
+    alpha : float, default 0.05
+        Significance threshold. A pair is flagged significant when its
+        reported p-value < alpha. Set 0.10 / 0.05 / 0.01 for 90/95/99%.
+    min_n : int, default 3
+        Minimum valid (non-NaN) observations per pair; smaller pairs skipped.
+    round_to : int or None, default 4
+        Decimal places for r/p columns. None disables rounding.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Columns:
+          * method="none": var1, var2, n, r, p_value, significant.
+          * otherwise:    var1, var2, n, r, p_corrected, p_value, significant.
+        Sorted by p_corrected when a correction is used, otherwise by p_value.
+    """
+    corr = corr.lower()
+    if corr not in _CORR_FUNCS:
+        raise ValueError(f"Unknown corr '{corr}'. Use 'pearson' or 'spearman'.")
+    corr_func = _CORR_FUNCS[corr]
+
+    method = method.lower()
+    if method not in _SUPPORTED_METHODS:
+        raise ValueError(
+            f"Unknown method '{method}'. Supported: {sorted(_SUPPORTED_METHODS)}"
+        )
+
+    cols = _select_columns(df, columns)
+    corrected_mode = method != "none"
+    if corrected_mode:
+        empty_cols = ["var1", "var2", "n", "r", "p_corrected", "p_value", "significant"]
+    else:
+        empty_cols = ["var1", "var2", "n", "r", "p_value", "significant"]
+
+    records = []
+    for a, b in combinations(cols, 2):
+        pair = df[[a, b]].dropna()
+        n = len(pair)
+        if n < min_n:
+            continue
+        if pair[a].nunique() < 2 or pair[b].nunique() < 2:
+            r, p = np.nan, np.nan
+        else:
+            r, p = corr_func(pair[a], pair[b])
+        records.append({"var1": a, "var2": b, "n": n, "r": r, "_p_raw": p})
+
+    if not records:
+        return pd.DataFrame(columns=empty_cols)
+
+    out = pd.DataFrame.from_records(records)
+    raw = out["_p_raw"].to_numpy(dtype=float)
+
+    if corrected_mode:
+        if method == "bonferroni" and not _HAS_STATSMODELS:
+            corrected, _ = _bonferroni(raw, alpha)
+        else:
+            corrected, _ = _apply_correction(raw, method, alpha)
+        out["p_corrected"] = corrected
+        out["p_value"] = raw
+        sort_col = "p_corrected"
+    else:
+        out["p_value"] = raw
+        sort_col = "p_value"
+
+    out = out.drop(columns="_p_raw")
+    out["significant"] = out[sort_col] < alpha
+    out = out.sort_values(sort_col, na_position="last").reset_index(drop=True)
+
+    if round_to is not None:
+        for c in ("r", "p_corrected", "p_value"):
+            if c in out.columns:
+                out[c] = out[c].round(round_to)
+
+    if corrected_mode:
+        out = out[["var1", "var2", "n", "r", "p_corrected", "p_value", "significant"]]
+    else:
+        out = out[["var1", "var2", "n", "r", "p_value", "significant"]]
+    out.attrs["corr"] = corr
+    out.attrs["correction_method"] = method
+    out.attrs["alpha"] = alpha
+    return out
+
+
+def corr_table(
+    df: pd.DataFrame,
+    columns: Optional[Iterable[str]] = None,
+    corr: str = "pearson",
+    method: str = "none",
+    alpha: float = 0.05,
+    min_n: int = 3,
+    round_to: int = 4,
+    stars: bool = True,
+):
+    """Pairwise correlations as two square matrices: coefficients and p-values.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Input data (pairwise NaN deletion per pair).
+    columns : iterable of str, optional
+        Columns to use. Defaults to all numeric columns.
+    corr : {"pearson", "spearman"}, default "pearson"
+        Correlation coefficient.
+    method : str, default "none"
+        Multiple-comparison correction. "none" -> the p-matrix holds raw
+        p-values; any other method -> it holds corrected p-values.
+    alpha : float, default 0.05
+        Significance threshold. A coefficient is starred when its reported
+        p-value < alpha. Use 0.10 / 0.05 / 0.01 for 90 / 95 / 99%.
+    min_n : int, default 3
+        Minimum valid observations per pair.
+    round_to : int, default 4
+        Decimal places for both matrices.
+    stars : bool, default True
+        If True, the coefficient matrix is a string matrix with a single "*"
+        appended to significant coefficients (p < alpha). If False, it is a
+        plain numeric matrix.
+
+    Returns
+    -------
+    dict of pandas.DataFrame with keys:
+        'r' : coefficient matrix. Lower triangle filled, upper triangle blank,
+              diagonal = "1". A single "*" marks significant coefficients
+              (reported p < alpha) when stars=True.
+        'p' : p-value matrix in the same lower-triangle style, diagonal = "—".
+              Holds raw p-values (method="none") or corrected ones otherwise.
+
+    Both are string matrices sharing index/columns, so cells line up.
+    """
+    cols = _select_columns(df, columns)
+    long = corr_pairwise(df, columns=cols, corr=corr, method=method,
+                         alpha=alpha, min_n=min_n, round_to=None)
+    p_col = "p_corrected" if method.lower() != "none" else "p_value"
+
+    r_num = pd.DataFrame(np.eye(len(cols)), index=cols, columns=cols)
+    p_mat = pd.DataFrame(np.zeros((len(cols), len(cols))), index=cols, columns=cols)
+    sig_mat = pd.DataFrame(False, index=cols, columns=cols)
+
+    for _, row in long.iterrows():
+        a, b = row["var1"], row["var2"]
+        r_num.loc[a, b] = r_num.loc[b, a] = row["r"]
+        p_mat.loc[a, b] = p_mat.loc[b, a] = row[p_col]
+        sig_mat.loc[a, b] = sig_mat.loc[b, a] = bool(row["significant"])
+
+    cols_list = list(cols)
+    r_out = pd.DataFrame("", index=cols_list, columns=cols_list)
+    p_out = pd.DataFrame("", index=cols_list, columns=cols_list)
+
+    for i, ri in enumerate(cols_list):
+        for j, cj in enumerate(cols_list):
+            if i == j:
+                r_out.loc[ri, cj] = "1"
+                p_out.loc[ri, cj] = "—"
+            elif i > j:  # lower triangle only
+                r = r_num.loc[ri, cj]
+                p = p_mat.loc[ri, cj]
+                if pd.isna(r):
+                    r_out.loc[ri, cj] = "—"
+                    p_out.loc[ri, cj] = "—"
+                else:
+                    mark = "*" if (stars and sig_mat.loc[ri, cj]) else ""
+                    r_out.loc[ri, cj] = f"{r:.{round_to}f}{mark}"
+                    p_out.loc[ri, cj] = f"{p:.{round_to}f}"
+            # upper triangle stays blank
+
+    for d in (r_out, p_out):
+        d.attrs["corr"] = corr
+        d.attrs["correction_method"] = method
+        d.attrs["alpha"] = alpha
+
+    return {"r": r_out, "p": p_out}
+
+
+
+corr_matrices = corr_table
+
+
+def show_table(df, columns=None, corr="pearson", method="none", alpha=0.05,
+               min_n=3, round_to=4, stars=True, tables=None):
+    """Display both tables (coefficients and p-values) with a plain pandas render.
+
+    In Jupyter this shows two clean HTML tables back-to-back, each preceded by
+    a short caption, and returns None (so Jupyter doesn't also echo the raw
+    dict as text below them). Outside Jupyter it prints them and returns the
+    dict {'r', 'p'}.
+
+    If you need the tables as objects, call `corr_table(...)` directly.
+
+    Same arguments as `corr_table`. Pass a precomputed `tables=corr_table(...)`
+    to skip recomputation.
+    """
+    if tables is None:
+        tables = corr_table(df, columns=columns, corr=corr, method=method,
+                            alpha=alpha, min_n=min_n, round_to=round_to,
+                            stars=stars)
+    r_tab, p_tab = tables["r"], tables["p"]
+
+    corr_name = tables["r"].attrs.get("corr", corr).capitalize()
+    meth = tables["r"].attrs.get("correction_method", method)
+    a = tables["r"].attrs.get("alpha", alpha)
+    star_note = f" (* p < {a})" if stars else ""
+    p_kind = "raw" if meth == "none" else f"{meth}-corrected"
+
+    r_caption = f"{corr_name} correlation coefficients{star_note}"
+    p_caption = f"p-values ({p_kind})"
+
+    try:
+        from IPython.display import display, HTML
+        get_ipython  # noqa: F821 — exists only inside IPython/Jupyter
+        display(HTML(f"<b>{r_caption}</b>"))
+        display(r_tab)                       # plain pandas HTML render
+        display(HTML(f"<b>{p_caption}</b>"))
+        display(p_tab)
+        # Return nothing: Jupyter would otherwise echo the dict as raw text
+        # below the rendered tables. Use corr_table(...) if you need the object.
+        return None
+    except (ImportError, NameError):
+        print(r_caption)
+        print(r_tab.to_string())
+        print()
+        print(p_caption)
+        print(p_tab.to_string())
+        return tables

pcorr-0.5.1/pcorr.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: pcorr
+Version: 0.5.1
+Summary: Pairwise Pearson correlations with p-values and multiple-comparison correction
+Author: Mark
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Cyber200potato/pcorr
+Project-URL: Issues, https://github.com/Cyber200potato/pcorr/issues
+Keywords: correlation,pearson,p-value,statistics,multiple-comparisons
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: pandas>=1.2
+Requires-Dist: scipy>=1.6
+Provides-Extra: full
+Requires-Dist: statsmodels>=0.13; extra == "full"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: statsmodels>=0.13; extra == "test"
+Dynamic: license-file
+
+# pcorr
+
+Compute all pairwise Pearson/Spearman correlations between numeric columns in a `pandas.DataFrame` — like `pandas.DataFrame.corr()`, but with **p-values for each pair** and **multiple-comparison correction** in one call.
+
+## Installation
+
+```bash
+pip install -e .             # core: numpy, pandas, scipy
+pip install -e ".[full]"     # + statsmodels (fdr_bh, holm, sidak, ...)
+```
+
+Without statsmodels only `method="bonferroni"` and `method="none"` are available.
+
+If the package is published, you can install it as:
+
+```bash
+pip install pcorr
+pip install "pcorr[full]"
+```
+
+## Usage
+
+```python
+import pandas as pd
+from pcorr import corr_pairwise, corr_table, show_table
+
+df = pd.read_csv("data.csv")
+
+# Long (tidy) format: one row per pair
+table = corr_pairwise(df, method="fdr_bh", alpha=0.05)
+print(table)
+#   var1 var2    n      r  p_corrected  p_value  significant
+# 0    x    y  200  0.967       0.0000  0.0000         True
+# 1    x    z  200 -0.894       0.0000  0.0000         True
+# ...
+
+# Two square tables (r and p) rendered as lower-triangle output
+tables = corr_table(df, method="bonferroni")
+tables["r"]  # coefficients
+tables["p"]  # p-values (raw when method="none", otherwise corrected)
+
+# Convenience display (renders nicely in Jupyter, prints in console)
+show_table(df, method="bonferroni")
+```
+
+## API
+
+- `corr_pairwise(df, ...)` — tidy table: one row per column pair.
+- `corr_table(df, ...)` — two square tables (coefficients and p-values) in a lower-triangle style.
+- `show_table(df, ...)` — displays/prints `corr_table(...)`.
+- `corr_matrices(df, ...)` — alias for `corr_table(...)` (compatibility).
+
+## Output format
+
+### corr_pairwise
+
+Always returns:
+
+- `var1`, `var2` — column names
+- `n` — number of valid observations in the pair (after pairwise NaN deletion)
+- `r` — correlation coefficient
+- `significant` — `p < alpha` for the p-value used for significance
+
+P-value columns depend on `method`:
+
+- `method="none"` returns `p_value` (raw p-value)
+- any correction (e.g. `bonferroni`, `fdr_bh`, `holm`) returns `p_corrected` and `p_value` (raw)
+
+Raw p-values example:
+
+```python
+from pcorr import corr_pairwise
+out = corr_pairwise(df, method="none")
+```
+
+### corr_table / corr_matrices
+
+Returns a dict with two `DataFrame`s:
+
+- `tables["r"]` — coefficients (lower triangle filled), diagonal `"1"`, upper triangle blank
+- `tables["p"]` — p-values in the same layout, diagonal `"—"`
+  - raw p-values when `method="none"`
+  - corrected p-values for any correction method
+
+## Parameters
+
+| parameter  | meaning                                                         |
+|-----------|------------------------------------------------------------------|
+| `columns` | which columns to use (default: all numeric)                      |
+| `corr`    | `"pearson"` or `"spearman"`                                      |
+| `method`  | `bonferroni`, `fdr_bh`, `holm`, `sidak`, `none`, ...             |
+| `alpha`   | threshold for `significant`                                      |
+| `min_n`   | minimum valid observations per pair (pairwise NaN deletion)      |
+| `round_to`| rounding for r/p columns (None disables rounding)                |
+
+## Notes
+
+- Pairwise NaN deletion: each pair has its own `n`.
+- Constant columns and pairs with `n < min_n` are handled without crashing.
+- `corr_pairwise` is sorted by the p-value used for ranking (corrected when applicable).
+
+## P-value correction methods
+
+- `method="none"` and `method="bonferroni"` work without statsmodels.
+- Other methods use `statsmodels.stats.multitest.multipletests` and require statsmodels (install via the `full` extra).

pcorr-0.5.1/pcorr.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+pcorr/__init__.py
+pcorr/core.py
+pcorr.egg-info/PKG-INFO
+pcorr.egg-info/SOURCES.txt
+pcorr.egg-info/dependency_links.txt
+pcorr.egg-info/requires.txt
+pcorr.egg-info/top_level.txt
+tests/test_core.py

pcorr-0.5.1/pcorr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pcorr-0.5.1/pcorr.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=1.20
+pandas>=1.2
+scipy>=1.6
+
+[full]
+statsmodels>=0.13
+
+[test]
+pytest>=7.0
+statsmodels>=0.13

pcorr-0.5.1/pcorr.egg-info/top_level.txt

@@ -0,0 +1 @@
+pcorr

pcorr-0.5.1/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pcorr"
+version = "0.5.1"
+description = "Pairwise Pearson correlations with p-values and multiple-comparison correction"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Mark" }]
+keywords = ["correlation", "pearson", "p-value", "statistics", "multiple-comparisons"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+dependencies = [
+    "numpy>=1.20",
+    "pandas>=1.2",
+    "scipy>=1.6",
+]
+
+[project.urls]
+Repository = "https://github.com/Cyber200potato/pcorr"
+Issues = "https://github.com/Cyber200potato/pcorr/issues"
+
+
+[project.optional-dependencies]
+full = ["statsmodels>=0.13"]   # enables fdr_bh, holm, sidak, etc.
+test = ["pytest>=7.0", "statsmodels>=0.13"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pcorr*"]

pcorr-0.5.1/setup.cfg

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

pcorr-0.5.1/tests/test_core.py

@@ -0,0 +1,211 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from pcorr import corr_pairwise, corr_table
+from pcorr import corr_matrices
+
+
+@pytest.fixture
+def df():
+    rng = np.random.default_rng(42)
+    x = rng.normal(size=200)
+    return pd.DataFrame({
+        "x": x,
+        "y": 2 * x + rng.normal(scale=0.5, size=200),   # strong positive
+        "z": -x + rng.normal(scale=0.5, size=200),       # strong negative
+        "noise": rng.normal(size=200),                   # ~uncorrelated
+    })
+
+
+# ---- corr_pairwise ----
+
+def test_default_is_raw_pvalue(df):
+    out = corr_pairwise(df)
+    assert "p_value" in out.columns
+    assert "p_corrected" not in out.columns
+    assert list(out.columns) == ["var1", "var2", "n", "r", "p_value", "significant"]
+    assert len(out) == 6
+
+
+def test_corrected_includes_raw(df):
+    out = corr_pairwise(df, method="bonferroni")
+    assert "p_corrected" in out.columns
+    assert "p_value" in out.columns
+    assert list(out.columns) == ["var1", "var2", "n", "r", "p_corrected", "p_value", "significant"]
+
+
+def test_pearson_matches_scipy(df):
+    from scipy.stats import pearsonr
+    out = corr_pairwise(df, round_to=None)
+    row = out[(out.var1 == "x") & (out.var2 == "y")].iloc[0]
+    r, p = pearsonr(df["x"], df["y"])
+    assert np.isclose(row["r"], r)
+    assert np.isclose(row["p_value"], p)
+
+
+def test_spearman_matches_scipy(df):
+    from scipy.stats import spearmanr
+    out = corr_pairwise(df, corr="spearman", round_to=None)
+    row = out[(out.var1 == "x") & (out.var2 == "y")].iloc[0]
+    r, p = spearmanr(df["x"], df["y"])
+    assert np.isclose(row["r"], r)
+    assert np.isclose(row["p_value"], p)
+
+
+def test_significant_flag_respects_alpha(df):
+    # noise pair has high p; at alpha=0.05 not significant
+    out = corr_pairwise(df, alpha=0.05, round_to=None)
+    noise = out[out.var2 == "noise"]
+    for _, row in noise.iterrows():
+        assert row["significant"] == (row["p_value"] < 0.05)
+
+
+def test_alpha_changes_significance():
+    rng = np.random.default_rng(0)
+    n = 80
+    x = rng.normal(size=n)
+    y = 0.25 * x + rng.normal(size=n)  # weak-ish correlation
+    df = pd.DataFrame({"x": x, "y": y})
+    p = corr_pairwise(df, round_to=None).iloc[0]["p_value"]
+    strict = corr_pairwise(df, alpha=0.01).iloc[0]["significant"]
+    loose = corr_pairwise(df, alpha=0.10).iloc[0]["significant"]
+    # whatever p is, strict<=loose in significance
+    assert bool(loose) >= bool(strict)
+
+
+def test_correction_increases_pvalues(df):
+    raw = corr_pairwise(df, method="none", round_to=None).set_index(["var1", "var2"])
+    corr = corr_pairwise(df, method="bonferroni", round_to=None).set_index(["var1", "var2"])
+    j = raw.join(corr, lsuffix="_r", rsuffix="_c")
+    assert (j["p_corrected"] >= j["p_value_r"] - 1e-12).all()
+
+
+def test_invalid_corr(df):
+    with pytest.raises(ValueError):
+        corr_pairwise(df, corr="kendall")
+
+
+def test_invalid_method(df):
+    with pytest.raises(ValueError):
+        corr_pairwise(df, method="not_a_method")
+
+
+def test_pairwise_nan_deletion():
+    df = pd.DataFrame({
+        "a": [1, 2, 3, 4, np.nan],
+        "b": [2, 4, 6, 8, 10],
+        "c": [np.nan, np.nan, 1, 2, 3],
+    })
+    out = corr_pairwise(df, min_n=2)
+    ab = out[(out.var1 == "a") & (out.var2 == "b")].iloc[0]
+    assert ab["n"] == 4
+    assert np.isclose(ab["r"], 1.0)
+
+
+def test_min_n_skips_pairs():
+    df = pd.DataFrame({"a": [1, np.nan, np.nan], "b": [1, 2, 3]})
+    out = corr_pairwise(df, min_n=3)
+    assert len(out) == 0
+
+
+def test_constant_column_yields_nan():
+    df = pd.DataFrame({"a": [1, 1, 1, 1], "b": [1, 2, 3, 4]})
+    out = corr_pairwise(df)
+    assert np.isnan(out.iloc[0]["r"])
+
+
+# ---- corr_table ----
+
+def test_table_returns_two_matrices(df):
+    t = corr_table(df)
+    assert set(t.keys()) == {"r", "p"}
+    assert list(t["r"].columns) == list(df.columns)
+    assert list(t["p"].columns) == list(df.columns)
+
+
+def test_table_p_lower_triangle(df):
+    t = corr_table(df)
+    p = t["p"]
+    cols = list(p.columns)
+    # diagonal is em-dash, upper triangle blank, lower filled
+    assert p.loc[cols[0], cols[0]] == "—"
+    assert p.loc[cols[0], cols[1]] == ""          # upper blank
+    assert p.loc[cols[1], cols[0]] != ""          # lower filled
+
+
+def test_table_stars_only_significant(df):
+    t = corr_table(df, alpha=0.05)
+    cols = list(t["r"].columns)
+    # find lower-triangle cell for the strong x-y pair
+    xi, yi = cols.index("x"), cols.index("y")
+    lo, hi = (("y", "x") if xi < yi else ("x", "y"))
+    assert t["r"].loc[lo, hi].endswith("*")        # strong pair starred
+    # diagonal never starred
+    assert t["r"].loc["x", "x"] == "1"
+    # a noise pair in the lower triangle should not be starred
+    ni = cols.index("noise")
+    others = [c for c in cols if c != "noise"]
+    for o in others:
+        oi = cols.index(o)
+        cell = t["r"].loc["noise", o] if ni > oi else t["r"].loc[o, "noise"]
+        if cell not in ("", "—"):
+            # if it's the lower-triangle filled cell, noise shouldn't be sig
+            assert not cell.endswith("*")
+
+
+def test_table_no_stars(df):
+    t = corr_table(df, stars=False)
+    cols = list(t["r"].columns)
+    xi, yi = cols.index("x"), cols.index("y")
+    lo, hi = (("y", "x") if xi < yi else ("x", "y"))
+    # strong pair present but never carries a star when stars=False
+    assert not t["r"].loc[lo, hi].endswith("*")
+    assert t["r"].loc["x", "x"] == "1"
+
+
+def test_table_corrected_pmatrix(df):
+    # corrected lower-triangle p >= raw lower-triangle p, cell by cell
+    raw = corr_table(df, method="none", round_to=6)["p"]
+    cor = corr_table(df, method="bonferroni", round_to=6)["p"]
+    cols = list(raw.columns)
+    for i, ri in enumerate(cols):
+        for j, cj in enumerate(cols):
+            if i > j and raw.loc[ri, cj] not in ("", "—"):
+                assert float(cor.loc[ri, cj]) >= float(raw.loc[ri, cj]) - 1e-9
+
+
+def test_table_alpha_controls_stars():
+    rng = np.random.default_rng(3)
+    n = 60
+    x = rng.normal(size=n)
+    y = 0.3 * x + rng.normal(size=n)
+    df = pd.DataFrame({"x": x, "y": y})
+    cols = list(corr_table(df)["r"].columns)
+    lo, hi = (cols[1], cols[0])  # lower-triangle cell
+    loose = corr_table(df, alpha=0.10)["r"].loc[lo, hi]
+    strict = corr_table(df, alpha=0.001)["r"].loc[lo, hi]
+    assert loose.count("*") >= strict.count("*")
+
+
+def test_corr_matrices_alias(df):
+    t = corr_matrices(df)
+    assert set(t.keys()) == {"r", "p"}
+
+
+def test_fdr_bh_outputs_corrected(df):
+    raw = corr_pairwise(df, method="none", round_to=None).set_index(["var1", "var2"])
+    cor = corr_pairwise(df, method="fdr_bh", round_to=None).set_index(["var1", "var2"])
+    j = raw.join(cor, lsuffix="_r", rsuffix="_c")
+    assert (j["p_corrected"] >= j["p_value_r"] - 1e-12).all()
+    assert j["p_corrected"].dropna().between(0.0, 1.0).all()
+
+
+def test_missing_statsmodels_blocks_noncore_methods(df, monkeypatch):
+    import pcorr.core as core
+    monkeypatch.setattr(core, "_HAS_STATSMODELS", False)
+    with pytest.raises(ImportError):
+        corr_pairwise(df, method="holm")
+    out = corr_pairwise(df, method="bonferroni")
+    assert "p_corrected" in out.columns
+    assert "p_value" in out.columns