exp_1196

FORMULA_NAME = "Contrarian 52-Week Hybrid (Repair Relay with Scarcity-Value Arbitration, v1196)"
LOGIC_VARIANT_COUNT = 5
NOTES = """mode=explore; family=contrarian-52w-hybrid
New hybrid family that combines deep 52-week contrarian repair, regime-aware momentum leadership, and quality/value durability, but resolves conflicts with an explicit relay instead of a static blend. The arbitration is deliberate: panic tapes require repair evidence before honoring drawdowns, clean bull tapes let trend win only when extension is controlled, euphoric tapes tax crowded leaders and rotate toward fresher repair or durable value, transitional tapes compare repair and momentum directly, and narrow/defensive tapes route toward compounders unless a rebound case is overwhelming.
Deliberate metric coverage this run: active momentum uses return_1m_pct, return_3m_pct, return_6m_pct, return_12m_pct, and momentum_12_1_pct; trend/recovery uses both from_200d_ma_pct and from_52w_high_pct; volatility uses realized_vol_3m; liquidity uses avg_daily_volume_3m, avg_daily_dollar_volume_3m, and trading_days_3m; income uses dividend_yield_ttm_pct and dividend_ttm; valuation uses pe, forward_pe, and peg; growth uses eps_growth_pct, operating_income_growth_pct, free_cash_flow_growth_pct, and forward_eps; quality uses operating_margin_pct and free_cash_flow_margin_pct; size uses market_cap only as a raw tilt/gate rather than a z-score rank. Deliberate weight-0 metrics this run: revenue_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, and free_cash_flow_ttm. Sparse fundamentals are normalized by present weight inside each sleeve so missing fields do not mechanically dominate selection."""

ACTIVE_METRICS = (
    "return_1m_pct",
    "return_3m_pct",
    "return_6m_pct",
    "return_12m_pct",
    "momentum_12_1_pct",
    "from_200d_ma_pct",
    "from_52w_high_pct",
    "realized_vol_3m",
    "avg_daily_volume_3m",
    "avg_daily_dollar_volume_3m",
    "trading_days_3m",
    "dividend_yield_ttm_pct",
    "dividend_ttm",
    "pe",
    "forward_pe",
    "peg",
    "eps_growth_pct",
    "operating_income_growth_pct",
    "free_cash_flow_growth_pct",
    "forward_eps",
    "operating_margin_pct",
    "free_cash_flow_margin_pct",
)

