exp_1130

FORMULA_NAME = "Recovery Quality Contrarian 52-Week Hybrid (Relay Arbitration, v1130)"
LOGIC_VARIANT_COUNT = 3
NOTES = """mode=explore; family=recovery-quality-contrarian-52w-hybrid
This hybrid is a stock-level relay between three sleeves rather than a flat blend: leadership repair, off-high rebound, and defensive shelter. The regime picks the default sleeve, but each stock can be promoted or demoted when discount, repair, durability, and crowding conflict. In strong tapes, repaired laggards can graduate into leaders only after trend repair and quality confirmation; in mixed tapes, deep-off-high names must prove both business durability and tradability before the contrarian sleeve takes over; in stressed tapes, the model defaults to shelter but still admits selective fallen-angel recoveries when stability and quality are unusually strong.
Deliberate metric coverage: momentum active via 3m, 6m, 12m, and 12_1 metrics; trend/recovery active via both 200d and 52w-high distance with opposite signs by sleeve; volatility active via realized 3m vol; liquidity active via share volume, dollar volume, and trading-days continuity; income active via dividend yield and dividend_ttm in the shelter sleeve; valuation active via PE and PEG; growth active via forward EPS plus operating-income and free-cash-flow growth; quality active via operating and free-cash-flow margins; size active via market_cap as a stability tilt in defense and a modest contrarian tilt in rebound.
Deliberate weight-0 metrics this run: return_1m_pct, forward_pe, revenue_growth_pct, eps_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm."""

LEADER_SLEEVE = {
    "momentum_12_1_pct": (0.20, +1),
    "return_6m_pct": (0.14, +1),
    "from_200d_ma_pct": (0.14, +1),
    "from_52w_high_pct": (0.10, +1),
    "forward_eps": (0.12, +1),
    "operating_margin_pct": (0.12, +1),
    "avg_daily_dollar_volume_3m": (0.10, +1),
    "realized_vol_3m": (0.08, -1),
}

REBOUND_SLEEVE = {
    "from_52w_high_pct": (0.22, -1),
    "from_200d_ma_pct": (0.14, +1),
    "return_3m_pct": (0.12, +1),
    "return_12m_pct": (0.08, +1),
    "free_cash_flow_growth_pct": (0.12, +1),
    "free_cash_flow_margin_pct": (0.10, +1),
    "peg": (0.10, -1),
    "avg_daily_volume_3m": (0.08, +1),
    "market_cap": (0.04, -1),
}

SHELTER_SLEEVE = {
    "realized_vol_3m": (0.18, -1),
    "trading_days_3m": (0.14, +1),
    "dividend_yield_ttm_pct": (0.10, +1),
    "dividend_ttm": (0.10, +1),
    "pe": (0.10, -1),
    "operating_income_growth_pct": (0.12, +1),
    "operating_margin_pct": (0.10, +1),
    "market_cap": (0.10, +1),
    "avg_daily_dollar_volume_3m": (0.06, +1),
}


