cyb50-quant/research/dragon/v2/dragon_glued_refined_year_regime_review.py

from __future__ import annotations

from pathlib import Path

import pandas as pd


def _load_csv(base_dir: Path, name: str) -> pd.DataFrame:
    return pd.read_csv(base_dir / name, encoding="utf-8-sig")


def main() -> None:
    base_dir = Path(__file__).resolve().parent
    yearly = _load_csv(base_dir, "dragon_glued_refined_yearly_breakdown.csv")
    regime = _load_csv(base_dir, "dragon_glued_refined_regime_breakdown.csv")
    family = _load_csv(base_dir, "dragon_glued_refined_family_breakdown.csv")
    holding = _load_csv(base_dir, "dragon_glued_refined_holding_breakdown.csv")

    alpha_year = yearly[yearly["branch"] == "alpha_first_selective_veto"].copy()
    refined_year = yearly[yearly["branch"] == "alpha_first_glued_refined_hot_cap"].copy()
    year_cmp = alpha_year.merge(refined_year, on="sell_year", suffixes=("_alpha", "_refined"))
    year_cmp["delta_avg_return"] = year_cmp["avg_return_refined"] - year_cmp["avg_return_alpha"]
    year_cmp["delta_profit_factor"] = year_cmp["profit_factor_refined"] - year_cmp["profit_factor_alpha"]
    year_cmp.to_csv(base_dir / "dragon_glued_refined_year_regime_review.csv", index=False, encoding="utf-8-sig")

    alpha_regime = regime[regime["branch"] == "alpha_first_selective_veto"].copy()
    refined_regime = regime[regime["branch"] == "alpha_first_glued_refined_hot_cap"].copy()
    regime_cmp = alpha_regime.merge(refined_regime, on="regime_bucket", suffixes=("_alpha", "_refined"))
    regime_cmp["delta_avg_return"] = regime_cmp["avg_return_refined"] - regime_cmp["avg_return_alpha"]
    regime_cmp["delta_profit_factor"] = regime_cmp["profit_factor_refined"] - regime_cmp["profit_factor_alpha"]
    regime_cmp.to_csv(base_dir / "dragon_glued_refined_regime_review.csv", index=False, encoding="utf-8-sig")

    alpha_holding = holding[holding["branch"] == "alpha_first_selective_veto"].copy()
    refined_holding = holding[holding["branch"] == "alpha_first_glued_refined_hot_cap"].copy()
    holding_cmp = alpha_holding.merge(refined_holding, on="holding_bucket", suffixes=("_alpha", "_refined"))
    holding_cmp["delta_avg_return"] = holding_cmp["avg_return_refined"] - holding_cmp["avg_return_alpha"]
    holding_cmp["delta_profit_factor"] = holding_cmp["profit_factor_refined"] - holding_cmp["profit_factor_alpha"]
    holding_cmp.to_csv(base_dir / "dragon_glued_refined_holding_review.csv", index=False, encoding="utf-8-sig")

    alpha_family = family[family["branch"] == "alpha_first_selective_veto"].copy()
    refined_family = family[family["branch"] == "alpha_first_glued_refined_hot_cap"].copy()
    family_cmp = alpha_family.merge(refined_family, on="entry_family", suffixes=("_alpha", "_refined"))
    family_cmp["delta_avg_return"] = family_cmp["avg_return_refined"] - family_cmp["avg_return_alpha"]
    family_cmp["delta_profit_factor"] = family_cmp["profit_factor_refined"] - family_cmp["profit_factor_alpha"]
    family_cmp.to_csv(base_dir / "dragon_glued_refined_family_review.csv", index=False, encoding="utf-8-sig")

    year_better = int((year_cmp["delta_avg_return"] > 0).sum())
    regime_better = int((regime_cmp["delta_avg_return"] > 0).sum())
    holding_better = int((holding_cmp["delta_avg_return"] > 0).sum())
    top_family_deltas = family_cmp.sort_values("delta_avg_return", ascending=False).head(8)

    lines = [
        "# Dragon Glued Refined Year/Regime Review",
        "",
        "## Yearly Comparison",
        f"- refined improves avg_return in `{year_better}` yearly buckets out of `{int(len(year_cmp))}`",
    ]
    for _, row in year_cmp.sort_values("sell_year").iterrows():
        lines.append(
            f"- `{int(row['sell_year'])}`: alpha `{row['avg_return_alpha']:.2%}` vs refined `{row['avg_return_refined']:.2%}`, "
            f"delta `{row['delta_avg_return']:.2%}`"
        )

    lines.extend(
        [
            "",
            "## Regime Comparison",
            f"- refined improves avg_return in `{regime_better}` regime buckets out of `{int(len(regime_cmp))}`",
        ]
    )
    for _, row in regime_cmp.sort_values("regime_bucket").iterrows():
        lines.append(
            f"- `{row['regime_bucket']}`: alpha `{row['avg_return_alpha']:.2%}` vs refined `{row['avg_return_refined']:.2%}`, "
            f"delta `{row['delta_avg_return']:.2%}`"
        )

    lines.extend(
        [
            "",
            "## Holding-Bucket Comparison",
            f"- refined improves avg_return in `{holding_better}` holding buckets out of `{int(len(holding_cmp))}`",
        ]
    )
    for _, row in holding_cmp.sort_values("holding_bucket").iterrows():
        lines.append(
            f"- `{row['holding_bucket']}`: alpha `{row['avg_return_alpha']:.2%}` vs refined `{row['avg_return_refined']:.2%}`, "
            f"delta `{row['delta_avg_return']:.2%}`"
        )

    lines.extend(["", "## Entry-Family Comparison"])
    for _, row in top_family_deltas.iterrows():
        lines.append(
            f"- `{row['entry_family']}`: alpha `{row['avg_return_alpha']:.2%}` vs refined `{row['avg_return_refined']:.2%}`, "
            f"delta `{row['delta_avg_return']:.2%}`, alpha trades `{int(row['trades_alpha'])}`, refined trades `{int(row['trades_refined'])}`"
        )

    lines.extend(
        [
            "",
            "## Quant Judgment",
            "- This review checks whether improvement is broad-based or concentrated in a narrow slice of the sample.",
            "- If refined mainly wins through short-holding cleanup while not damaging medium and long holding buckets, the branch is behaving as intended.",
        ]
    )

    (base_dir / "dragon_glued_refined_year_regime_review.md").write_text("\n".join(lines) + "\n", encoding="utf-8")


if __name__ == "__main__":
    main()