exp_1150

FORMULA_NAME = "Contrarian 52-Week Recovery with Quality Conflict Arbitration (v1150)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=contrarian-52w-recovery-quality-hybrid
New hybrid family that fuses a deep-contrarian 52-week drawdown sleeve with a recovery-quality durability sleeve, but only after an explicit conflict check: violent rebounds without enough balance-sheet/earnings/liquidity support get capped, while high-quality businesses with only partial repair can still win in stressed tapes if their tradability and volatility profile are strong. The structure is intentionally not a flat average: each regime branch changes both the sleeve mix and the arbitration rule.
Deliberate metric coverage: actively use a recovery/trend cluster (from_52w_high_pct, from_200d_ma_pct), a momentum cluster (return_3m_pct, return_6m_pct, momentum_12_1_pct, return_12m_pct), a volatility check (realized_vol_3m), a liquidity cluster (avg_daily_dollar_volume_3m, avg_daily_volume_3m, trading_days_3m), an income cluster (dividend_yield_ttm_pct, dividend_ttm), a valuation cluster (peg, forward_pe), a growth cluster (revenue_growth_pct, eps_growth_pct, forward_eps), a quality cluster (free_cash_flow_ttm, operating_income_ttm), and a size tilt (market_cap). Deliberately weight return_1m_pct, pe, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, and revenue_ttm at zero this run so the backtest can test a different orthogonal mix instead of collapsing into the recent parents. Sparse fundamentals are normalized by present weight before the final arbitration."""

def _get(obj, key, default=None):
    if isinstance(obj, dict):
        return obj.get(key, default)
    return getattr(obj, key, default)


def _to_num(value):
    if value is None:
        return None
    if isinstance(value, bool):
        return 1.0 if value else 0.0
    try:
        x = float(value)
    except Exception:
        return None
    if x != x:
        return None
    return x


def _clamp(x, lo, hi):
    if x < lo:
        return lo
    if x > hi:
        return hi
    return x


def _percentile_maps(rows, metrics):
    maps = {}
    for metric in metrics:
        vals = []
        for row in rows:
            v = _to_num(_get(row, metric))
            if v is not None:
                vals.append(v)
        if not vals:
            maps[metric] = None
            continue
        vals.sort()
        n = len(vals)
        denom = n - 1 if n > 1 else 1
        metric_map = {}
        for i, v in enumerate(vals):
            metric_map[v] = i / denom
        maps[metric] = metric_map
    return maps


def _rank(row, metric, maps, invert=False):
    metric_map = maps.get(metric)
    if not metric_map:
        return None
    v = _to_num(_get(row, metric))
    if v is None:
        return None
    r = metric_map.get(v)
    if r is None:
        return None
    return 1.0 - r if invert else r


def _blend(parts):
    total_w = 0.0
    total = 0.0
    for value, weight in parts:
        if value is None or weight <= 0:
            continue
        total += value * weight
        total_w += weight
    if total_w <= 0:
        return None
    return total / total_w


def _mul_gate(a, b):
    if a is None or b is None:
        return None
    return (a * b) ** 0.5


def _regime_branch(regime):
    name = str(
        _get(regime, "name",
        _get(regime, "regime",
        _get(regime, "state",
        _get(regime, "label", regime))))
    ).lower()

    trend_6m = _to_num(_get(regime, "market_return_6m_pct"))
    trend_3m = _to_num(_get(regime, "market_return_3m_pct"))
    vol = _to_num(_get(regime, "market_realized_vol_3m"))
    drawdown = _to_num(_get(regime, "market_from_52w_high_pct"))

    bullish = False
    stressed = False

    if "bull" in name or "risk_on" in name or "uptrend" in name:
        bullish = True
    if "bear" in name or "stress" in name or "volatile" in name or "correction" in name:
        stressed = True

    if trend_6m is not None and trend_6m > 6:
        bullish = True
    if trend_3m is not None and trend_3m > 3:
        bullish = True
    if vol is not None and vol > 38:
        stressed = True
    if drawdown is not None and drawdown < -12:
        stressed = True

    if bullish and stressed:
        return "stressed_bull"
    if bullish:
        return "calm_bull"
    if stressed:
        return "defensive"
    return "transition"


def score_universe(stocks, regime, ctx):
    rows = []
    if isinstance(stocks, dict):
        for symbol, stock in stocks.items():
            if isinstance(stock, dict):
                row = dict(stock)
                row.setdefault("symbol", symbol)
            else:
                row = stock
            rows.append(row)
    else:
        for stock in stocks:
            rows.append(stock)

    metrics = [
        "from_52w_high_pct",
        "from_200d_ma_pct",
        "return_3m_pct",
        "return_6m_pct",
        "return_12m_pct",
        "momentum_12_1_pct",
        "realized_vol_3m",
        "avg_daily_dollar_volume_3m",
        "avg_daily_volume_3m",
        "trading_days_3m",
        "dividend_yield_ttm_pct",
        "dividend_ttm",
        "peg",
        "forward_pe",
        "revenue_growth_pct",
        "eps_growth_pct",
        "forward_eps",
        "free_cash_flow_ttm",
        "operating_income_ttm",
        "market_cap",
    ]
    ranks = _percentile_maps(rows, metrics)
    branch = _regime_branch(regime)
    scores = {}

    for row in rows:
        symbol = _get(row, "symbol")
        if symbol is None:
            continue

        deep_discount = _rank(row, "from_52w_high_pct", ranks, invert=True)
        repaired_trend = _rank(row, "from_200d_ma_pct", ranks)
        mom_3m = _rank(row, "return_3m_pct", ranks)
        mom_6m = _rank(row, "return_6m_pct", ranks)
        mom_12_1 = _rank(row, "momentum_12_1_pct", ranks)
        ret_12m = _rank(row, "return_12m_pct", ranks)

        low_vol = _rank(row, "realized_vol_3m", ranks, invert=True)
        liq_dollar = _rank(row, "avg_daily_dollar_volume_3m", ranks)
        liq_share = _rank(row, "avg_daily_volume_3m", ranks)
        liq_days = _rank(row, "trading_days_3m", ranks)

        inc_yield = _rank(row, "dividend_yield_ttm_pct", ranks)
        inc_cash = _rank(row, "dividend_ttm", ranks)

        cheap_peg = _rank(row, "peg", ranks, invert=True)
        cheap_fpe = _rank(row, "forward_pe", ranks, invert=True)

        grow_rev = _rank(row, "revenue_growth_pct", ranks)
        grow_eps = _rank(row, "eps_growth_pct", ranks)
        grow_fwd = _rank(row, "forward_eps", ranks)

        qual_fcf = _rank(row, "free_cash_flow_ttm", ranks)
        qual_oi = _rank(row, "operating_income_ttm", ranks)

        small_cap = _rank(row, "market_cap", ranks, invert=True)
        large_cap = _rank(row, "market_cap", ranks)

        repair_sleeve = _blend([
            (deep_discount, 0.30),
            (repaired_trend, 0.26),
            (mom_3m, 0.14),
            (mom_6m, 0.10),
            (mom_12_1, 0.12),
            (ret_12m, 0.08),
        ])

        durability_sleeve = _blend([
            (qual_fcf, 0.24),
            (qual_oi, 0.22),
            (grow_rev, 0.12),
            (grow_eps, 0.10),
            (grow_fwd, 0.08),
            (cheap_peg, 0.10),
            (cheap_fpe, 0.06),
            (inc_yield, 0.04),
            (inc_cash, 0.04),
        ])

        tradability_sleeve = _blend([
            (liq_dollar, 0.45),
            (liq_share, 0.25),
            (liq_days, 0.15),
            (low_vol, 0.15),
        ])

        balanced_risk = _blend([
            (low_vol, 0.40),
            (liq_dollar, 0.30),
            (liq_days, 0.10),
            (large_cap, 0.10),
            (inc_yield, 0.10),
        ])

        score = 0.0

        if branch == "calm_bull":
            core = _blend([
                (repair_sleeve, 0.58),
                (durability_sleeve, 0.24),
                (tradability_sleeve, 0.10),
                (small_cap, 0.08),
            ])
            gate = _mul_gate(repaired_trend, tradability_sleeve)
            if core is None:
                core = 0.0
            if gate is not None:
                core = 0.85 * core + 0.15 * gate
            if repair_sleeve is not None and durability_sleeve is not None:
                if repair_sleeve > 0.72 and durability_sleeve < 0.34:
                    core *= 0.78
                elif durability_sleeve > 0.72 and repair_sleeve < 0.44:
                    core *= 0.92
            score = core

        elif branch == "stressed_bull":
            core = _blend([
                (repair_sleeve, 0.40),
                (durability_sleeve, 0.34),
                (tradability_sleeve, 0.18),
                (balanced_risk, 0.08),
            ])
            gate = _mul_gate(durability_sleeve, tradability_sleeve)
            if core is None:
                core = 0.0
            if gate is not None:
                core = 0.78 * core + 0.22 * gate
            if repair_sleeve is not None and durability_sleeve is not None:
                if repair_sleeve > 0.72 and durability_sleeve < 0.42:
                    core *= 0.68
                elif durability_sleeve > 0.70 and repair_sleeve < 0.36:
                    core *= 1.06
            score = core

        elif branch == "defensive":
            controlled_repair = _blend([
                (repaired_trend, 0.42),
                (mom_3m, 0.18),
                (mom_6m, 0.12),
                (deep_discount, 0.10),
                (ret_12m, 0.18),
            ])
            core = _blend([
                (durability_sleeve, 0.40),
                (balanced_risk, 0.28),
                (tradability_sleeve, 0.18),
                (controlled_repair, 0.14),
            ])
            gate = _mul_gate(durability_sleeve, low_vol)
            if core is None:
                core = 0.0
            if gate is not None:
                core = 0.82 * core + 0.18 * gate
            if repair_sleeve is not None and durability_sleeve is not None:
                if repair_sleeve > 0.78 and durability_sleeve < 0.46:
                    core *= 0.62
                elif durability_sleeve > 0.76 and repaired_trend is not None and repaired_trend > 0.45:
                    core *= 1.05
            score = core

        else:  # transition
            early_repair = _blend([
                (deep_discount, 0.24),
                (repaired_trend, 0.24),
                (mom_3m, 0.18),
                (mom_12_1, 0.12),
                (cheap_peg, 0.10),
                (grow_rev, 0.12),
            ])
            core = _blend([
                (early_repair, 0.42),
                (durability_sleeve, 0.28),
                (tradability_sleeve, 0.14),
                (low_vol, 0.08),
                (small_cap, 0.08),
            ])
            gate = _mul_gate(repaired_trend, durability_sleeve)
            if core is None:
                core = 0.0
            if gate is not None:
                core = 0.80 * core + 0.20 * gate
            if early_repair is not None and durability_sleeve is not None:
                if early_repair > 0.68 and durability_sleeve < 0.32:
                    core *= 0.74
                elif durability_sleeve > 0.72 and early_repair < 0.38:
                    core *= 0.97
            score = core

        scores[symbol] = _clamp(score if score is not None else 0.0, 0.0, 1.0)

    return scores