corrscore 0.1.0__py3-none-any.whl

corrscore/__init__.py

@@ -0,0 +1,21 @@
+from .backtest import BacktestResult, backtest_zero_overlap
+from .bootstrap import BootstrapResult, circular_block_bootstrap
+from .diebold_mariano import DieboldMarianoResult, diebold_mariano
+from .mcs import MCSResult, model_confidence_set
+from .scoring import matrix_energy_score, matrix_geodesic_variogram_score, matrix_variogram_score
+from .utils import asymmetric_weighted_mean
+
+__all__ = [
+    "matrix_energy_score",
+    "matrix_variogram_score",
+    "matrix_geodesic_variogram_score",
+    "backtest_zero_overlap",
+    "BacktestResult",
+    "circular_block_bootstrap",
+    "BootstrapResult",
+    "diebold_mariano",
+    "DieboldMarianoResult",
+    "model_confidence_set",
+    "MCSResult",
+    "asymmetric_weighted_mean",
+]

corrscore/backtest.py

@@ -0,0 +1,148 @@
+"""The zero-overlap walk-forward backtest driver.
+
+Design note: an earlier sketch of this API had a `window` parameter
+defaulting to `horizon`. Working through the actual mechanics precisely
+during implementation surfaced a cleaner, more honestly-scoped contract,
+documented here rather than silently substituted. This harness does not,
+and cannot, police how much history a caller's `forecast_fn` consults
+internally -- that model is opaque to the harness (it might be a
+full-history discounted filter, a short trailing window, or anything
+else), exactly the same responsibility boundary scikit-learn's
+`TimeSeriesSplit` leaves to the caller. What the harness genuinely *can*
+and does enforce, unconditionally, is that `ground_truth_fn` is always
+called with a start point strictly after the origin
+(`origin + 1 + purge_gap`), never a window that reaches back before or
+across it. That guards against a real class of bug this package exists
+to prevent: computing "ground truth" as a window *ending* near the
+origin rather than a window *starting* strictly after it, which silently
+leaks estimation-window information into the evaluation. This API makes
+that specific mistake structurally impossible to reproduce, since the
+caller never controls the start point passed to `ground_truth_fn`.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping, NamedTuple, Sequence
+
+import numpy as np
+import numpy.typing as npt
+
+from .scoring import matrix_energy_score
+
+ForecastFn = Callable[[int], Mapping[str, Any]]
+GroundTruthFn = Callable[[int, int], npt.ArrayLike]
+ScoreFn = Callable[[Mapping[str, Any], npt.ArrayLike], float]
+SeverityFn = Callable[[npt.NDArray[np.float64]], float]
+
+__all__ = ["BacktestResult", "backtest_zero_overlap"]
+
+
+class BacktestResult(NamedTuple):
+    """Result of `backtest_zero_overlap`.
+
+    Attributes
+    ----------
+    origins : list of int
+        The origins actually scored, in order.
+    scores : dict of str -> ndarray
+        Per-model, per-origin scores, one array per key of the
+        `forecast_fns` mapping passed in, aligned with `origins`.
+    severity : ndarray or None
+        Per-origin realized-severity values (`severity_fn(y)` at each
+        origin), or None if `severity_fn` was not supplied. Intended for
+        `corrscore.asymmetric_weighted_mean`.
+    horizon : int
+    purge_gap : int
+    """
+
+    origins: list[int]
+    scores: dict[str, npt.NDArray[np.float64]]
+    severity: npt.NDArray[np.float64] | None
+    horizon: int
+    purge_gap: int
+
+
+def backtest_zero_overlap(
+    forecast_fns: Mapping[str, ForecastFn] | ForecastFn,
+    ground_truth_fn: GroundTruthFn,
+    origins: Sequence[int],
+    horizon: int,
+    purge_gap: int = 0,
+    score_fn: ScoreFn = matrix_energy_score,
+    severity_fn: SeverityFn | None = None,
+) -> BacktestResult:
+    """Score one or more forecasting methods against a proper,
+    zero-overlap-by-construction ground truth.
+
+    For each `origin` in `origins`: computes
+    `y = ground_truth_fn(origin + 1 + purge_gap, origin + 1 + purge_gap
+    + horizon)`, then scores each `forecast_fns[name](origin)` against
+    `y` via `score_fn`. `purge_gap=0` (the default) gives zero shared
+    days between the forecast origin and the ground-truth window by
+    construction; a larger `purge_gap` is a deliberate relaxation the
+    caller must opt into explicitly -- never a silent default.
+
+    Parameters
+    ----------
+    forecast_fns : callable, or dict of str -> callable
+        Each callable maps an origin (int) to a forecast dict in the
+        shape `matrix_energy_score`/`matrix_variogram_score` expect
+        (see `corrscore.scoring`). A single callable is treated as
+        `{"model": forecast_fns}`. Sharing one `ground_truth_fn` call
+        per origin across every model is deliberate: ground truth is
+        model-independent and often the more expensive computation, and
+        this shape is exactly what `corrscore.circular_block_bootstrap`,
+        `corrscore.diebold_mariano`, and `corrscore.model_confidence_set`
+        expect as input (`result.scores[name]`).
+    ground_truth_fn : callable
+        `(start, end) -> K x K matrix`. Called only with
+        `start = origin + 1 + purge_gap`, `end = start + horizon` --
+        never anything else. It is the caller's responsibility that
+        this function computes a genuinely forward-looking realized
+        estimate from `[start, end)`, not a trailing one -- the timing
+        guard above prevents overlap, but not a `ground_truth_fn` that
+        is itself defined as a trailing window.
+    origins : sequence of int
+    horizon : int
+    purge_gap : int, default=0
+    score_fn : callable, default=matrix_energy_score
+    severity_fn : callable, optional
+        `y -> float`, a per-origin realized-severity summary (e.g. mean
+        absolute off-diagonal correlation) for later use with
+        `corrscore.asymmetric_weighted_mean`.
+
+    Returns
+    -------
+    BacktestResult
+    """
+    if callable(forecast_fns):
+        forecast_fns = {"model": forecast_fns}
+    if purge_gap < 0:
+        raise ValueError(f"purge_gap must be >= 0, got {purge_gap}")
+    if horizon < 1:
+        raise ValueError(f"horizon must be >= 1, got {horizon}")
+
+    names = list(forecast_fns.keys())
+    scores: dict[str, list[float]] = {name: [] for name in names}
+    severities: list[float] = []
+    used_origins: list[int] = []
+
+    for origin in origins:
+        start = origin + 1 + purge_gap
+        end = start + horizon
+        y = np.asarray(ground_truth_fn(start, end), dtype=float)
+        for name in names:
+            forecast = forecast_fns[name](origin)
+            scores[name].append(score_fn(forecast, y))
+        if severity_fn is not None:
+            severities.append(severity_fn(y))
+        used_origins.append(origin)
+
+    scores_arr = {name: np.array(values) for name, values in scores.items()}
+    severity_arr = np.array(severities) if severity_fn is not None else None
+    return BacktestResult(
+        origins=used_origins,
+        scores=scores_arr,
+        severity=severity_arr,
+        horizon=horizon,
+        purge_gap=purge_gap,
+    )

corrscore/bootstrap.py

@@ -0,0 +1,81 @@
+"""Circular block-bootstrap significance testing on paired per-origin
+score differentials, via `arch.bootstrap.CircularBlockBootstrap` -- kept
+as a real dependency rather than vendored, since `arch` clears this
+package's "widely used, actively maintained, field-standard" bar for
+reuse, and block-bootstrap correctness (edge handling, unbiased block
+placement) carries real reimplementation risk for a "just wrap it
+correctly" component.
+"""
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import numpy as np
+import numpy.typing as npt
+from arch.bootstrap import CircularBlockBootstrap
+
+__all__ = ["BootstrapResult", "circular_block_bootstrap"]
+
+
+class BootstrapResult(NamedTuple):
+    """Result of `circular_block_bootstrap` for one block length.
+
+    Attributes
+    ----------
+    obs : float
+        The observed mean of `scores_a - scores_b`.
+    ci_lo, ci_hi : float
+        95% percentile confidence interval from the bootstrap
+        distribution of that mean.
+    p_value : float
+        Two-sided bootstrap p-value for H0: true mean difference = 0.
+    significant : bool
+        `ci_lo > 0 or ci_hi < 0` -- whether zero falls outside the 95%
+        interval.
+    block_len : int
+    n_boot : int
+    """
+
+    obs: float
+    ci_lo: float
+    ci_hi: float
+    p_value: float
+    significant: bool
+    block_len: int
+    n_boot: int
+
+
+def circular_block_bootstrap(
+    scores_a: npt.ArrayLike,
+    scores_b: npt.ArrayLike,
+    block_lengths: list[int],
+    n_boot: int = 2000,
+    seed: int | np.random.Generator | None = None,
+) -> dict[int, BootstrapResult]:
+    """Percentile circular block bootstrap on the paired differential
+    `d_i = scores_a[i] - scores_b[i]`, swept across `block_lengths` as a
+    sensitivity check rather than relying on one automatically "optimal"
+    block length.
+
+    Returns a dict keyed by each entry of `block_lengths`. The most
+    conservative (largest-p) entry is the one worth reporting as the
+    headline result.
+    """
+    diffs = np.asarray(scores_a, dtype=float) - np.asarray(scores_b, dtype=float)
+    results: dict[int, BootstrapResult] = {}
+    for block_len in block_lengths:
+        bs = CircularBlockBootstrap(block_len, diffs, seed=seed)
+        boot_means = bs.apply(lambda z: np.mean(z), n_boot).ravel()
+        ci_lo, ci_hi = np.percentile(boot_means, [2.5, 97.5])
+        tail_frac = min(float(np.mean(boot_means <= 0)), float(np.mean(boot_means >= 0)))
+        p_value = min(1.0, 2.0 * tail_frac)
+        results[block_len] = BootstrapResult(
+            obs=float(diffs.mean()),
+            ci_lo=float(ci_lo),
+            ci_hi=float(ci_hi),
+            p_value=p_value,
+            significant=bool(ci_lo > 0 or ci_hi < 0),
+            block_len=block_len,
+            n_boot=n_boot,
+        )
+    return results

corrscore/diebold_mariano.py

@@ -0,0 +1,129 @@
+"""The Diebold-Mariano test (Diebold & Mariano, 1995), vendored rather
+than depending on the small, thinly-adopted `dieboldmariano` PyPI
+package.
+
+Deliberately mirrors R's `forecast::dm.test` (Hyndman et al.) formula
+by formula -- not because that package is depended on, but because it
+is the field's de facto reference implementation and this module's own
+test suite cross-checks against its output on fixed synthetic data as a
+development-time oracle (`tests/_reference/dm_test_oracle_values.py`),
+per this package's "oracle, not dependency" policy. In particular: the
+Harvey, Leybourne & Newbold (1997) small-sample correction is always
+applied (R's `dm.test` has no toggle for it either) and the p-value
+comes from a Student-t distribution with `n - 1` degrees of freedom, not
+the plain asymptotic normal.
+"""
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import numpy as np
+import numpy.typing as npt
+from scipy.stats import t as student_t
+
+__all__ = ["DieboldMarianoResult", "diebold_mariano"]
+
+
+class DieboldMarianoResult(NamedTuple):
+    """Result of `diebold_mariano`.
+
+    Attributes
+    ----------
+    statistic : float
+        The Harvey-Leybourne-Newbold-corrected DM statistic.
+    p_value : float
+        Two-sided p-value, Student-t with `n - 1` degrees of freedom.
+    mean_diff : float
+        Mean of `loss_a - loss_b` (uncorrected).
+    n : int
+    """
+
+    statistic: float
+    p_value: float
+    mean_diff: float
+    n: int
+
+
+def _autocovariance(d: npt.NDArray[np.float64], lag: int) -> float:
+    """Sample autocovariance at `lag`, normalized by the FULL sample
+    size `n` (not `n - lag`) at every lag -- the convention R's `acf()`
+    uses (and that `forecast::dm.test` relies on for its long-run-
+    variance estimate), not the `n - lag`-normalized "unbiased" variant.
+    Confirmed to matter here: with `n - lag` normalization this
+    function's h=1 oracle cases (lag=0 only, where the two conventions
+    coincide) passed, while every h>1 case (which needs lag>0
+    autocovariances) silently disagreed with R's own output -- exactly
+    how the discrepancy was actually caught."""
+    n = d.size
+    dbar = d.mean()
+    if lag == 0:
+        return float(np.mean((d - dbar) ** 2))
+    return float(np.sum((d[lag:] - dbar) * (d[:-lag] - dbar)) / n)
+
+
+def diebold_mariano(
+    loss_a: npt.ArrayLike,
+    loss_b: npt.ArrayLike,
+    h: int = 1,
+    varestimator: str = "acf",
+) -> DieboldMarianoResult:
+    """Diebold-Mariano test on the paired loss differential
+    `d_t = loss_a[t] - loss_b[t]`.
+
+    Parameters
+    ----------
+    loss_a, loss_b : array-like
+        Per-origin losses (e.g. `BacktestResult.scores[name]`) -- NOT
+        raw forecast errors; unlike R's `dm.test(e1, e2, power=...)`,
+        this function does not apply a power transform, since the
+        objects being compared here are already non-negative scores
+        (energy score, variogram score). Passing already-nonnegative
+        losses with R's `power=1` reproduces this function's `d`
+        exactly (see the reference-oracle test suite).
+    h : int, default=1
+        Forecast horizon. Controls the long-run-variance truncation lag
+        (`h - 1`) and the Harvey-Leybourne-Newbold correction factor.
+    varestimator : {"acf", "bartlett"}, default="acf"
+        "acf": unweighted sum of sample autocovariances up to lag
+        `h - 1` (R's own default, and the only option when `h == 1`,
+        where the two coincide). "bartlett": Bartlett-kernel-weighted
+        sum (`1 - k/h` weights), matching R's `varestimator="bartlett"`.
+
+    Returns
+    -------
+    DieboldMarianoResult
+    """
+    d = np.asarray(loss_a, dtype=float) - np.asarray(loss_b, dtype=float)
+    n = d.size
+    if h < 1:
+        raise ValueError(f"h must be >= 1, got {h}")
+    if h > n:
+        raise ValueError(f"h ({h}) cannot exceed the number of observations ({n})")
+
+    gamma0 = _autocovariance(d, 0)
+    if varestimator == "acf" or h == 1:
+        long_run_var = gamma0 + 2.0 * sum(_autocovariance(d, k) for k in range(1, h))
+    elif varestimator == "bartlett":
+        long_run_var = gamma0 + 2.0 * sum(
+            (1.0 - k / h) * _autocovariance(d, k) for k in range(1, h)
+        )
+    else:
+        raise ValueError(f"Unknown varestimator: {varestimator!r}")
+    long_run_var /= n
+
+    if long_run_var <= 0:
+        raise ValueError(
+            "Estimated long-run variance of the loss differential is <= 0 "
+            "(a degenerate or perfectly-periodic differential); the DM "
+            "statistic is undefined. R's dm.test falls back to h=1 with a "
+            "warning in this situation -- retry with h=1 or varestimator="
+            "'bartlett' explicitly rather than silently doing so here."
+        )
+
+    dbar = float(d.mean())
+    raw_statistic = dbar / np.sqrt(long_run_var)
+    correction = np.sqrt((n + 1 - 2 * h + (h / n) * (h - 1)) / n)
+    statistic = float(raw_statistic * correction)
+    p_value = float(2.0 * student_t.cdf(-abs(statistic), df=n - 1))
+
+    return DieboldMarianoResult(statistic=statistic, p_value=p_value, mean_diff=dbar, n=n)

corrscore/mcs.py

@@ -0,0 +1,143 @@
+"""The Model Confidence Set (Hansen, Lunde & Nason, 2011), vendored
+rather than depending on `model-confidence-set` (JLDC's GitHub-only,
+no-PyPI-release Python port): reproduced directly from the paper, with
+R's actively-maintained CRAN `MCS` package (Catania & Bernardi) and the
+JLDC port used only as development-time correctness references, never
+imported at runtime.
+
+Implements the range statistic (T_R) elimination algorithm: repeatedly
+test whether the current candidate set is statistically distinguishable
+from its own best member; if so, drop the single worst-performing model
+and repeat, until the surviving set cannot be rejected. The null
+distribution and each round's studentizing standard errors both come
+from the SAME joint circular block bootstrap of the loss matrix
+(reusing `arch.bootstrap.CircularBlockBootstrap`, matching this
+package's dependency policy).
+
+Honest scope note: this is this package's own reasonable
+operationalization of Hansen et al.'s range statistic and elimination
+rule, not a literal line-by-line transcription of any specific existing
+implementation's internal choices (e.g. R's `MCS` package's automatic
+block-length selection is not reproduced -- `block_len` is a required,
+caller-chosen parameter here, swept manually if robustness to it
+matters, the same discipline `circular_block_bootstrap` already uses).
+The test suite cross-checks this implementation's *verdict* (which
+models survive) against R's `MCS::MCSprocedure` on fixed synthetic
+data where the correct verdict is unambiguous by construction, not
+byte-exact statistic/p-value agreement -- see
+`tests/test_mcs.py` for why that is the honest bar for this
+specific dependency.
+"""
+from __future__ import annotations
+
+from typing import Mapping, NamedTuple
+
+import numpy as np
+import numpy.typing as npt
+from arch.bootstrap import CircularBlockBootstrap
+
+__all__ = ["MCSResult", "model_confidence_set"]
+
+
+class MCSResult(NamedTuple):
+    """Result of `model_confidence_set`.
+
+    Attributes
+    ----------
+    survivors : list of str
+        Models statistically indistinguishable from the best one at
+        `alpha`, in no particular order.
+    alpha : float
+    eliminated : list of (str, float)
+        Models removed, in elimination order, paired with the round's
+        p-value at the moment of that model's removal.
+    final_p_value : float
+        The surviving set's own p-value (>= alpha; or 1.0 if only one
+        model ever remained, a case in which rejection is trivially
+        impossible).
+    """
+
+    survivors: list[str]
+    alpha: float
+    eliminated: list[tuple[str, float]]
+    final_p_value: float
+
+
+def _round_statistics(
+    sub_loss: npt.NDArray[np.float64], block_len: int, n_boot: int, seed: int | np.random.Generator | None
+) -> tuple[npt.NDArray[np.float64], float]:
+    """One elimination round: pairwise studentized statistics for the
+    current model set, and the bootstrap p-value for the joint range
+    null. Returns `(t_obs, p_value)`, `t_obs` shape (m, m)."""
+    m = sub_loss.shape[1]
+    dbar = np.array([[np.mean(sub_loss[:, i] - sub_loss[:, j]) for j in range(m)] for i in range(m)])
+
+    bs = CircularBlockBootstrap(block_len, sub_loss, seed=seed)
+    boot_dbar = np.empty((n_boot, m, m))
+    for rep, (pos, _kw) in enumerate(bs.bootstrap(n_boot)):
+        resampled = pos[0]
+        boot_dbar[rep] = np.array(
+            [[np.mean(resampled[:, i] - resampled[:, j]) for j in range(m)] for i in range(m)]
+        )
+
+    se = boot_dbar.std(axis=0, ddof=1)
+    se[se == 0] = np.inf  # identical-loss pairs (including the diagonal) -> t_ij = 0, never inf/nan
+    t_obs = dbar / se
+    t_range_obs = float(np.abs(t_obs).max())
+
+    t_boot = (boot_dbar - dbar[None, :, :]) / se[None, :, :]
+    t_range_boot = np.abs(t_boot).max(axis=(1, 2))
+    p_value = float(np.mean(t_range_boot >= t_range_obs))
+    return t_obs, p_value
+
+
+def model_confidence_set(
+    scores: Mapping[str, npt.ArrayLike],
+    alpha: float = 0.10,
+    block_len: int = 5,
+    n_boot: int = 1000,
+    seed: int | np.random.Generator | None = None,
+) -> MCSResult:
+    """The Model Confidence Set via the range statistic.
+
+    Parameters
+    ----------
+    scores : dict of str -> array-like
+        Per-model, per-origin losses, all the same length (e.g.
+        `BacktestResult.scores`). At least two models required.
+    alpha : float, default=0.10
+    block_len : int, default=5
+        Circular block-bootstrap block length. Required and
+        caller-chosen (see module docstring) -- rerun with different
+        values to check robustness, matching `circular_block_bootstrap`.
+    n_boot : int, default=1000
+    seed : int, np.random.Generator, or None
+
+    Returns
+    -------
+    MCSResult
+    """
+    names = list(scores.keys())
+    if len(names) < 2:
+        raise ValueError("model_confidence_set needs at least two models")
+    loss = np.column_stack([np.asarray(scores[name], dtype=float) for name in names])
+
+    current = list(range(len(names)))
+    eliminated: list[tuple[str, float]] = []
+    p_value = 1.0
+
+    while True:
+        if len(current) == 1:
+            p_value = 1.0
+            break
+        sub_names = [names[i] for i in current]
+        t_obs, p_value = _round_statistics(loss[:, current], block_len, n_boot, seed)
+        if p_value >= alpha:
+            break
+        avg_t = t_obs.mean(axis=1)
+        worst_local = int(np.argmax(avg_t))
+        eliminated.append((sub_names[worst_local], p_value))
+        current.pop(worst_local)
+
+    survivors = [names[i] for i in current]
+    return MCSResult(survivors=survivors, alpha=alpha, eliminated=eliminated, final_p_value=p_value)

corrscore/scoring.py

@@ -0,0 +1,373 @@
+"""Matrix-aware proper scoring rules for correlation/covariance-matrix
+forecasts: the energy score (Gneiting & Raftery, 2007) and the variogram
+score (Scheuerer & Hamill, 2015), both adapted to score a full K x K
+matrix rather than the vector-valued observation either was originally
+published for.
+
+Forecast representation (see `matrix_energy_score` and
+`matrix_variogram_score` docstrings for the exact shape of each): a
+plain dict tagged by `"kind"`, dispatching across a closed-form
+tractability spectrum --
+
+  - "point":                     a single deterministic matrix (M=1).
+  - "mixture":                   any number of discrete atoms -- exact,
+                                  O(K_atoms^2) cost, no simulation, for
+                                  any number of atoms (not hard-coded to
+                                  two regimes).
+  - "isotropic_gaussian_mixture": discrete atoms each with an isotropic
+                                  Gaussian scatter -- exact for the
+                                  ENERGY score via the confluent
+                                  hypergeometric mean-norm formula; only
+                                  ever reachable through this explicit
+                                  kind, never inferred from a plain
+                                  ensemble automatically, because the
+                                  isotropy assumption is a real one.
+  - "ensemble":                   a general Monte Carlo draw set -- the
+                                  only kind with no closed form; used for
+                                  anything else, including simulated
+                                  paths from a regime-switching
+                                  correlation model.
+
+`matrix_variogram_score` has a narrower closed form than the energy
+score: exact for "point" and "mixture" (both are fully determined by a
+finite set of deterministic atoms), Monte-Carlo-estimated for "ensemble"
+and "isotropic_gaussian_mixture" -- no closed form for a fractional
+absolute moment of a Gaussian difference has been derived for this
+package; sampling is the honest v1 answer for those two kinds.
+
+`matrix_geodesic_variogram_score` is a geometric (Fisher-Rao-aware)
+variant of `matrix_variogram_score`: every free entry is passed through
+`phi`, the signed Fisher-Rao arc length from rho=0 (a correlation entry's
+distance-to-independence, treating the entry as its own isolated 2x2
+correlation matrix under the affine-invariant metric), before the
+ordinary variogram-score machinery runs on the transformed values. This
+is `matrix_variogram_score` itself, unmodified, called on
+phi-transformed entries -- not a new formula. It needs no new propriety
+argument: |a-b|^p is already conditionally negative definite (of
+negative type) on all of R for any real a, b (the same classical fact
+that already licenses the flat variogram score), and composing a fixed
+measurable transform with an already-valid kernel changes nothing about
+that -- this construction is in fact proper for *any* fixed measurable
+per-entry transform, not only ones with a metric interpretation.
+Validated on synthetic matrices, on a real 16-factor equity-factor
+panel, and -- the one comparison that matters most -- on real,
+walk-forward regime-switching correlation forecast ensembles, where it
+reproduced a statistically significant discrimination advantage over
+the flat variogram score's own blind spot near the boundary of valid
+correlation matrices. A whole-matrix geometric energy-score analogue was
+prototyped alongside this one but did not reproduce the same advantage
+on that comparison, so it is not (yet) shipped in this package; this is,
+for now, the one geometric scoring rule promoted from prototype to
+package code.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping, Sequence
+
+import numpy as np
+import numpy.typing as npt
+from scipy.spatial.distance import pdist
+from scipy.special import gammaln, hyp1f1
+
+Matrix = npt.NDArray[np.float64]
+Forecast = Mapping[str, Any]
+
+__all__ = ["matrix_energy_score", "matrix_variogram_score", "matrix_geodesic_variogram_score"]
+
+
+def _frobenius(a: npt.ArrayLike, b: npt.ArrayLike) -> float:
+    """Full K x K Frobenius distance -- the standard convention for a
+    matrix-valued energy score, not the upper-triangle-only convention
+    `matrix_variogram_score` uses (see that function's own docstring for
+    why the two conventions deliberately differ)."""
+    return float(np.linalg.norm(np.asarray(a, dtype=float) - np.asarray(b, dtype=float), ord="fro"))
+
+
+def _upper(m: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """The K(K-1)/2 free upper-triangle entries (diagonal, always 1 for
+    a correlation matrix, and the mirrored lower triangle both excluded,
+    since they carry no independent information)."""
+    arr = np.asarray(m, dtype=float)
+    k = arr.shape[0]
+    return arr[np.triu_indices(k, k=1)]
+
+
+def _expected_norm_isotropic_gaussian(norm_mu_sq: float, sigma: float, n: int) -> float:
+    """E[||Z||] for Z ~ N(mu, sigma^2 I_n), via the noncentral-chi mean
+    formula (Johnson, Kotz & Balakrishnan, 1994), evaluated through the
+    confluent hypergeometric function `scipy.special.hyp1f1` rather than
+    simulated.
+
+    `norm_mu_sq` is ||mu||^2 -- the formula only depends on mu through
+    this scalar, by spherical symmetry. `n == 0` (a degenerate,
+    parameter-free space, e.g. K=1) returns 0 directly.
+    """
+    if n <= 0:
+        return 0.0
+    if sigma <= 0.0:
+        return float(np.sqrt(norm_mu_sq))
+    log_ratio = gammaln((n + 1) / 2.0) - gammaln(n / 2.0)
+    coef = sigma * np.sqrt(2.0) * np.exp(log_ratio)
+    return float(coef * hyp1f1(-0.5, n / 2.0, -norm_mu_sq / (2.0 * sigma**2)))
+
+
+def _expected_matrix_norm_isotropic(diff_free_entries: npt.NDArray[np.float64], sigma: float) -> float:
+    """E[||A||_F] where A is the (implicit) symmetric, zero-diagonal K x
+    K matrix built by placing an isotropic Gaussian free-entry vector u
+    ~ N(diff_free_entries, sigma^2 I_n) (n = K(K-1)/2) into both the
+    upper and lower triangle. Each free entry appears twice in A (once
+    per triangle), so ||A||_F = sqrt(2) * ||u||_2 -- this reuses
+    `_expected_norm_isotropic_gaussian` above with that bookkeeping
+    factor folded in, not a separate derivation."""
+    n = diff_free_entries.size
+    norm_mu_sq = float(diff_free_entries @ diff_free_entries)
+    return np.sqrt(2.0) * _expected_norm_isotropic_gaussian(norm_mu_sq, sigma, n)
+
+
+def _energy_score_point(q: npt.ArrayLike, y: npt.ArrayLike) -> float:
+    return _frobenius(q, y)
+
+
+def _energy_score_mixture(components: Sequence[tuple[float, npt.ArrayLike]], y: npt.ArrayLike) -> float:
+    weights = np.array([float(p) for p, _ in components])
+    mats = [np.asarray(q, dtype=float) for _, q in components]
+    k = len(mats)
+    term1 = sum(weights[i] * _frobenius(mats[i], y) for i in range(k))
+    term2 = 0.0
+    for i in range(k):
+        for j in range(k):
+            term2 += weights[i] * weights[j] * _frobenius(mats[i], mats[j])
+    return float(term1 - 0.5 * term2)
+
+
+def _energy_score_isotropic_gaussian_mixture(
+    components: Sequence[tuple[float, npt.ArrayLike, float]], y: npt.ArrayLike
+) -> float:
+    weights = np.array([float(p) for p, _, _ in components])
+    mats_u = [_upper(q) for _, q, _ in components]
+    sigmas = [float(s) for _, _, s in components]
+    y_u = _upper(y)
+    k = len(components)
+
+    term1 = 0.0
+    for i in range(k):
+        term1 += weights[i] * _expected_matrix_norm_isotropic(mats_u[i] - y_u, sigmas[i])
+
+    term2 = 0.0
+    for i in range(k):
+        for j in range(k):
+            combined_sigma = float(np.sqrt(sigmas[i] ** 2 + sigmas[j] ** 2))
+            term2 += weights[i] * weights[j] * _expected_matrix_norm_isotropic(mats_u[i] - mats_u[j], combined_sigma)
+
+    return float(term1 - 0.5 * term2)
+
+
+def _energy_score_ensemble(draws: Sequence[npt.ArrayLike], y: npt.ArrayLike) -> float:
+    flat = np.stack([np.asarray(d, dtype=float).ravel() for d in draws])
+    y_flat = np.asarray(y, dtype=float).ravel()
+    m = flat.shape[0]
+    term1 = float(np.mean(np.linalg.norm(flat - y_flat, axis=1)))
+    if m < 2:
+        return term1
+    pairwise = pdist(flat, metric="euclidean")
+    term2 = float(pairwise.sum() / (m**2))
+    return term1 - term2
+
+
+def matrix_energy_score(forecast: Forecast, y: npt.ArrayLike) -> float:
+    """The energy score (Gneiting & Raftery, 2007), dispatched across the
+    closed-form spectrum (module docstring) by `forecast["kind"]`:
+
+    - {"kind": "point", "Q": Q} -> the M=1 special case, plain
+      Frobenius distance.
+    - {"kind": "mixture", "components": [(p_1, Q_1), ..., (p_K, Q_K)]}
+      -> Tier 1, exact. Any number of atoms, not just two.
+    - {"kind": "isotropic_gaussian_mixture",
+       "components": [(p_1, Q_1, sigma_1), ...]} -> Tier 2, exact.
+      `sigma_k` is the per-component scatter in the K(K-1)/2-dimensional
+      free-entry space, not in the full K x K ambient space.
+    - {"kind": "ensemble", "draws": [Q_1, ..., Q_M]} -> Tier 3, the
+      general Monte Carlo form, O(M^2) pairwise distances.
+
+    `y` is the realized K x K correlation (or covariance) matrix.
+    """
+    kind = forecast["kind"]
+    if kind == "point":
+        return _energy_score_point(forecast["Q"], y)
+    if kind == "mixture":
+        return _energy_score_mixture(forecast["components"], y)
+    if kind == "isotropic_gaussian_mixture":
+        return _energy_score_isotropic_gaussian_mixture(forecast["components"], y)
+    if kind == "ensemble":
+        return _energy_score_ensemble(forecast["draws"], y)
+    raise ValueError(f"Unknown forecast kind: {kind!r}")
+
+
+def _variogram_diff_p_point(q: npt.ArrayLike, p: float) -> npt.NDArray[np.float64]:
+    q_u = _upper(q)
+    return np.abs(q_u[:, None] - q_u[None, :]) ** p
+
+
+def _variogram_diff_p_mixture(components: Sequence[tuple[float, npt.ArrayLike]], p: float) -> npt.NDArray[np.float64]:
+    """Exact: a discrete mixture's entries are fully determined once the
+    atom is known, so E|X_i - X_j|^p is just the atom-weighted average
+    of the deterministic per-atom values -- no sampling needed."""
+    weights = [float(w) for w, _ in components]
+    total = None
+    for w, q in zip(weights, (c[1] for c in components)):
+        term = w * _variogram_diff_p_point(q, p)
+        total = term if total is None else total + term
+    assert total is not None
+    return total
+
+
+def _sample_upper_triangle(forecast: Forecast, n_samples: int, rng: np.random.Generator) -> npt.NDArray[np.float64]:
+    """Draws used only by `matrix_variogram_score`'s Monte Carlo path
+    (see module docstring for why "ensemble" and
+    "isotropic_gaussian_mixture" have no closed form here). "ensemble"
+    reuses its existing draws directly (deterministic, no extra
+    sampling); "isotropic_gaussian_mixture" is genuinely sampled."""
+    kind = forecast["kind"]
+    if kind == "ensemble":
+        return np.stack([_upper(d) for d in forecast["draws"]])
+    if kind == "isotropic_gaussian_mixture":
+        components = forecast["components"]
+        weights = np.array([float(w) for w, _, _ in components])
+        weights = weights / weights.sum()
+        atom_idx = rng.choice(len(components), size=n_samples, p=weights)
+        n_free = _upper(components[0][1]).size
+        out = np.empty((n_samples, n_free))
+        for k, (_, q, sigma) in enumerate(components):
+            mask = atom_idx == k
+            count = int(mask.sum())
+            if count == 0:
+                continue
+            noise = rng.normal(0.0, float(sigma), size=(count, n_free)) if sigma > 0 else 0.0
+            out[mask] = _upper(q) + noise
+        return out
+    raise ValueError(f"Forecast kind {kind!r} has no Monte Carlo sampling path")
+
+
+def matrix_variogram_score(
+    forecast: Forecast,
+    y: npt.ArrayLike,
+    p: float = 0.5,
+    weights: npt.ArrayLike | None = None,
+    n_samples: int = 500,
+    random_state: int | np.random.Generator | None = None,
+) -> float:
+    """The variogram score (Scheuerer & Hamill, 2015), adapted to index
+    i, j over the K(K-1)/2 free upper-triangle entries of the
+    correlation matrix, rather than the K original series the published
+    formula was defined for.
+
+    Exact (no sampling) for "point" and "mixture" forecasts. For
+    "ensemble" and "isotropic_gaussian_mixture", `E|X_i - X_j|^p` is
+    estimated by Monte Carlo (`n_samples` draws) -- no closed form for
+    this fractional absolute moment has been derived for this package
+    (unlike `matrix_energy_score`'s Tier 2 path); see the module
+    docstring. Cost and memory scale as O(n_samples * n_entries^2),
+    where n_entries = K(K-1)/2 -- the default `n_samples=500` keeps this
+    modest through K=16 (n_entries=120); pass a smaller value for larger
+    K if memory becomes a concern.
+
+    `weights` (if given) must be an (n_entries, n_entries) array;
+    defaults to uniform (all-ones), matching Scheuerer & Hamill's own
+    default and the published formula literally.
+    """
+    y_u = _upper(y)
+    n = y_u.size
+    y_diff_p = np.abs(y_u[:, None] - y_u[None, :]) ** p
+    w = np.ones((n, n)) if weights is None else np.asarray(weights, dtype=float)
+
+    kind = forecast["kind"]
+    if kind == "point":
+        exp_diff_p = _variogram_diff_p_point(forecast["Q"], p)
+    elif kind == "mixture":
+        exp_diff_p = _variogram_diff_p_mixture(forecast["components"], p)
+    elif kind in ("ensemble", "isotropic_gaussian_mixture"):
+        rng = random_state if isinstance(random_state, np.random.Generator) else np.random.default_rng(random_state)
+        samples = _sample_upper_triangle(forecast, n_samples, rng)
+        exp_diff_p = (np.abs(samples[:, :, None] - samples[:, None, :]) ** p).mean(axis=0)
+    else:
+        raise ValueError(f"Unknown forecast kind: {kind!r}")
+
+    return float(np.sum(w * (y_diff_p - exp_diff_p) ** 2))
+
+
+def _phi(rho: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """Signed Fisher-Rao arc length from rho=0: treats a single
+    correlation entry as its own isolated 2x2 correlation matrix
+    C(rho) = [[1,rho],[rho,1]] under the affine-invariant metric, and
+    returns sign(rho) * d_FR(I, C(rho)). Closed form (derived and
+    verified to machine precision against the general eigenvalue-based
+    Fisher-Rao formula):
+
+        phi(rho) = sign(rho) * sqrt(0.5 * (log(1+|rho|)^2 + log(1-|rho|)^2))
+
+    Smooth, odd, and strictly increasing on (-1, 1) -> R (verified
+    numerically); a close cousin of the century-old Fisher z-transform
+    arctanh(rho), diverging slightly faster as rho -> +-1.
+    """
+    rho = np.asarray(rho, dtype=float)
+    a = np.abs(rho)
+    d = np.sqrt(0.5 * (np.log1p(a) ** 2 + np.log1p(-a) ** 2))
+    return np.sign(rho) * d
+
+
+def _phi_transform_matrix(q: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """`_phi` applied entrywise off-diagonal. The diagonal is zeroed
+    before transforming, not left at the input's own (always exactly
+    1.0) diagonal: `_upper` never reads it, but `_phi(1.0)` is -inf
+    (log1p(-1)), which is harmless numerically (never read) but raises a
+    spurious divide-by-zero warning on every call otherwise."""
+    q = np.asarray(q, dtype=float).copy()
+    np.fill_diagonal(q, 0.0)
+    return _phi(q)
+
+
+def _phi_transform_forecast(forecast: Forecast) -> Forecast:
+    kind = forecast["kind"]
+    if kind == "point":
+        return {"kind": "point", "Q": _phi_transform_matrix(forecast["Q"])}
+    if kind == "mixture":
+        return {"kind": "mixture", "components": [(w, _phi_transform_matrix(q)) for w, q in forecast["components"]]}
+    if kind == "ensemble":
+        return {"kind": "ensemble", "draws": [_phi_transform_matrix(d) for d in forecast["draws"]]}
+    raise ValueError(f"Unknown forecast kind: {kind!r}")
+
+
+def matrix_geodesic_variogram_score(
+    forecast: Forecast,
+    y: npt.ArrayLike,
+    p: float = 0.5,
+    weights: npt.ArrayLike | None = None,
+    n_samples: int = 500,
+    random_state: int | np.random.Generator | None = None,
+) -> float:
+    """The geometric (Fisher-Rao-aware) variogram score: `matrix_
+    variogram_score` itself, unmodified, called on every free entry
+    passed through `_phi` first (see module docstring). Same forecast
+    dict shapes, same `p`/`weights`/`n_samples`/`random_state` semantics,
+    same closed-form-vs-Monte-Carlo split by `forecast["kind"]` as
+    `matrix_variogram_score` -- this function only changes what happens
+    to the raw entries before that machinery runs.
+
+    Proper for the same reason `matrix_variogram_score` is (it elicits a
+    pairwise-moment vector for any fixed measurable per-entry transform)
+    -- no new argument specific to `_phi` is needed. Not strictly proper,
+    for the identical reason the flat variogram score is not, though the
+    two scores' blind spots are provably different (a common shift in
+    phi-space vs. a common shift in raw rho-space) -- running both
+    alongside each other is a real, not just pragmatic, recommendation.
+
+    Validated on real, walk-forward regime-switching correlation forecast
+    ensembles: a statistically significant discrimination advantage over
+    the flat variogram score on that comparison, unlike a separate
+    whole-matrix geodesic energy score prototype, which did not reproduce
+    an advantage there and has accordingly not (yet) been promoted into
+    this package.
+    """
+    y_t = _phi_transform_matrix(y)
+    forecast_t = _phi_transform_forecast(forecast)
+    return matrix_variogram_score(forecast_t, y_t, p=p, weights=weights, n_samples=n_samples, random_state=random_state)

corrscore/utils.py

@@ -0,0 +1,37 @@
+"""Outcome-severity-weighted aggregation -- a small, general-purpose
+utility for weighting per-origin scores by how severe the realized
+outcome was, surfaced while dogfooding this package against a real
+regime-detection backtest.
+"""
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+
+__all__ = ["asymmetric_weighted_mean"]
+
+
+def asymmetric_weighted_mean(values: npt.ArrayLike, severity: npt.ArrayLike, kappa: float = 1.0) -> float:
+    """Weight per-origin `values` (typically per-origin scores from a
+    `BacktestResult`) by realized outcome severity: origins at or above
+    the median `severity` are weighted `kappa` times as heavily as
+    origins below it.
+
+    `severity` should be a non-circular, outcome-derived measure -- e.g.
+    the mean absolute off-diagonal correlation of the realized
+    ground-truth window (`BacktestResult.severity`, via
+    `backtest_zero_overlap`'s `severity_fn`) -- not any model's own
+    regime call, to avoid biasing which origins get up-weighted toward
+    whichever model is being evaluated.
+
+    `kappa=1.0` (the default) reduces to a plain mean.
+    """
+    values_arr = np.asarray(values, dtype=float)
+    severity_arr = np.asarray(severity, dtype=float)
+    if values_arr.shape != severity_arr.shape:
+        raise ValueError(
+            f"values and severity must have the same shape, got {values_arr.shape} and {severity_arr.shape}"
+        )
+    median = np.median(severity_arr)
+    weights = np.where(severity_arr >= median, kappa, 1.0)
+    return float(np.sum(values_arr * weights) / np.sum(weights))

corrscore-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.5
+Name: corrscore
+Version: 0.1.0
+Summary: Matrix-aware proper-scoring-rule backtesting for correlation and covariance forecasts: zero-overlap walk-forward evaluation, energy/variogram scoring, and significance testing (block bootstrap, Diebold-Mariano, Model Confidence Set).
+Author-email: Vinh Nguyen <vinhnguyen3455@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: arch>=6.3
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# corrscore
+
+Matrix-aware proper-scoring-rule backtesting for correlation and covariance forecasts, in Python.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why this exists
+
+Forecasting a correlation or covariance matrix is common in risk management and portfolio
+construction — but evaluating that forecast correctly is not routine. Two mistakes are easy to
+make and hard to notice:
+
+1. **Naive matrix-comparison metrics aren't proper scoring rules.** A metric that isn't a proper
+   scoring rule can reward a forecaster for hedging toward a "safe" answer instead of reporting
+   their honest best guess — the evaluation itself creates bad incentives.
+2. **Walk-forward evaluation windows are easy to overlap with the estimation window**, silently
+   leaking future information into a backtest and inflating apparent skill.
+
+`corrscore` evaluates a forecast; it never produces one. It doesn't fit a model, doesn't implement
+any particular correlation-dynamics model, and doesn't fetch or clean data — it's a focused
+evaluation layer you drop on top of whatever you're already forecasting with.
+
+## What it offers
+
+- **Matrix-aware energy and variogram scores.** The two standard proper scoring rules from the
+  forecast-verification literature, generalized from their usual vector-valued form to score a
+  full `K x K` correlation/covariance matrix directly.
+- **A geometric variant of the variogram score**, aware of the fact that correlation matrices live
+  on a curved space rather than flat Euclidean space — sharper at detecting forecast danger as a
+  matrix approaches the boundary of validity (near-singular, highly correlated regimes).
+- **Four forecast representations**, not just point forecasts: a single deterministic matrix, a
+  discrete mixture of any number of atoms, an isotropic-Gaussian mixture, or a general Monte Carlo
+  ensemble — with closed-form scoring wherever one exists, Monte Carlo estimation only where it
+  doesn't.
+- **A backtesting harness (`backtest_zero_overlap`)** that makes the specific, easy-to-make
+  lookahead bug — ground truth computed from a window that overlaps the forecast origin —
+  structurally impossible to reproduce, rather than something you have to remember to get right.
+- **Significance testing**, not just point comparisons: a circular block bootstrap for
+  serially-dependent score differentials, the Diebold-Mariano test, and the Model Confidence Set
+  — so "is model A really better than model B" has an actual answer.
+
+```python
+from corrscore import matrix_energy_score, backtest_zero_overlap
+from corrscore import circular_block_bootstrap, diebold_mariano, model_confidence_set
+
+result = backtest_zero_overlap(
+    forecast_fns={"naive": naive_forecast, "filter": my_model.forecast},
+    ground_truth_fn=realized_correlation,   # (start, end) -> K x K matrix
+    origins=origins,
+    horizon=10,
+)
+sig = circular_block_bootstrap(result.scores["filter"], result.scores["naive"], block_lengths=[1, 3, 6, 10])
+mcs = model_confidence_set(result.scores, alpha=0.10)
+```
+
+## Install
+
+```bash
+pip install corrscore
+```
+
+Requires Python 3.10-3.12. Runtime dependencies are `numpy`, `scipy`, and `arch` (for the circular
+block bootstrap) — nothing else.
+
+## Validation
+
+Every scoring rule and test in this package is checked against an independent source of truth, not
+just its own self-consistency: `diebold_mariano` and `model_confidence_set` are cross-checked
+against live-generated R oracles (`forecast::dm.test` byte-exact, `MCS::MCSprocedure`
+verdict-matched), and every closed-form scoring formula is checked against brute-force Monte Carlo
+simulation of the object it claims to score. Fully type-hinted and `mypy`-clean. See `tests/` for
+the full suite.
+
+## Related work
+
+No existing package (Python or R) treats a correlation/covariance matrix as the forecast object
+with purge-aware walk-forward splitting and a proper scoring rule built in — see
+[`docs/survey/`](docs/survey/) for the full landscape survey and the specific reuse-vs.-vendor
+decision behind each dependency.
+
+## Citation
+
+A companion paper describing the package's design and methodology is available as a working
+paper on SSRN: [Nguyen (2026), "corrscore: Matrix-Aware Proper Scoring Rules and Significance
+Testing for Correlation and Covariance Forecasts in
+Python"](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=7358478). See
+[`CITATION.cff`](CITATION.cff) for a machine-readable citation.
+
+## Development
+
+```bash
+git clone https://github.com/vinhnguyen3455/corrscore
+cd corrscore
+pip install -e ".[dev]"
+pytest -q
+mypy src/corrscore
+```
+
+Issues and pull requests welcome.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

corrscore-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+corrscore/__init__.py,sha256=xjKePWKScFs2h7EjlYW9HPJIPoNTZU5evw7M4TFGC-E,728
+corrscore/backtest.py,sha256=QfYoZNOFNAB-8vQ_ukS07ZzdWaAk9VXJGhsE9m20Wfk,6143
+corrscore/bootstrap.py,sha256=qJkLDh95JucUQ5NyCsO4zDDPy_Xm3K7X0uaj4KWFbZU,2801
+corrscore/diebold_mariano.py,sha256=Oi3aZDFhZAG5HY3Q5CpjOnHk7-kbejUPwQWIKu-RrJU,5093
+corrscore/mcs.py,sha256=ki6KH47dpFgCaotrCyKa_B9nR2f98cRJ46SD-MZmEsw,5636
+corrscore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+corrscore/scoring.py,sha256=0QJrtjylgaGovnoq7Mdz-oe8J1aDFeVhGPNsRsEVVuc,17546
+corrscore/utils.py,sha256=_CV08KOct3AWVcLV36CmcTkXuiC6qv3ZQu5osJs1xwo,1587
+corrscore-0.1.0.dist-info/METADATA,sha256=eLeYUCpW9opAOLApSmqF1RmnhVuMtMgTmhLmv-LLjRU,5889
+corrscore-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+corrscore-0.1.0.dist-info/licenses/LICENSE,sha256=jB6MybiFM3YMWm7FRRZsoRPq7FOuzYut1XkoQOVGpYU,1068
+corrscore-0.1.0.dist-info/RECORD,,

corrscore-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

corrscore-0.1.0.dist-info/licenses/LICENSE

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