exp_1133

FORMULA_NAME = "Regime Momentum Recovery Quality Contrarian 52-Week Hybrid (Arbitrated Relay, v1133)"
LOGIC_VARIANT_COUNT = 3
NOTES = """mode=explore; family=regime-momentum-recovery-quality-contrarian-52w-hybrid
New hybrid family that combines three strong but orthogonal parent ideas with explicit arbitration instead of static averaging: regime-aware momentum leadership from the quality-value branch, repaired-drawdown turnarounds from the recovery-quality relay, and shallower 52-week-high contrarian entries from the winner contrarian family. The structure is intentionally distinct from the earlier degrading regime hybrid: bull regimes let repaired leaders outrank, mixed regimes require quality-backed repair before deep pullbacks can score, and risk-off regimes only admit contrarian rebounds when low-vol durability and trading continuity confirm they are not falling knives. When momentum, contrarian depth, and quality disagree, the branch-specific gates choose which sleeve is allowed to lead.
Deliberate metric coverage this run: momentum/return uses 1m, 3m, 6m, and 12_1 but thins 12m to zero; trend/recovery uses both 200d distance and 52-week-high drawdown in every branch; volatility is active in all branches but strongest in risk-off; liquidity rotates across trading_days, avg_daily_volume, and avg_daily_dollar_volume instead of leaving the category idle; income uses dividend_yield selectively in pullback and risk-off sleeves; valuation uses forward_pe and peg while pe is deliberately zeroed to avoid redundant value exposure; growth rotates across eps, revenue, operating-income, and free-cash-flow growth rather than repeating one sparse signal; quality keeps both operating_margin and free_cash_flow_margin; size uses market_cap and shares_outstanding as selective tie-breakers. Deliberate weight-0 metrics this run: pe, return_12m_pct, forward_eps, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm."""

BULL_LEADER = {
    "momentum_12_1_pct": (0.27, +1),
    "return_6m_pct": (0.18, +1),
    "from_200d_ma_pct": (0.16, +1),
    "return_3m_pct": (0.08, +1),
    "realized_vol_3m": (0.08, -1),
    "eps_growth_pct": (0.09, +1),
    "free_cash_flow_margin_pct": (0.08, +1),
    "forward_pe": (0.06, -1),
}

BULL_PULLBACK = {
    "from_52w_high_pct": (0.26, -1),
    "from_200d_ma_pct": (0.20, +1),
    "momentum_12_1_pct": (0.10, +1),
    "return_1m_pct": (0.09, -1),
    "market_cap": (0.06, -1),
    "dividend_yield_ttm_pct": (0.05, +1),
    "peg": (0.08, -1),
    "operating_income_growth_pct": (0.08, +1),
    "trading_days_3m": (0.08, +1),
}

TRANSITION_REPAIR = {
    "from_52w_high_pct": (0.24, -1),
    "from_200d_ma_pct": (0.22, +1),
    "return_3m_pct": (0.16, +1),
    "return_1m_pct": (0.10, -1),
    "momentum_12_1_pct": (0.08, +1),
    "realized_vol_3m": (0.08, -1),
    "trading_days_3m": (0.12, +1),
}

TRANSITION_QUALITY = {
    "operating_margin_pct": (0.16, +1),
    "free_cash_flow_margin_pct": (0.14, +1),
    "free_cash_flow_growth_pct": (0.10, +1),
    "operating_income_growth_pct": (0.10, +1),
    "avg_daily_dollar_volume_3m": (0.08, +1),
    "forward_pe": (0.06, -1),
    "peg": (0.06, -1),
    "dividend_yield_ttm_pct": (0.04, +1),
    "shares_outstanding": (0.06, -1),
}

RISK_OFF_DEFENSE = {
    "realized_vol_3m": (0.22, -1),
    "from_200d_ma_pct": (0.18, +1),
    "from_52w_high_pct": (0.10, -1),
    "operating_margin_pct": (0.12, +1),
    "dividend_yield_ttm_pct": (0.10, +1),
    "trading_days_3m": (0.10, +1),
    "forward_pe": (0.08, -1),
    "revenue_growth_pct": (0.05, +1),
    "avg_daily_volume_3m": (0.05, +1),
}