def score_universe(stocks, regime, ctx):
    z_cache = {}
    for metric in ACTIVE_METRICS:
        try:
            z_cache[metric] = ctx.z(metric)
        except Exception:
            z_cache[metric] = {}

    def z(metric, symbol):
        bucket = z_cache.get(metric) or {}
        value = bucket.get(symbol)
        if value is None:
            return None
        return value

    def blend(parts):
        total = 0.0
        weight_sum = 0.0
        for weight, value in parts:
            if value is None:
                continue
            total += weight * value
            weight_sum += abs(weight)
        if weight_sum == 0.0:
            return 0.0
        return total / weight_sum

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

    bull = 1.0 if regime.get("bull") else 0.0
    breadth = regime.get("breadth")
    if breadth is None:
        breadth = 0.5
    avg_vol = regime.get("avg_realized_vol_3m")
    if avg_vol is None:
        avg_vol = 28.0
    med_mom = regime.get("median_momentum_12_1_pct")
    if med_mom is None:
        med_mom = 0.0
    med_dist = regime.get("median_from_200d_ma_pct")
    if med_dist is None:
        med_dist = 0.0

    if breadth < 0.46 or avg_vol > 34.0 or med_dist < -7.0:
        regime_branch = 0  # stress / washout
    elif bull and breadth > 0.70 and med_mom > 14.0 and med_dist > 10.0 and avg_vol < 22.0:
        regime_branch = 1  # euphoric / crowded
    elif bull and breadth > 0.58 and med_mom > 5.0 and med_dist > 2.0 and avg_vol < 28.0:
        regime_branch = 2  # clean bull
    elif med_mom > -2.0 or med_dist > -2.0:
        regime_branch = 3  # transition / rebound
    else:
        regime_branch = 4  # narrow / defensive

    scores = {}

    for stock in stocks:
        symbol = stock["symbol"]

        r1 = z("return_1m_pct", symbol)
        r3 = z("return_3m_pct", symbol)
        r6 = z("return_6m_pct", symbol)
        r12 = z("return_12m_pct", symbol)
        m121 = z("momentum_12_1_pct", symbol)
        d200 = z("from_200d_ma_pct", symbol)
        d52 = z("from_52w_high_pct", symbol)
        vol = z("realized_vol_3m", symbol)
        adv = z("avg_daily_volume_3m", symbol)
        addv = z("avg_daily_dollar_volume_3m", symbol)
        tdays = z("trading_days_3m", symbol)
        divy = z("dividend_yield_ttm_pct", symbol)
        divlvl = z("dividend_ttm", symbol)
        pe = z("pe", symbol)
        fpe = z("forward_pe", symbol)
        peg = z("peg", symbol)
        epsg = z("eps_growth_pct", symbol)
        opg = z("operating_income_growth_pct", symbol)
        fcfg = z("free_cash_flow_growth_pct", symbol)
        feps = z("forward_eps", symbol)
        opm = z("operating_margin_pct", symbol)
        fcfm = z("free_cash_flow_margin_pct", symbol)

        liquidity = blend(((0.25, adv), (0.45, addv), (0.30, tdays)))
        quality = blend(((0.55, opm), (0.45, fcfm)))
        value = blend(((0.35, -pe if pe is not None else None),
                       (0.40, -fpe if fpe is not None else None),
                       (0.25, -peg if peg is not None else None)))
        growth = blend(((0.30, epsg), (0.25, opg), (0.25, fcfg), (0.20, feps)))
        income = blend(((0.70, divy), (0.30, divlvl)))
        low_vol = -vol if vol is not None else 0.0

        drawdown_depth = blend(((0.60, -d52 if d52 is not None else None),
                                (0.40, -d200 if d200 is not None else None)))
        repair_evidence = blend(((0.45, r1), (0.35, r3), (0.20, d200)))
        repair = blend(((0.38, drawdown_depth),
                        (0.28, repair_evidence),
                        (0.14, value),
                        (0.10, quality),
                        (0.10, liquidity)))

        trend = blend(((0.22, r3),
                       (0.24, r6),
                       (0.18, r12),
                       (0.26, m121),
                       (0.10, d200)))

        durable = blend(((0.26, quality),
                         (0.20, value),
                         (0.16, growth),
                         (0.16, low_vol),
                         (0.12, income),
                         (0.10, liquidity)))

        extension = blend(((0.45, r1), (0.25, r3), (0.30, d52)))
        fragility = blend(((0.55, vol), (0.45, -liquidity)))

        market_cap = stock.get("market_cap")
        size_tilt = 0.0
        if market_cap is not None:
            if 1500000000 <= market_cap <= 40000000000:
                size_tilt = 0.18
            elif market_cap < 400000000:
                size_tilt = -0.18
            elif market_cap > 250000000000:
                size_tilt = -0.05

        trading_days = stock.get("trading_days_3m")
        if trading_days is not None:
            if trading_days < 56:
                size_tilt -= 0.10
            elif trading_days >= 62:
                size_tilt += 0.04

        no_repair_penalty = 0.0
        if drawdown_depth > 0.6 and repair_evidence < -0.1:
            no_repair_penalty = 0.45
        broken_quality_penalty = 0.0
        if quality < -0.55 and growth < -0.35:
            broken_quality_penalty = 0.30
        crowded_penalty = 0.0
        if extension > 0.95:
            crowded_penalty = 0.30
        if extension > 1.35:
            crowded_penalty += 0.25

        if regime_branch == 0:
            repair_gate = 0.0
            if repair_evidence > -0.05:
                repair_gate = 0.35
            score = (
                1.10 * repair
                + 0.30 * durable
                + 0.10 * low_vol
                + repair_gate
                + size_tilt
                - 0.90 * no_repair_penalty
                - 0.55 * broken_quality_penalty
                - 0.25 * fragility
            )
        elif regime_branch == 1:
            crowd_tax = 0.75 * crowded_penalty
            if repair > trend + 0.20:
                relay_bonus = 0.22
                score = (
                    0.95 * repair
                    + 0.45 * durable
                    + 0.10 * trend
                    + relay_bonus
                    + size_tilt
                    - 0.40 * broken_quality_penalty
                    - 0.20 * fragility
                )
            else:
                score = (
                    0.72 * trend
                    + 0.45 * durable
                    + 0.18 * value
                    + size_tilt
                    - crowd_tax
                    - 0.30 * broken_quality_penalty
                    - 0.15 * fragility
                )
        elif regime_branch == 2:
            trend_bonus = 0.0
            if trend > repair + 0.12 and extension < 1.10:
                trend_bonus = 0.24
            score = (
                0.92 * trend
                + 0.34 * durable
                + 0.22 * repair
                + trend_bonus
                + 0.5 * size_tilt
                - 0.45 * crowded_penalty
                - 0.18 * broken_quality_penalty
            )
        elif regime_branch == 3:
            if repair > trend + 0.15:
                arbitration = 0.18
                score = (
                    0.86 * repair
                    + 0.48 * durable
                    + 0.18 * trend
                    + arbitration
                    + size_tilt
                    - 0.40 * no_repair_penalty
                    - 0.20 * broken_quality_penalty
                )
            elif trend > repair + 0.20:
                arbitration = 0.14
                score = (
                    0.78 * trend
                    + 0.42 * repair
                    + 0.28 * durable
                    + arbitration
                    + 0.5 * size_tilt
                    - 0.25 * crowded_penalty
                    - 0.15 * broken_quality_penalty
                )
            else:
                score = (
                    0.58 * repair
                    + 0.52 * trend
                    + 0.32 * durable
                    + 0.5 * size_tilt
                    - 0.20 * crowded_penalty
                    - 0.15 * no_repair_penalty
                )
        else:
            defensive_bonus = 0.0
            if durable > 0.30:
                defensive_bonus = 0.18
            rebound_override = 0.0
            if repair > durable + 0.45 and repair_evidence > 0.0:
                rebound_override = 0.16
            score = (
                0.84 * durable
                + 0.30 * repair
                + 0.12 * income
                + defensive_bonus
                + rebound_override
                + 0.25 * size_tilt
                - 0.18 * crowded_penalty
                - 0.22 * broken_quality_penalty
                - 0.08 * fragility
            )

        if liquidity < -1.25:
            score -= 0.35
        if quality > 0.90 and growth > 0.40 and crowded_penalty == 0.0:
            score += 0.12
        if repair_evidence > 0.55 and drawdown_depth > 0.55 and value > 0.10:
            score += 0.10

        scores[symbol] = clamp(score, -6.0, 6.0)

    return scores