exp_1193

FORMULA_NAME = "Regime Momentum Contrarian 52W Recovery Quality Hybrid (Conflict-Arbitrated, v1193)"
LOGIC_VARIANT_COUNT = 3
NOTES = """mode=explore; family=regime-momentum-contrarian-52w-recovery-quality-hybrid
New hybrid family built by combining the shallower 52-week-high recovery sweet spot from the contrarian winner, the regime sleeve discipline of regime-momentum-quality-value, and the stock-level conflict arbitration idea from recovery-quality-regime-momentum-hybrid. The structure is intentionally not a mechanical average: strong tapes reward repaired leaders only when momentum confirms, mixed tapes buy recoveries only when quality and trading continuity de-risk the bounce, and risk-off rotates toward durable low-vol franchises with valuation and income support while explicitly penalizing unresolved momentum/recovery conflict.
Deliberate metric coverage this run: momentum uses 12_1 plus 6m and 3m; trend/recovery uses both 200d distance and 52-week-high distance; volatility is active in all branches; liquidity uses trading_days and avg_daily_dollar_volume only; income uses dividend_yield only in defensive branches; valuation uses forward_pe and peg but leaves pe at zero deliberately; growth uses eps_growth and revenue_growth selectively while operating-income/free-cash-flow growth and forward_eps are zeroed; quality uses free_cash_flow_margin and operating_margin; size uses market_cap only in bull as a modest small-cap tilt. Deliberate weight-0 metrics this run: return_1m_pct, return_12m_pct, avg_daily_volume_3m, dividend_ttm, pe, operating_income_growth_pct, free_cash_flow_growth_pct, forward_eps, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm."""

BULL = {
    "momentum_12_1_pct": (0.19, +1),
    "return_6m_pct": (0.16, +1),
    "return_3m_pct": (0.08, +1),
    "from_200d_ma_pct": (0.14, +1),
    "from_52w_high_pct": (0.15, -1),
    "eps_growth_pct": (0.08, +1),
    "free_cash_flow_margin_pct": (0.08, +1),
    "realized_vol_3m": (0.05, -1),
    "market_cap": (0.04, -1),
    "avg_daily_dollar_volume_3m": (0.03, +1),
}

MIXED = {
    "from_52w_high_pct": (0.19, -1),
    "from_200d_ma_pct": (0.15, +1),
    "return_6m_pct": (0.10, +1),
    "momentum_12_1_pct": (0.07, +1),
    "free_cash_flow_margin_pct": (0.11, +1),
    "operating_margin_pct": (0.10, +1),
    "revenue_growth_pct": (0.08, +1),
    "trading_days_3m": (0.07, +1),
    "avg_daily_dollar_volume_3m": (0.04, +1),
    "realized_vol_3m": (0.05, -1),
    "peg": (0.04, -1),
}

RISK_OFF = {
    "realized_vol_3m": (0.20, -1),
    "from_200d_ma_pct": (0.16, +1),
    "from_52w_high_pct": (0.07, -1),
    "operating_margin_pct": (0.13, +1),
    "free_cash_flow_margin_pct": (0.09, +1),
    "revenue_growth_pct": (0.06, +1),
    "forward_pe": (0.09, -1),
    "peg": (0.07, -1),
    "dividend_yield_ttm_pct": (0.08, +1),
    "trading_days_3m": (0.05, +1),
}


