exp_1165

FORMULA_NAME = "Contrarian 52W Regime Momentum Recovery Quality Hybrid (State-Arbitrated Relay, v1165)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=contrarian-52w-regime-momentum-recovery-quality-hybrid
New hybrid family built as a state-arbitrated relay instead of a static blend. It preserves the strong parent edge in recovery leaders off 52-week highs, but only pays for deeper drawdowns when repair, liquidity continuity, and operating durability confirm them. In healthy tapes, repaired leaders outrank deeper contrarian names; in choppier tapes, controlled pullbacks with improving trend get priority; in transitions, quality-backed turnarounds can beat pure momentum; in risk-off, the model triages for durable, liquid, lower-vol franchises that are merely bruised rather than broken.
Explicit arbitration rule: when momentum leadership and contrarian depth conflict, stock-state gates decide the sleeve. Deep drawdown names must pass a repair-and-durability gate to avoid falling knives; shallow drawdown leaders need trend persistence to outrank cheaper-looking laggards; transition tapes favor improving quality recoveries over both raw momentum and raw depth.
Deliberate metric coverage this run: active momentum uses 3m, 6m, and 12_1; trend/recovery uses both 200d distance and 52-week-high distance; volatility is active through realized vol; liquidity uses volume, dollar-volume, and trading-days continuity; income uses dividend yield in defensive branches only; valuation rotates to forward_pe and peg in transition/risk-off while pe is deliberately zeroed; growth uses forward_eps plus operating-income and free-cash-flow growth; quality uses operating and free-cash-flow margins; size uses market_cap only as a small negative tilt in strong tapes. Deliberate weight-0 metrics: return_1m_pct, return_12m_pct, dividend_ttm, pe, eps_growth_pct, revenue_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm.
"""

# Deliberate weight-0 metrics this run:
# - Momentum/return: return_1m_pct, return_12m_pct
# - Income: dividend_ttm
# - Valuation: pe
# - Growth: eps_growth_pct, revenue_growth_pct
# - Size/raw levels: shares_outstanding, close, adj_close, high_52w, ma_200d,
#   eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm

STRONG_BULL = {
    "momentum_12_1_pct": (0.23, +1),
    "return_6m_pct": (0.19, +1),
    "return_3m_pct": (0.08, +1),
    "from_200d_ma_pct": (0.13, +1),
    "from_52w_high_pct": (0.17, -1),
    "realized_vol_3m": (0.06, -1),
    "avg_daily_dollar_volume_3m": (0.04, +1),
    "trading_days_3m": (0.03, +1),
    "forward_eps": (0.03, +1),
    "free_cash_flow_margin_pct": (0.02, +1),
    "market_cap": (0.02, -1),
}

SOFT_BULL = {
    "from_52w_high_pct": (0.21, -1),
    "from_200d_ma_pct": (0.18, +1),
    "return_6m_pct": (0.12, +1),
    "momentum_12_1_pct": (0.09, +1),
    "return_3m_pct": (0.07, +1),
    "realized_vol_3m": (0.08, -1),
    "avg_daily_volume_3m": (0.05, +1),
    "avg_daily_dollar_volume_3m": (0.04, +1),
    "operating_income_growth_pct": (0.07, +1),
    "free_cash_flow_growth_pct": (0.05, +1),
    "operating_margin_pct": (0.04, +1),
}

TRANSITION = {
    "from_200d_ma_pct": (0.16, +1),
    "from_52w_high_pct": (0.14, -1),
    "momentum_12_1_pct": (0.08, +1),
    "return_3m_pct": (0.08, +1),
    "realized_vol_3m": (0.07, -1),
    "avg_daily_dollar_volume_3m": (0.05, +1),
    "trading_days_3m": (0.04, +1),
    "forward_pe": (0.08, -1),
    "peg": (0.05, -1),
    "forward_eps": (0.08, +1),
    "operating_income_growth_pct": (0.07, +1),
    "free_cash_flow_growth_pct": (0.06, +1),
    "operating_margin_pct": (0.02, +1),
    "free_cash_flow_margin_pct": (0.02, +1),
}

RISK_OFF = {
    "from_52w_high_pct": (0.09, -1),
    "from_200d_ma_pct": (0.13, +1),
    "realized_vol_3m": (0.13, -1),
    "avg_daily_dollar_volume_3m": (0.07, +1),
    "trading_days_3m": (0.05, +1),
    "dividend_yield_ttm_pct": (0.08, +1),
    "forward_pe": (0.08, -1),
    "peg": (0.05, -1),
    "forward_eps": (0.07, +1),
    "operating_margin_pct": (0.10, +1),
    "free_cash_flow_margin_pct": (0.10, +1),
    "free_cash_flow_growth_pct": (0.05, +1),
}

def score_universe(stocks, regime, ctx):
    def safe_float(v):
        if v is None:
            return None
        if isinstance(v, bool):
            return 1.0 if v else 0.0
        try:
            x = float(v)
        except Exception:
            return None
        if x != x:
            return None
        return x

    def get_metric(stock, key):
        return safe_float(stock.get(key))

    def get_symbol(stock):
        sym = stock.get("symbol")
        if sym is None:
            return None
        try:
            return str(sym)
        except Exception:
            return None

    def rank_map(metric, direction):
        values = []
        for idx, stock in enumerate(stocks):
            v = get_metric(stock, metric)
            if v is not None:
                values.append((idx, v))
        ranked = {}
        n = len(values)
        if n == 0:
            return ranked
        values.sort(key=lambda x: x[1], reverse=(direction > 0))
        if n == 1:
            ranked[values[0][0]] = 1.0
            return ranked
        i = 0
        while i < n:
            j = i + 1
            while j < n and values[j][1] == values[i][1]:
                j += 1
            avg_rank = (i + j - 1) * 0.5
            score = 1.0 - (avg_rank / (n - 1))
            k = i
            while k < j:
                ranked[values[k][0]] = score
                k += 1
            i = j
        return ranked

    def weighted_base(branch):
        total = [0.0] * len(stocks)
        coverage = [0.0] * len(stocks)
        for metric, spec in branch.items():
            weight, direction = spec
            ranks = rank_map(metric, direction)
            for idx, val in ranks.items():
                total[idx] += weight * val
                coverage[idx] += weight
        out = [0.0] * len(stocks)
        for idx in range(len(stocks)):
            if coverage[idx] > 0.0:
                out[idx] = total[idx] / coverage[idx]
        return out

    def regime_token():
        parts = []
        if isinstance(regime, str):
            parts.append(regime.lower())
        elif isinstance(regime, dict):
            for key in (
                "label",
                "name",
                "regime",
                "state",
                "market_regime",
                "primary_regime",
                "trend",
                "description",
            ):
                v = regime.get(key)
                if v is not None:
                    try:
                        parts.append(str(v).lower())
                    except Exception:
                        pass
        if ctx and isinstance(ctx, dict):
            for key in ("regime", "market_regime", "regime_label", "market_state"):
                v = ctx.get(key)
                if v is not None:
                    try:
                        parts.append(str(v).lower())
                    except Exception:
                        pass
        text = " ".join(parts)
        if "risk" in text or "bear" in text or "defensive" in text or "crash" in text:
            return "risk_off"
        if "transition" in text or "mixed" in text or "neutral" in text or "sideways" in text:
            return "transition"
        if "soft" in text or "weak bull" in text or "fragile" in text or "repair" in text:
            return "soft_bull"
        if "bull" in text or "up" in text or "strong" in text or "momentum" in text:
            return "strong_bull"
        return "transition"

    branch_name = regime_token()
    if branch_name == "strong_bull":
        branch = STRONG_BULL
    elif branch_name == "soft_bull":
        branch = SOFT_BULL
    elif branch_name == "risk_off":
        branch = RISK_OFF
    else:
        branch = TRANSITION

    base_scores = weighted_base(branch)
    result = {}

    for idx, stock in enumerate(stocks):
        symbol = get_symbol(stock)
        if not symbol:
            continue

        m12 = get_metric(stock, "momentum_12_1_pct")
        r6 = get_metric(stock, "return_6m_pct")
        r3 = get_metric(stock, "return_3m_pct")
        d52 = get_metric(stock, "from_52w_high_pct")
        d200 = get_metric(stock, "from_200d_ma_pct")
        vol = get_metric(stock, "realized_vol_3m")
        adv = get_metric(stock, "avg_daily_volume_3m")
        addv = get_metric(stock, "avg_daily_dollar_volume_3m")
        tdays = get_metric(stock, "trading_days_3m")
        fpe = get_metric(stock, "forward_pe")
        peg = get_metric(stock, "peg")
        feps = get_metric(stock, "forward_eps")
        oig = get_metric(stock, "operating_income_growth_pct")
        fcfg = get_metric(stock, "free_cash_flow_growth_pct")
        om = get_metric(stock, "operating_margin_pct")
        fcfm = get_metric(stock, "free_cash_flow_margin_pct")
        dy = get_metric(stock, "dividend_yield_ttm_pct")

        score = base_scores[idx]
        bonus = 0.0

        momentum_ok = (
            (m12 is not None and m12 > 0.0) or
            (r6 is not None and r6 > 0.0) or
            (r3 is not None and r3 > -2.0)
        )
        strong_momentum = (
            (m12 is not None and m12 > 8.0) and
            (r6 is not None and r6 > 10.0)
        )
        repaired_trend = (
            (d200 is not None and d200 > 0.0) and
            (r3 is not None and r3 > -5.0)
        )
        deep_drawdown = d52 is not None and d52 >= 0.22
        shallow_pullback = d52 is not None and 0.07 <= d52 <= 0.22
        controlled_vol = vol is None or vol < 42.0
        liquid_ok = (
            (tdays is None or tdays >= 45.0) and
            ((addv is not None and addv > 0.0) or (adv is not None and adv > 0.0))
        )
        durability_ok = (
            ((om is not None and om > 0.0) or (fcfm is not None and fcfm > 0.0)) and
            ((fcfg is None or fcfg > -10.0) and (oig is None or oig > -10.0))
        )
        growth_ok = (
            (feps is None or feps > 0.0) and
            ((oig is not None and oig > 0.0) or (fcfg is not None and fcfg > 0.0))
        )
        value_ok = (
            (fpe is None or (fpe > 0.0 and fpe < 28.0)) and
            (peg is None or (peg > 0.0 and peg < 2.2))
        )

        if branch_name == "strong_bull":
            if strong_momentum and repaired_trend and shallow_pullback:
                bonus += 0.18
            elif deep_drawdown and repaired_trend and durability_ok and liquid_ok:
                bonus += 0.08
            elif deep_drawdown and not repaired_trend:
                bonus -= 0.18
            elif not momentum_ok:
                bonus -= 0.08

            if controlled_vol:
                bonus += 0.03
            else:
                bonus -= 0.04

        elif branch_name == "soft_bull":
            if deep_drawdown and repaired_trend and durability_ok and controlled_vol:
                bonus += 0.16
            elif shallow_pullback and strong_momentum and controlled_vol:
                bonus += 0.07
            elif deep_drawdown and not durability_ok:
                bonus -= 0.16
            elif not liquid_ok:
                bonus -= 0.05

            if growth_ok:
                bonus += 0.04

        elif branch_name == "transition":
            turnaround_ok = repaired_trend and durability_ok and growth_ok and value_ok
            if turnaround_ok and deep_drawdown:
                bonus += 0.18
            elif turnaround_ok and shallow_pullback:
                bonus += 0.10
            elif strong_momentum and not value_ok:
                bonus -= 0.07
            elif deep_drawdown and (not repaired_trend or not durability_ok):
                bonus -= 0.18

            if liquid_ok:
                bonus += 0.03

        else:
            defensive_ok = durability_ok and value_ok and controlled_vol and liquid_ok
            if defensive_ok and shallow_pullback:
                bonus += 0.15
            elif defensive_ok and deep_drawdown and repaired_trend:
                bonus += 0.08
            elif deep_drawdown and not defensive_ok:
                bonus -= 0.20
            elif strong_momentum and vol is not None and vol > 45.0:
                bonus -= 0.06

            if dy is not None and dy > 0.0:
                bonus += 0.03
            if d200 is not None and d200 < -8.0:
                bonus -= 0.05

        coverage_penalty = 0.0
        missing_core = 0
        for v in (d52, d200, vol):
            if v is None:
                missing_core += 1
        if missing_core >= 2:
            coverage_penalty -= 0.06
        if not liquid_ok:
            coverage_penalty -= 0.03

        result[symbol] = score + bonus + coverage_penalty

    return result