RISK_OFF_REBOUND = {
    "from_52w_high_pct": (0.18, -1),
    "from_200d_ma_pct": (0.16, +1),
    "return_1m_pct": (0.06, -1),
    "return_3m_pct": (0.10, +1),
    "momentum_12_1_pct": (0.06, +1),
    "market_cap": (0.05, -1),
    "free_cash_flow_margin_pct": (0.08, +1),
    "peg": (0.07, -1),
    "avg_daily_dollar_volume_3m": (0.08, +1),
    "realized_vol_3m": (0.06, -1),
}


def score_universe(stocks, regime, ctx):
    def metric_value(stock, metric):
        value = stock.get(metric)
        if value is None:
            return None
        if isinstance(value, bool):
            value = 1.0 if value else 0.0
        elif isinstance(value, (int, float)):
            value = float(value)
        else:
            try:
                value = float(value)
            except Exception:
                return None
        if value != value:
            return None
        return value

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

    def mean_present(values, default=0.5):
        total = 0.0
        count = 0
        for value in values:
            if value is not None:
                total += value
                count += 1
        if count == 0:
            return default
        return total / count

    def build_metric_ranks(metric_names):
        ranks = {}
        for metric in metric_names:
            observed = []
            for idx, stock in enumerate(stocks):
                value = metric_value(stock, metric)
                if value is not None:
                    observed.append((value, idx))
            observed.sort(key=lambda item: item[0])
            metric_rank = {}
            n = len(observed)
            if n == 1:
                metric_rank[observed[0][1]] = 0.5
            elif n > 1:
                start = 0
                while start < n:
                    end = start
                    current = observed[start][0]
                    while end + 1 < n and observed[end + 1][0] == current:
                        end += 1
                    pct = (start + end) / (2.0 * (n - 1))
                    j = start
                    while j <= end:
                        metric_rank[observed[j][1]] = pct
                        j += 1
                    start = end + 1
            ranks[metric] = metric_rank
        return ranks

    def signal(idx, metric, direction):
        pct = rank_cache.get(metric, {}).get(idx)
        if pct is None:
            return None
        if direction >= 0:
            return pct
        return 1.0 - pct

    def spec_score(idx, spec):
        total = 0.0
        used = 0.0
        for metric, params in spec.items():
            weight, direction = params
            sig = signal(idx, metric, direction)
            if sig is None:
                continue
            total += weight * sig
            used += weight
        if used == 0.0:
            return 0.5
        return total / used

    def detect_branch(regime_obj, ctx_obj):
        text_parts = []
        if regime_obj is not None:
            text_parts.append(str(regime_obj))
            if isinstance(regime_obj, dict):
                for key in ("label", "name", "regime", "state", "market_regime", "trend"):
                    if key in regime_obj and regime_obj.get(key) is not None:
                        text_parts.append(str(regime_obj.get(key)))
        if isinstance(ctx_obj, dict):
            for key in ("regime", "market_regime", "state", "trend", "mode"):
                if key in ctx_obj and ctx_obj.get(key) is not None:
                    text_parts.append(str(ctx_obj.get(key)))
        text = " ".join(text_parts).lower()

        if (
            "risk_off" in text
            or "risk-off" in text
            or "bear" in text
            or "defensive" in text
            or "crash" in text
            or "panic" in text
            or "drawdown" in text
        ):
            return "risk_off"
        if (
            "bull" in text
            or "risk_on" in text
            or "risk-on" in text
            or "uptrend" in text
            or "expansion" in text
            or "recovery" in text
        ):
            return "bull"
        return "transition"

    all_metrics = {}
    for spec in (
        BULL_LEADER,
        BULL_PULLBACK,
        TRANSITION_REPAIR,
        TRANSITION_QUALITY,
        RISK_OFF_DEFENSE,
        RISK_OFF_REBOUND,
    ):
        for metric in spec:
            all_metrics[metric] = True

    rank_cache = build_metric_ranks(all_metrics)
    branch = detect_branch(regime, ctx)
    scores = {}

    for idx, stock in enumerate(stocks):
        leader = spec_score(idx, BULL_LEADER)
        bull_pullback = spec_score(idx, BULL_PULLBACK)
        repair = spec_score(idx, TRANSITION_REPAIR)
        quality = spec_score(idx, TRANSITION_QUALITY)
        defense = spec_score(idx, RISK_OFF_DEFENSE)
        rebound = spec_score(idx, RISK_OFF_REBOUND)

        deep_pullback = signal(idx, "from_52w_high_pct", -1)
        repair_gate = mean_present(
            [
                signal(idx, "from_200d_ma_pct", +1),
                signal(idx, "return_3m_pct", +1),
                signal(idx, "return_1m_pct", -1),
            ]
        )
        quality_gate = mean_present(
            [
                signal(idx, "operating_margin_pct", +1),
                signal(idx, "free_cash_flow_margin_pct", +1),
                signal(idx, "operating_income_growth_pct", +1),
                signal(idx, "free_cash_flow_growth_pct", +1),
            ]
        )
        liquidity_gate = mean_present(
            [
                signal(idx, "trading_days_3m", +1),
                signal(idx, "avg_daily_dollar_volume_3m", +1),
                signal(idx, "avg_daily_volume_3m", +1),
            ]
        )
        value_gate = mean_present(
            [
                signal(idx, "forward_pe", -1),
                signal(idx, "peg", -1),
            ]
        )
        low_vol_gate = signal(idx, "realized_vol_3m", -1)
        if low_vol_gate is None:
            low_vol_gate = 0.5

        if branch == "bull":
            if leader >= 0.58 and repair_gate >= 0.52:
                score = 0.56 * leader + 0.22 * quality + 0.22 * bull_pullback
            elif deep_pullback is not None and deep_pullback >= 0.62 and repair_gate >= 0.48 and quality_gate >= 0.50:
                score = 0.42 * bull_pullback + 0.33 * leader + 0.25 * quality
            else:
                score = 0.42 * leader + 0.38 * quality + 0.20 * bull_pullback
            score += 0.03 * value_gate
            if deep_pullback is not None and deep_pullback >= 0.75 and repair_gate < 0.40:
                score -= 0.06

        elif branch == "risk_off":
            if defense >= 0.58 and liquidity_gate >= 0.52:
                score = 0.56 * defense + 0.24 * quality + 0.20 * rebound
            elif deep_pullback is not None and deep_pullback >= 0.60 and repair_gate >= 0.50 and defense >= 0.48:
                score = 0.42 * rebound + 0.38 * defense + 0.20 * quality
            else:
                score = 0.50 * defense + 0.30 * quality + 0.20 * repair
            score += 0.04 * value_gate
            if low_vol_gate < 0.35:
                score -= 0.08
            if liquidity_gate < 0.35:
                score -= 0.05

        else:
            if deep_pullback is not None and deep_pullback >= 0.60 and repair_gate >= 0.50 and quality_gate >= 0.52:
                score = 0.44 * repair + 0.36 * quality + 0.20 * bull_pullback
            elif leader >= 0.60 and quality_gate >= 0.48:
                score = 0.44 * leader + 0.31 * repair + 0.25 * quality
            else:
                score = 0.40 * repair + 0.40 * quality + 0.20 * bull_pullback
            score += 0.04 * value_gate
            if deep_pullback is not None and deep_pullback >= 0.72 and repair_gate < 0.42 and quality_gate < 0.46:
                score -= 0.08
            if liquidity_gate < 0.30:
                score -= 0.04

        symbol = stock.get("symbol", stock.get("ticker"))
        if symbol is not None:
            scores[symbol] = clamp01(score)

    return scores