systemgmmkit 0.5.8.dev0__tar.gz → 0.5.9__tar.gz

{systemgmmkit-0.5.8.dev0/src/systemgmmkit.egg-info → systemgmmkit-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemgmmkit
-Version: 0.5.8.dev0
+Version: 0.5.9
 Summary: Generic panel-data econometrics workflow helpers for FE, RE, IV/2SLS, and Difference/System GMM in Python.
 Author: Oluwajuwon Mayomi Akanbi
 License-Expression: MIT

{systemgmmkit-0.5.8.dev0 → systemgmmkit-0.5.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "systemgmmkit"
-version = "0.5.8.dev0"
+version = "0.5.9"
 description = "Generic panel-data econometrics workflow helpers for FE, RE, IV/2SLS, and Difference/System GMM in Python."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -51,7 +51,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.5.8.dev0"
+target-version = "0.5.9"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "B", "UP", "SIM"]
@@ -72,5 +72,3 @@ line-ending = "auto"
 
 
 
-
-

{systemgmmkit-0.5.8.dev0 → systemgmmkit-0.5.9}/src/systemgmmkit/__init__.py

@@ -75,7 +75,7 @@ __all__ = [
     "first_difference",
 ]
 
-__version__ = "0.5.8"
+__version__ = "0.5.9"
 
 import contextlib
 
@@ -107,3 +107,5 @@ from .postestimation import (
 )
 
 
+
+

{systemgmmkit-0.5.8.dev0 → systemgmmkit-0.5.9}/src/systemgmmkit/native_gmm.py

@@ -39,10 +39,6 @@ class NativeGMMResult:
     sargan_p: float | None = None
     ar1_p: float | None = None
     ar2_p: float | None = None
-    ar1_z: float | None = None
-    ar2_z: float | None = None
-    ar1: float | None = None
-    ar2: float | None = None
     z_shape: tuple[int, int] | None = None
     w_shape: tuple[int, int] | None = None
     j_stat: float | None = None
@@ -53,16 +49,6 @@ class NativeGMMResult:
     overid_df: int | None = None
     hansen_j_error: str | None = None
 
-    # Stata/xtabond2-style diagnostic aliases for export/comparison layers.
-    hansen: float | None = None
-    hansenp: float | None = None
-    sargan: float | None = None
-    sarganp: float | None = None
-    n_g: int | None = None
-    df_m: int | None = None
-    df_r: int | None = None
-    j_p: float | None = None
-
     def summary_frame(self) -> pd.DataFrame:
         return pd.DataFrame(
             {
@@ -1253,461 +1239,66 @@ def _native_overid_diagnostics(
     return pvalue, pvalue
 
 
-
-def _native_export_ar_debug_inputs(
-    *,
-    spec: DynamicPanelSpec,
-    data: pd.DataFrame,
-    entity: str,
-    time: str | None,
-    row_index: np.ndarray,
-    residual_vec: np.ndarray,
-    row_meta: object | None = None,
-) -> None:
-    """Export residual-level inputs for AR diagnostic parity research.
-
-    Diagnostic-only. Activated only when SYSTEMGMMKIT_AR_DEBUG_DIR is set.
-    """
-
-    import json as _json
-    import os as _os
-    from pathlib import Path as _Path
-
-    debug_dir_raw = _os.getenv("SYSTEMGMMKIT_AR_DEBUG_DIR")
-    if not debug_dir_raw:
-        return
-
-    debug_dir = _Path(debug_dir_raw)
-    debug_dir.mkdir(parents=True, exist_ok=True)
-
-    safe_name = "".join(
-        ch if ch.isalnum() or ch in "-_." else "_"
-        for ch in str(getattr(spec, "name", "native_gmm"))
-    )
-
-    resid = np.asarray(residual_vec, dtype=float).reshape(-1)
-    idx = np.asarray(row_index).reshape(-1)
-
-    base = data.copy()
-    if time is not None and time in base.columns:
-        base = base.sort_values([entity, time]).copy()
-    else:
-        base = base.sort_values([entity]).copy()
-
-    rows = None
-
-    try:
-        idx_int = idx.astype(int)
-        if (
-            idx_int.size >= resid.size
-            and idx_int.min(initial=0) >= 0
-            and idx_int.max(initial=-1) < len(base)
-        ):
-            rows = base.iloc[idx_int[: resid.size]].copy()
-    except Exception:
-        rows = None
-
-    if rows is None:
-        try:
-            if idx.size >= resid.size:
-                rows = data.loc[idx[: resid.size]].copy()
-        except Exception:
-            rows = None
-
-    if rows is None or len(rows) != resid.size:
-        rows = base.iloc[: min(len(base), resid.size)].copy()
-        resid = resid[: len(rows)]
-
-    out = pd.DataFrame(
-        {
-            "spec_name": str(getattr(spec, "name", "")),
-            "system": bool(getattr(spec, "system", False)),
-            "transformation": str(getattr(spec, "transformation", "")),
-            "row_number": np.arange(len(rows), dtype=int),
-            "row_index": idx[: len(rows)] if idx.size >= len(rows) else np.arange(len(rows)),
-            "entity": rows[entity].to_numpy() if entity in rows.columns else np.nan,
-            "time": rows[time].to_numpy() if time is not None and time in rows.columns else np.nan,
-            "residual": resid,
-        }
-    )
-
-    try:
-        meta = list(row_meta) if row_meta is not None else []
-        if len(meta) >= len(out):
-            eq_values = []
-            raw_values = []
-            for item in meta[: len(out)]:
-                raw_values.append(_json.dumps(item, default=str))
-                eq = None
-                if isinstance(item, dict):
-                    eq = item.get("eq") or item.get("equation") or item.get("block")
-                else:
-                    eq = (
-                        getattr(item, "eq", None)
-                        or getattr(item, "equation", None)
-                        or getattr(item, "block", None)
-                    )
-                eq_values.append(eq)
-            out["equation"] = eq_values
-            out["row_meta"] = raw_values
-    except Exception:
-        pass
-
-    out_path = debug_dir / f"{safe_name}_ar_debug_inputs.csv"
-    out.to_csv(out_path, index=False)
-
-    meta_path = debug_dir / f"{safe_name}_ar_debug_inputs_meta.json"
-    meta_path.write_text(
-        _json.dumps(
-            {
-                "spec_name": str(getattr(spec, "name", "")),
-                "system": bool(getattr(spec, "system", False)),
-                "transformation": str(getattr(spec, "transformation", "")),
-                "n_rows": int(len(out)),
-                "source": "systemgmmkit native AR debug export",
-            },
-            indent=2,
-        ),
-        encoding="utf-8",
-    )
-
-
-
-def _native_xtabond2_ab_serial_correlation_tests(
+def _native_ab_serial_correlation_pvalues(
     *,
     data: pd.DataFrame,
     entity: str,
-    time: str | None,
+    time: str,
     row_index: np.ndarray,
-    residual_vec: np.ndarray,
+    residuals: np.ndarray,
     X: np.ndarray,
-    Z: np.ndarray,
-    W: np.ndarray,
-    bread: np.ndarray,
-    cov: np.ndarray,
     coef_names: list[str],
-    spec: DynamicPanelSpec | None = None,
-    cov_correction: float = 1.0,
-    windmeijer_xtabond2_small_correction: float = 1.0,
-) -> dict[str, float | None]:
-    """Compute xtabond2-compatible Arellano-Bond AR(1)/AR(2) tests.
-
-    This follows xtabond2's robust/two-step specification-test denominator:
-
-        m2VZXA = -2 * e(V_raw) * X'Z * A
-        d = wHw + Xw * (m2VZXA * ZHw' + V_robust * Xw')
-        ar_l = ew_l / sqrt(d)
-
-    where V_raw is the uncorrected GMM bread matrix and V_robust is the
-    robust/Windmeijer base covariance before xtabond2's final small-sample
-    reposting correction. In this implementation that is recovered as:
-
-        V_robust = cov / (cov_correction * windmeijer_xtabond2_small_correction)
+    system: bool,
+) -> tuple[float | None, float | None]:
+    """Experimental Arellano-Bond AR(1)/AR(2)-style residual tests.
 
-    This diagnostic is post-estimation only and does not affect coefficients
-    or standard errors.
+    Uses residuals from differenced-equation rows. For System GMM, level rows
+    are excluded using the level-only `_con` marker.
     """
-    resid = np.asarray(residual_vec, dtype=float).reshape(-1)
-    X = np.asarray(X, dtype=float)
-    Z = np.asarray(Z, dtype=float)
-    W = np.asarray(W, dtype=float)
-    bread = np.asarray(bread, dtype=float)
-    cov = np.asarray(cov, dtype=float)
-
-    if resid.size == 0:
-        return {"ar1_z": None, "ar1_p": None, "ar2_z": None, "ar2_p": None}
-
-    if X.shape[0] != resid.size or Z.shape[0] != resid.size:
-        return {"ar1_z": None, "ar1_p": None, "ar2_z": None, "ar2_p": None}
-
-    base = data.copy()
-    if time is not None and time in base.columns:
-        base = base.sort_values([entity, time]).copy()
-    else:
-        base = base.sort_values([entity]).copy()
-
-    idx = np.asarray(row_index).reshape(-1)
-
     try:
-        idx_int = idx.astype(int)
-        if (
-            idx_int.size == resid.size
-            and idx_int.min(initial=0) >= 0
-            and idx_int.max(initial=-1) < len(base)
-        ):
-            rows = base.iloc[idx_int].copy()
-        elif idx.size == resid.size:
-            rows = data.loc[idx].copy()
-        else:
-            raise ValueError("row_index length does not match residual length")
-    except Exception:
-        # Conservative fallback matching the transformed-equation row order.
-        parts = []
-        for _, g in base.groupby(entity, sort=False):
-            if len(g) > 1:
-                parts.append(g.iloc[1:].copy())
-        rows = pd.concat(parts, axis=0) if parts else base.iloc[:0].copy()
-        rows = rows.iloc[: resid.size].copy()
-
-    if len(rows) != resid.size:
-        n_common = min(len(rows), resid.size, X.shape[0], Z.shape[0])
-        rows = rows.iloc[:n_common].copy()
-        resid = resid[:n_common]
-        X = X[:n_common, :]
-        Z = Z[:n_common, :]
-
-    row_df = pd.DataFrame(
-        {
-            "row_pos": np.arange(resid.size, dtype=int),
-            "entity": rows[entity].to_numpy() if entity in rows.columns else np.arange(resid.size),
-            "resid": resid,
-        }
-    )
-
-    if time is not None and time in rows.columns:
-        row_df["time"] = pd.to_numeric(rows[time].to_numpy(), errors="coerce")
-    else:
-        row_df["time"] = row_df["row_pos"].astype(float)
-
-    row_df["entity_str"] = row_df["entity"].astype(str)
-
-    if spec is not None and bool(getattr(spec, "system", False)) and "_con" in coef_names:
-        con_idx = coef_names.index("_con")
-        # Current stacked System-GMM design: _con == 0 for transformed/difference
-        # rows and _con == 1 for level-equation rows.
-        ar_equation_mask = np.isclose(X[:, con_idx], 0.0)
-    else:
-        ar_equation_mask = np.ones(resid.size, dtype=bool)
-
-    denom_scale = float(cov_correction) * float(windmeijer_xtabond2_small_correction)
-    if not np.isfinite(denom_scale) or denom_scale <= 0:
-        denom_scale = 1.0
-
-    v_robust_for_ar = cov / denom_scale
-
-    ZX = X.T @ Z
-    m2VZXA = -2.0 * bread @ ZX @ W
-
-    def _compute_lag(lag: int) -> tuple[float | None, float | None]:
-        df = row_df.copy()
-        df["w"] = 0.0
-        df["is_ar_equation"] = ar_equation_mask
-
-        ar_df = df[df["is_ar_equation"]].copy()
-        ar_df = ar_df.sort_values(["entity_str", "time", "row_pos"]).copy()
-
-        lagged_rows: list[tuple[int, float]] = []
-
-        for _, g in ar_df.groupby("entity_str", sort=False):
-            g = g.sort_values(["time", "row_pos"]).copy()
-            r = g["resid"].to_numpy(dtype=float)
-            pos = g["row_pos"].to_numpy(dtype=int)
-
-            if len(r) <= lag:
-                continue
-
-            for jj in range(lag, len(r)):
-                lagged_rows.append((int(pos[jj]), float(r[jj - lag])))
-
-        if lagged_rows:
-            lagged = pd.DataFrame(lagged_rows, columns=["row_pos", "w_value"])
-            df = df.merge(lagged, on="row_pos", how="left")
-            df["w"] = df["w_value"].fillna(0.0)
-            df = df.drop(columns=["w_value"])
-
-        df["ewvar"] = np.where(df["is_ar_equation"], df["w"] * df["resid"], np.nan)
-
-        ew = float(np.nansum(df["ewvar"].to_numpy(dtype=float)))
-        if not np.isfinite(ew) or ew == 0:
-            return None, None
-
-        group_ew = (
-            df.groupby("entity_str", sort=False)["ewvar"]
-            .sum(min_count=1)
-            .fillna(0.0)
-            .rename("group_ew")
-        )
-        df = df.join(group_ew, on="entity_str")
-
-        w = df["w"].to_numpy(dtype=float)
-        group_ew_row = df["group_ew"].to_numpy(dtype=float)
-
-        # xtabond2 robust branch:
-        # by id: ewi = sum(ewvar)
-        # etmp = sign(ewi) * e
-        # iweight = abs(ewi)
-        # weighted etmp contribution is therefore ewi * e.
-        weighted_e = group_ew_row * resid
-
-        ZHw = weighted_e.reshape(1, -1) @ Z
-        wHw = float(np.asarray(weighted_e.reshape(1, -1) @ w.reshape(-1, 1)).squeeze())
-
-        mask = df["is_ar_equation"].to_numpy(dtype=bool)
-        Xw = w[mask].reshape(1, -1) @ X[mask, :]
-
-        d = float(
-            np.asarray(
-                wHw + Xw @ (m2VZXA @ ZHw.T + v_robust_for_ar @ Xw.T)
-            ).squeeze()
-        )
-
-        if not np.isfinite(d) or d <= 0:
-            return None, None
-
-        z = float(ew / np.sqrt(d))
-        p = float(2.0 * stats.norm.sf(abs(z)))
-        return z, p
-
-    ar1_z, ar1_p = _compute_lag(1)
-    ar2_z, ar2_p = _compute_lag(2)
-
-    return {
-        "ar1_z": ar1_z,
-        "ar1_p": ar1_p,
-        "ar2_z": ar2_z,
-        "ar2_p": ar2_p,
-    }
-
+        resid = np.asarray(residuals, dtype=float).reshape(-1)
+        idx = np.asarray(row_index)
 
-def _native_ab_serial_correlation_tests(
-    *,
-    data: pd.DataFrame,
-    entity: str,
-    time: str | None,
-    row_index: np.ndarray,
-    residual_vec: np.ndarray,
-    spec: DynamicPanelSpec | None = None,
-    **_: object,
-) -> dict[str, float | None]:
-    """Compute experimental Arellano-Bond-style AR(1)/AR(2) diagnostics.
-
-    WARNING:
-    This diagnostic is not yet xtabond2-certified. It is exposed for
-    post-estimation development only and must not be described as parity-certified
-    until the AR candidate harness reproduces Stata's AR(1)/AR(2) z-statistics.
-
-    This post-estimation diagnostic intentionally does not affect coefficient
-    or covariance estimation.
-
-    Implementation policy:
-    - Use entity-level differenced-equation residuals.
-    - For System GMM, ignore the level-equation residual block and use only the
-      differenced-equation residual block.
-    - Report signed z-statistics and two-sided normal p-values.
-    - Use entity-cluster moment aggregation: for lag m, compute each entity's
-      residual product sum and standardize the cross-entity moment.
-
-    This is closer to xtabond2's m-test logic than the previous simple pooled
-    residual correlation heuristic, and it exposes z-statistics for parity
-    comparison.
-    """
-
-    from scipy import stats as _stats
-
-    resid = np.asarray(residual_vec, dtype=float).reshape(-1)
-    idx = np.asarray(row_index).reshape(-1)
-
-    if resid.size == 0:
-        return {"ar1_z": None, "ar1_p": None, "ar2_z": None, "ar2_p": None}
-
-    # Sort data deterministically by entity/time. Use row_index to map residuals
-    # back to entity/time rows whenever possible.
-    base = data.copy()
-    if time is not None and time in base.columns:
-        base = base.sort_values([entity, time]).copy()
-    else:
-        base = base.sort_values([entity]).copy()
-
-    # For System GMM, residual_vec usually stacks:
-    #   [differenced-equation residuals, level-equation residuals]
-    # AR tests should use only the differenced-equation block.
-    # In the maintained FD001 benchmark this corresponds to sum(T_i - 1).
-    if spec is not None and bool(getattr(spec, "system", False)):
-        diff_n = int(
-            sum(max(len(g) - 1, 0) for _, g in base.groupby(entity, sort=False))
-        )
-        if 0 < diff_n <= resid.size:
-            resid = resid[:diff_n]
-            idx = idx[: min(idx.size, diff_n)]
-
-    # Build residual frame. Prefer positional row mapping because native matrix
-    # construction uses sorted working rows.
-    try:
-        idx_int = idx.astype(int)
-        if idx_int.size == resid.size and idx_int.min(initial=0) >= 0 and idx_int.max(initial=-1) < len(base):
-            rows = base.iloc[idx_int].copy()
-        elif idx.size == resid.size:
-            rows = data.loc[idx].copy()
+        if system and "_con" in coef_names:
+            con_col = coef_names.index("_con")
+            diff_mask = ~np.isclose(np.asarray(X[:, con_col], dtype=float), 1.0)
         else:
-            raise ValueError("row_index length does not match residual length")
-    except Exception:
-        # Fallback: take the final len(resid) sorted differenced rows by entity.
-        parts = []
-        for _, g in base.groupby(entity, sort=False):
-            if len(g) > 1:
-                parts.append(g.iloc[1:].copy())
-        rows = pd.concat(parts, axis=0) if parts else base.iloc[:0].copy()
-        rows = rows.iloc[: resid.size].copy()
-
-    if len(rows) != resid.size:
-        n = min(len(rows), resid.size)
-        rows = rows.iloc[:n].copy()
-        resid = resid[:n]
-
-    rows["_native_ab_resid"] = resid
-
-    if time is not None and time in rows.columns:
-        rows = rows.sort_values([entity, time]).copy()
-    else:
-        rows = rows.sort_values([entity]).copy()
+            diff_mask = np.ones_like(resid, dtype=bool)
 
-    def one_lag(lag: int) -> tuple[float | None, float | None]:
-        cluster_moments: list[float] = []
-
-        for _, g in rows.groupby(entity, sort=False):
-            u = np.asarray(g["_native_ab_resid"], dtype=float)
-            u = u[np.isfinite(u)]
-
-            if u.size <= lag:
-                continue
+        idx = idx[diff_mask]
+        resid = resid[diff_mask]
 
-            moment = float(np.sum(u[lag:] * u[:-lag]))
-            if np.isfinite(moment):
-                cluster_moments.append(moment)
+        panel_keys = data.loc[idx, [entity, time]].copy()
+        panel_keys["_resid"] = resid
+        panel_keys = panel_keys.sort_values([entity, time])
 
-        if len(cluster_moments) < 2:
-            return None, None
+        def _lag_test(lag: int) -> float | None:
+            d = panel_keys.copy()
+            d["_lag"] = d.groupby(entity)["_resid"].shift(lag)
+            d = d.dropna(subset=["_resid", "_lag"])
 
-        m = np.asarray(cluster_moments, dtype=float)
-        numerator = float(np.sum(m))
-        denominator = float(np.sqrt(np.sum(m * m)))
+            if len(d) < 5:
+                return None
 
-        if not np.isfinite(denominator) or denominator <= 0:
-            return None, None
+            a = d["_resid"].to_numpy(dtype=float)
+            b = d["_lag"].to_numpy(dtype=float)
 
-        z = numerator / denominator
-        p = float(2.0 * _stats.norm.sf(abs(z)))
+            denom = float(np.sqrt(np.sum(a * a) * np.sum(b * b)))
+            if denom <= 0:
+                return None
 
-        return float(z), p
+            corr = float(np.sum(a * b) / denom)
+            z = corr * np.sqrt(len(d))
 
-    ar1_z, ar1_p = one_lag(1)
-    ar2_z, ar2_p = one_lag(2)
+            if not np.isfinite(z):
+                return None
 
-    return {
-        "ar1_z": ar1_z,
-        "ar1_p": ar1_p,
-        "ar2_z": ar2_z,
-        "ar2_p": ar2_p,
-    }
+            return float(2.0 * stats.norm.sf(abs(z)))
 
+        return _lag_test(1), _lag_test(2)
 
-def _native_ab_serial_correlation_pvalues(
-    **kwargs: object,
-) -> tuple[float | None, float | None]:
-    """Backward-compatible wrapper returning only AR p-values."""
-
-    tests = _native_ab_serial_correlation_tests(**kwargs)
-    return tests.get("ar1_p"), tests.get("ar2_p")
+    except Exception:
+        return None, None
 
 
 def _native_fod_difference_windmeijer_covariance(
@@ -2159,155 +1750,16 @@ def run_native_dynamic_panel_gmm(
         n_params=len(names),
     )
 
-    # Optional late-stage matrix dump for xtabond2 AR-test parity.
-    #
-    # This dump is intentionally placed after final W, bread, residuals, and
-    # covariance are available. The earlier SYSTEMGMMKIT_NATIVE_MATRIX_DUMP_DIR
-    # dump occurs before final System-GMM Z/W/covariance construction and is
-    # therefore not sufficient for reproducing xtabond2's AR denominator:
-    #   d = wHw + Xw * (m2VZXA * ZHw' + Vrobust * Xw')
-    import os as _native_ar_formula_os
-
-    native_ar_formula_dump_dir = _native_ar_formula_os.getenv(
-        "SYSTEMGMMKIT_NATIVE_AR_FORMULA_DUMP_DIR"
-    )
-    if native_ar_formula_dump_dir:
-        import json as _native_ar_formula_json
-        from pathlib import Path as _NativeArFormulaDumpPath
-
-        dump_dir = _NativeArFormulaDumpPath(native_ar_formula_dump_dir)
-        dump_dir.mkdir(parents=True, exist_ok=True)
-
-        safe_name = "".join(
-            ch if ch.isalnum() or ch in "-_." else "_"
-            for ch in str(getattr(spec, "name", "native_gmm"))
-        )
-
-        npz_path = dump_dir / f"{safe_name}_ar_formula_inputs.npz"
-        json_path = dump_dir / f"{safe_name}_ar_formula_inputs.json"
-        row_meta_path = dump_dir / f"{safe_name}_row_meta.json"
-
-        def _object_array_from_list(values):
-            arr = np.empty(len(values), dtype=object)
-            for ii, vv in enumerate(values):
-                arr[ii] = np.asarray(vv)
-            return arr
-
-        _group_indices_obj = _object_array_from_list(group_indices_for_cov)
-
-        _maybe_windmeijer_base_cov = locals().get("windmeijer_base_cov", None)
-        _maybe_vcov_step1 = locals().get("vcov_step1", None)
-        _maybe_s_group = locals().get("s_group", None)
-        _maybe_s_group_diag = locals().get("_s_group_diag", None)
-
-        np.savez_compressed(
-            npz_path,
-            y=np.asarray(y, dtype=float),
-            X=np.asarray(X, dtype=float),
-            Z=np.asarray(Z, dtype=float),
-            beta=np.asarray(beta, dtype=float),
-            beta1=np.asarray(beta1, dtype=float),
-            residuals=np.asarray(residuals, dtype=float),
-            residuals1=np.asarray(residuals1, dtype=float),
-            residual_vec=np.asarray(residual_vec, dtype=float),
-            W1=np.asarray(W1, dtype=float),
-            W=np.asarray(W, dtype=float),
-            bread=np.asarray(bread, dtype=float),
-            D=np.asarray(D, dtype=float),
-            ZX=np.asarray(D, dtype=float),
-            cov=np.asarray(cov, dtype=float),
-            windmeijer_base_cov=(
-                np.asarray(_maybe_windmeijer_base_cov, dtype=float)
-                if _maybe_windmeijer_base_cov is not None
-                else np.asarray([], dtype=float)
-            ),
-            vcov_step1=(
-                np.asarray(_maybe_vcov_step1, dtype=float)
-                if _maybe_vcov_step1 is not None
-                else np.asarray([], dtype=float)
-            ),
-            s_group=(
-                np.asarray(_maybe_s_group, dtype=float)
-                if _maybe_s_group is not None
-                else np.asarray([], dtype=float)
-            ),
-            s_group_diag=(
-                np.asarray(_maybe_s_group_diag, dtype=float)
-                if _maybe_s_group_diag is not None
-                else np.asarray([], dtype=float)
-            ),
-            row_index=np.asarray([str(v) for v in row_index], dtype=object),
-            row_entities_for_cov=np.asarray([str(v) for v in row_entities_for_cov], dtype=object),
-            group_indices=_group_indices_obj,
-            coef_names=np.asarray(names, dtype=object),
-            instrument_names=np.asarray(instrument_names, dtype=object),
-        )
-
-        with contextlib.suppress(Exception):
-            row_meta_path.write_text(
-                _native_ar_formula_json.dumps(row_meta, indent=2, default=str),
-                encoding="utf-8",
-            )
-
-        json_path.write_text(
-            _native_ar_formula_json.dumps(
-                {
-                    "spec": str(getattr(spec, "name", "")),
-                    "system": bool(getattr(spec, "system", False)),
-                    "transformation": str(getattr(spec, "transformation", "")),
-                    "steps": str(getattr(spec, "steps", "")),
-                    "windmeijer_requested": bool(windmeijer_requested),
-                    "use_twostep": bool(use_twostep),
-                    "nobs_effective": int(nobs_effective),
-                    "nobs_reported": int(nobs_reported),
-                    "n_groups_for_cov": int(n_groups_for_cov),
-                    "n": int(n),
-                    "k": int(k),
-                    "j": int(Z.shape[1]),
-                    "x_shape": list(X.shape),
-                    "z_shape": list(Z.shape),
-                    "w1_shape": list(W1.shape),
-                    "w_shape": list(W.shape),
-                    "bread_shape": list(bread.shape),
-                    "cov_shape": list(cov.shape),
-                    "coef_names": list(names),
-                    "instrument_names": list(instrument_names),
-                    "cov_correction": float(locals().get("cov_correction", 1.0)),
-                    "windmeijer_xtabond2_small_correction": float(
-                        locals().get("windmeijer_xtabond2_small_correction", 1.0)
-                    ),
-                    "has_windmeijer_base_cov": _maybe_windmeijer_base_cov is not None,
-                    "has_vcov_step1": _maybe_vcov_step1 is not None,
-                    "has_s_group": _maybe_s_group is not None,
-                    "has_s_group_diag": _maybe_s_group_diag is not None,
-                },
-                indent=2,
-            ),
-            encoding="utf-8",
-        )
-
-    _ar_serial = _native_xtabond2_ab_serial_correlation_tests(
+    ar1_p, ar2_p = _native_ab_serial_correlation_pvalues(
         data=data,
         entity=entity,
         time=time,
         row_index=np.asarray(row_index),
-        residual_vec=residual_vec,
+        residuals=residual_vec,
         X=X,
-        Z=Z,
-        W=W,
-        bread=bread,
-        cov=cov,
         coef_names=names,
-        spec=spec,
-        cov_correction=float(locals().get("cov_correction", 1.0)),
-        windmeijer_xtabond2_small_correction=float(
-            locals().get("windmeijer_xtabond2_small_correction", 1.0)
-        ),
+        system=spec.system,
     )
-    ar1_z = _ar_serial.get("ar1_z")
-    ar1_p = _ar_serial.get("ar1_p")
-    ar2_z = _ar_serial.get("ar2_z")
-    ar2_p = _ar_serial.get("ar2_p")
 
     _u_col = residual_vec.reshape(-1, 1)
     _ztu = Z.T @ _u_col
@@ -2385,70 +1837,6 @@ def run_native_dynamic_panel_gmm(
     # reporting a misleading pseudo-Hansen p-value.
     hansen_p = None
 
-    # xtabond2-compatible overidentification diagnostics for the maintained
-    # first-difference two-step path.
-    #
-    # xtabond2 computes:
-    #   Sargan = e1' Z A1 e1, with A1 rescaled by 1/sig2
-    #   Hansen = e2' Z A2 e2, with robust two-step moment covariance scaling
-    #
-    # In the native matrix normalization used here, the FD001 parity harness
-    # identifies the equivalent formulas as:
-    #   Hansen = (u2' Z W2 Z' u2) / n_groups
-    #   Sargan = (u1' Z W1 Z' u1) / sig2
-    #   sig2   = sum(e1_diff^2) / nobs_effective / 2
-    #
-    # This override is deliberately restricted to FD two-step style estimation
-    # to avoid changing non-FD/FOD behavior before separate certification.
-    try:
-        _is_fd_transformation_for_overid = (
-            str(getattr(spec, "transformation", "")).strip().lower() == "fd"
-        )
-
-        if use_twostep and _is_fd_transformation_for_overid:
-            _u2_overid = np.asarray(residual_vec, dtype=float).reshape(-1, 1)
-            _u1_overid = np.asarray(residuals1, dtype=float).reshape(-1, 1)
-
-            _ztu2 = Z.T @ _u2_overid
-            _hansen_raw_xtabond2 = float(np.asarray(_ztu2.T @ W @ _ztu2).squeeze())
-            _hansen_j_stat = _hansen_raw_xtabond2 / max(float(n_groups_for_cov), 1.0)
-
-            if _overid_df > 0 and np.isfinite(_hansen_j_stat) and _hansen_j_stat >= 0:
-                _hansen_p_candidate = float(stats.chi2.sf(_hansen_j_stat, _overid_df))
-            else:
-                _hansen_p_candidate = None
-
-            if spec.system and "_con" in names:
-                _con_col_for_sargan_sig2 = names.index("_con")
-                _sargan_sig2_mask = np.isclose(X[:, _con_col_for_sargan_sig2], 0.0)
-            else:
-                _sargan_sig2_mask = np.ones(np.asarray(residuals1).reshape(-1).shape[0], dtype=bool)
-
-            _e1_for_sig2 = np.asarray(residuals1, dtype=float).reshape(-1)[_sargan_sig2_mask]
-            _e1_for_sig2 = _e1_for_sig2[np.isfinite(_e1_for_sig2)]
-
-            if _e1_for_sig2.size:
-                _sig2_xtabond2_sargan = (
-                    float(np.sum(_e1_for_sig2 ** 2))
-                    / max(float(nobs_effective), 1.0)
-                    / 2.0
-                )
-
-                if np.isfinite(_sig2_xtabond2_sargan) and _sig2_xtabond2_sargan > 0:
-                    _ztu1 = Z.T @ _u1_overid
-                    _sargan_unscaled_xtabond2 = float(
-                        np.asarray(_ztu1.T @ W1 @ _ztu1).squeeze()
-                    )
-                    _sargan_stat = _sargan_unscaled_xtabond2 / _sig2_xtabond2_sargan
-
-                    if _overid_df > 0 and np.isfinite(_sargan_stat) and _sargan_stat >= 0:
-                        sargan_p = float(stats.chi2.sf(_sargan_stat, _overid_df))
-                    else:
-                        sargan_p = None
-
-    except Exception as exc:
-        _hansen_j_error = f"{type(exc).__name__}: {exc}"
-
 
     _ztu_norm = float(np.linalg.norm(_ztu))
     _w_norm = float(np.linalg.norm(W))
@@ -2550,11 +1938,6 @@ def run_native_dynamic_panel_gmm(
                 index=False,
             )
 
-    _df_m_export = int(len(names) - (1 if "_con" in names else 0))
-    _df_r_export = int(n_groups_for_cov - (1 if bool(spec.system) else 0))
-    _j_p_export = None
-
-
     return NativeGMMResult(
         spec=spec,
         nobs=int(nobs_reported),
@@ -2585,18 +1968,10 @@ def run_native_dynamic_panel_gmm(
             ),
         ],
         instrument_names=list(instrument_names),
-        # Use the robust Hansen p-value candidate computed from the
-        # group-moment robust covariance when available. The earlier
-        # hansen_p variable is intentionally left undefined for two-step
-        # robust/Windmeijer paths to avoid reporting the old pseudo-Hansen.
-        hansen_p=_hansen_p_candidate,
+        hansen_p=hansen_p,
         sargan_p=sargan_p,
         ar1_p=ar1_p,
         ar2_p=ar2_p,
-        ar1_z=ar1_z,
-        ar2_z=ar2_z,
-        ar1=ar1_z,
-        ar2=ar2_z,
         z_shape=tuple(Z.shape),
         w_shape=tuple(W.shape),
         j_stat=_j_stat,
@@ -2606,20 +1981,6 @@ def run_native_dynamic_panel_gmm(
         sargan_j_stat=_sargan_stat,
         overid_df=_overid_df,
         hansen_j_error=_hansen_j_error,
-
-        # Export aliases used by Stata/xtabond2 comparison workflows.
-        hansen=_hansen_j_stat,
-        hansenp=_hansen_p_candidate,
-        sargan=_sargan_stat,
-        sarganp=(
-            float(stats.chi2.sf(_sargan_stat, _overid_df))
-            if _sargan_stat is not None and _overid_df is not None and _overid_df > 0
-            else None
-        ),
-        n_g=int(data[entity].nunique()) if entity in data.columns else None,
-        df_m=_df_m_export,
-        df_r=_df_r_export,
-        j_p=_j_p_export,
     )
 
 

{systemgmmkit-0.5.8.dev0 → systemgmmkit-0.5.9/src/systemgmmkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemgmmkit
-Version: 0.5.8.dev0
+Version: 0.5.9
 Summary: Generic panel-data econometrics workflow helpers for FE, RE, IV/2SLS, and Difference/System GMM in Python.
 Author: Oluwajuwon Mayomi Akanbi
 License-Expression: MIT