def score_universe(stocks, regime, ctx):
    def _num(v):
        return isinstance(v, (int, float)) and v == v

    def _rank_map(metric, direction):
        pairs = []
        for stock in stocks:
            value = stock.get(metric)
            if _num(value):
                pairs.append((stock.get("symbol"), value))
        n = len(pairs)
        if n == 0:
            return {}
        pairs.sort(key=lambda item: item[1], reverse=(direction > 0))
        if n == 1:
            return {pairs[0][0]: 1.0}
        out = {}
        denom = float(n - 1)
        i = 0
        while i < n:
            out[pairs[i][0]] = 1.0 - (i / denom)
            i += 1
        return out

    def _blend(spec, rank_cache):
        scores = {}
        for stock in stocks:
            symbol = stock.get("symbol")
            total = 0.0
            used = 0.0
            for metric, cfg in spec.items():
                weight = cfg[0]
                rank = rank_cache[metric][cfg[1]].get(symbol)
                if rank is not None:
                    total += weight * rank
                    used += weight
            if used > 0.0:
                scores[symbol] = total / used
            else:
                scores[symbol] = 0.0
        return scores

    def _avg_symbol(symbol, maps):
        total = 0.0
        count = 0
        for mapping in maps:
            value = mapping.get(symbol)
            if value is not None:
                total += value
                count += 1
        if count == 0:
            return 0.5
        return total / count

    def _branch_name(regime_info):
        breadth = regime_info.get("breadth", 0)
        avg_vol = regime_info.get("avg_realized_vol_3m", 0)
        median_momo = regime_info.get("median_momentum_12_1_pct", 0)
        median_trend = regime_info.get("median_from_200d_ma_pct", 0)
        if regime_info.get("bull") and breadth >= 62 and avg_vol <= 29 and median_momo >= 4 and median_trend >= 2:
            return "leadership"
        if breadth <= 45 or avg_vol >= 38 or median_trend < -1:
            return "defense"
        return "rebuild"

    metrics = {
        "momentum_12_1_pct",
        "return_3m_pct",
        "return_6m_pct",
        "return_12m_pct",
        "from_200d_ma_pct",
        "from_52w_high_pct",
        "forward_eps",
        "operating_margin_pct",
        "avg_daily_dollar_volume_3m",
        "realized_vol_3m",
        "free_cash_flow_growth_pct",
        "free_cash_flow_margin_pct",
        "peg",
        "avg_daily_volume_3m",
        "market_cap",
        "trading_days_3m",
        "dividend_yield_ttm_pct",
        "dividend_ttm",
        "pe",
        "operating_income_growth_pct",
    }

    rank_cache = {}
    for metric in metrics:
        rank_cache[metric] = {
            +1: _rank_map(metric, +1),
            -1: _rank_map(metric, -1),
        }

    leader_scores = _blend(LEADER_SLEEVE, rank_cache)
    rebound_scores = _blend(REBOUND_SLEEVE, rank_cache)
    shelter_scores = _blend(SHELTER_SLEEVE, rank_cache)

    branch = _branch_name(regime)
    scores = {}

    for stock in stocks:
        symbol = stock.get("symbol")

        repair_signal = _avg_symbol(
            symbol,
            [
                rank_cache["from_200d_ma_pct"][+1],
                rank_cache["return_3m_pct"][+1],
                rank_cache["return_6m_pct"][+1],
            ],
        )
        discount_signal = rank_cache["from_52w_high_pct"][-1].get(symbol, 0.5)
        durability_signal = _avg_symbol(
            symbol,
            [
                rank_cache["operating_margin_pct"][+1],
                rank_cache["free_cash_flow_margin_pct"][+1],
                rank_cache["forward_eps"][+1],
                rank_cache["operating_income_growth_pct"][+1],
                rank_cache["free_cash_flow_growth_pct"][+1],
            ],
        )
        liquidity_signal = _avg_symbol(
            symbol,
            [
                rank_cache["avg_daily_volume_3m"][+1],
                rank_cache["avg_daily_dollar_volume_3m"][+1],
                rank_cache["trading_days_3m"][+1],
            ],
        )
        momentum_signal = _avg_symbol(
            symbol,
            [
                rank_cache["momentum_12_1_pct"][+1],
                rank_cache["return_6m_pct"][+1],
                rank_cache["return_12m_pct"][+1],
            ],
        )
        value_signal = _avg_symbol(
            symbol,
            [
                rank_cache["pe"][-1],
                rank_cache["peg"][-1],
            ],
        )
        income_signal = _avg_symbol(
            symbol,
            [
                rank_cache["dividend_yield_ttm_pct"][+1],
                rank_cache["dividend_ttm"][+1],
            ],
        )
        stability_signal = _avg_symbol(
            symbol,
            [
                rank_cache["realized_vol_3m"][-1],
                rank_cache["market_cap"][+1],
            ],
        )
        crowding_signal = _avg_symbol(
            symbol,
            [
                rank_cache["momentum_12_1_pct"][+1],
                rank_cache["return_12m_pct"][+1],
                rank_cache["from_52w_high_pct"][+1],
            ],
        )

        leader = leader_scores.get(symbol, 0.0)
        rebound = rebound_scores.get(symbol, 0.0)
        shelter = shelter_scores.get(symbol, 0.0)

        if branch == "leadership":
            score = leader + 0.08 * durability_signal + 0.05 * liquidity_signal + 0.05 * repair_signal

            if discount_signal > 0.62 and repair_signal > 0.56 and durability_signal > 0.52:
                score = 0.72 * rebound + 0.28 * leader + 0.10 * durability_signal
            elif crowding_signal > 0.74 and value_signal < 0.34 and durability_signal < 0.48:
                score -= 0.18
            elif discount_signal > 0.76 and repair_signal < 0.44:
                score -= 0.12

            if stability_signal < 0.34:
                score -= 0.06

        elif branch == "rebuild":
            score = rebound + 0.09 * durability_signal + 0.07 * value_signal + 0.05 * liquidity_signal

            if discount_signal > 0.60 and repair_signal > 0.58 and durability_signal > 0.50 and liquidity_signal > 0.45:
                score += 0.18 + 0.08 * momentum_signal
            elif discount_signal > 0.70 and durability_signal < 0.42:
                score = 0.65 * shelter + 0.35 * rebound - 0.14
            elif leader > rebound and momentum_signal > 0.66 and discount_signal < 0.45:
                score = 0.55 * leader + 0.45 * rebound + 0.08 * durability_signal

            if momentum_signal < 0.35:
                score -= 0.08

        else:
            score = shelter + 0.10 * durability_signal + 0.08 * income_signal + 0.06 * value_signal + 0.05 * stability_signal

            if discount_signal > 0.68 and durability_signal > 0.58 and stability_signal > 0.52 and liquidity_signal > 0.46:
                score = 0.58 * shelter + 0.42 * rebound + 0.12 * income_signal
            elif durability_signal < 0.38 or liquidity_signal < 0.35:
                score -= 0.18
            elif discount_signal > 0.78 and repair_signal < 0.42:
                score -= 0.10

            if crowding_signal > 0.70 and value_signal < 0.30:
                score -= 0.08

        scores[symbol] = score

    return scores