def score_universe(stocks, regime, ctx):
    def _to_float(x):
        if x is None or x == "":
            return None
        try:
            v = float(x)
        except Exception:
            return None
        if v != v:
            return None
        return v

    def _field(stock, name):
        return _to_float(stock.get(name))

    def _rank_map(metric, direction):
        vals = []
        for stock in stocks:
            v = _field(stock, metric)
            if v is not None:
                vals.append((stock.get("symbol"), v))
        if not vals:
            return {}
        vals.sort(key=lambda item: item[1], reverse=(direction > 0))
        n = len(vals)
        if n == 1:
            return {vals[0][0]: 1.0}
        out = {}
        denom = float(n - 1)
        i = 0
        while i < n:
            j = i + 1
            while j < n and vals[j][1] == vals[i][1]:
                j += 1
            rank = 1.0 - ((i + j - 1) * 0.5) / denom
            k = i
            while k < j:
                out[vals[k][0]] = rank
                k += 1
            i = j
        return out

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

    def _clip(x):
        if x < 0.0:
            return 0.0
        if x > 1.0:
            return 1.0
        return x

    def _regime_name(value):
        text = ""
        if value is not None:
            text = str(value).lower()
        if "bull" in text or "risk_on" in text or "risk-on" in text:
            return "bull"
        if "bear" in text or "risk_off" in text or "risk-off" in text or "defens" in text:
            return "risk_off"
        return "mixed"

    branch = _regime_name(regime)

    bull_base = _weighted_score(BULL)
    mixed_base = _weighted_score(MIXED)
    risk_base = _weighted_score(RISK_OFF)

    momentum_core = _weighted_score({
        "momentum_12_1_pct": (0.46, +1),
        "return_6m_pct": (0.34, +1),
        "return_3m_pct": (0.20, +1),
    })
    recovery_core = _weighted_score({
        "from_52w_high_pct": (0.58, -1),
        "from_200d_ma_pct": (0.42, +1),
    })
    quality_core = _weighted_score({
        "free_cash_flow_margin_pct": (0.36, +1),
        "operating_margin_pct": (0.28, +1),
        "eps_growth_pct": (0.18, +1),
        "revenue_growth_pct": (0.18, +1),
    })
    defense_core = _weighted_score({
        "realized_vol_3m": (0.34, -1),
        "forward_pe": (0.20, -1),
        "peg": (0.14, -1),
        "dividend_yield_ttm_pct": (0.16, +1),
        "trading_days_3m": (0.16, +1),
    })
    liquidity_core = _weighted_score({
        "trading_days_3m": (0.65, +1),
        "avg_daily_dollar_volume_3m": (0.35, +1),
    })

    scores = {}
    for stock in stocks:
        symbol = stock.get("symbol")
        m = momentum_core.get(symbol, 0.0)
        r = recovery_core.get(symbol, 0.0)
        q = quality_core.get(symbol, 0.0)
        d = defense_core.get(symbol, 0.0)
        l = liquidity_core.get(symbol, 0.0)

        conflict = abs(m - r)
        synergy = 1.0 - conflict

        v52 = _field(stock, "from_52w_high_pct")
        v200 = _field(stock, "from_200d_ma_pct")

        shallow_recovery_bonus = 0.0
        if v52 is not None:
            if -24.0 <= v52 <= -8.0:
                shallow_recovery_bonus += 0.045
            elif -35.0 <= v52 < -24.0:
                shallow_recovery_bonus += 0.020
            elif v52 < -45.0:
                shallow_recovery_bonus -= 0.035

        trend_confirm = 0.0
        if v200 is not None:
            if v200 > 0.0:
                trend_confirm = 0.035
            elif v200 < -6.0:
                trend_confirm = -0.040

        if branch == "bull":
            base = bull_base.get(symbol, 0.0)
            repaired_leader = 0.55 * r + 0.45 * m
            arbitration = 0.0
            if m >= 0.62 and r >= 0.55:
                arbitration += 0.070 + 0.040 * synergy
            elif m >= 0.66 and r < 0.40:
                arbitration -= 0.045 + 0.020 * conflict
            elif r >= 0.68 and m < 0.42:
                arbitration -= 0.060 + 0.020 * conflict
            else:
                arbitration += 0.018 * synergy
            score = (
                0.58 * base
                + 0.20 * repaired_leader
                + 0.12 * q
                + 0.05 * l
                + shallow_recovery_bonus
                + trend_confirm
                + arbitration
            )
        elif branch == "risk_off":
            base = risk_base.get(symbol, 0.0)
            defensive_repair = 0.50 * d + 0.25 * q + 0.15 * r + 0.10 * m
            arbitration = 0.0
            if d >= 0.60 and q >= 0.55 and v200 is not None and v200 > -4.0:
                arbitration += 0.060
            if conflict > 0.38:
                arbitration -= 0.060
            elif synergy > 0.78:
                arbitration += 0.018
            score = (
                0.62 * base
                + 0.22 * defensive_repair
                + 0.06 * l
                + shallow_recovery_bonus * 0.35
                + trend_confirm * 0.75
                + arbitration
            )
        else:
            base = mixed_base.get(symbol, 0.0)
            balanced_rebound = 0.40 * r + 0.25 * m + 0.25 * q + 0.10 * l
            arbitration = 0.0
            if r >= 0.62 and q >= 0.58 and l >= 0.48:
                arbitration += 0.055
            if conflict > 0.30:
                arbitration -= 0.050 * conflict
            else:
                arbitration += 0.020 * synergy
            if m < 0.35 and r > 0.70:
                arbitration -= 0.030
            score = (
                0.56 * base
                + 0.24 * balanced_rebound
                + 0.10 * d
                + shallow_recovery_bonus * 0.8
                + trend_confirm
                + arbitration
            )

        scores[symbol] = score

    return scores