exp_1195

FORMULA_NAME = "Recovery Quality Contrarian 52-Week Hybrid (Evidence-Relay Arbitration, v1195)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=recovery-quality-contrarian-52w-hybrid
New hybrid family built as an evidence-relay rather than a static blend: every stock is first classified into a repair, leadership, durability, or skeptical state, then each regime branch decides which state is allowed to dominate and how hard conflicting signals are taxed. The design preserves what deep-52w contrarian repair does well, keeps recovery-quality discipline so damaged junk does not float to the top, and still lets genuine leaders win in cleaner tapes only after extension, volatility, and valuation sanity checks clear.
Deliberate metric coverage this run: active momentum uses return_3m_pct, return_6m_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; valuation uses forward_pe and peg; growth uses 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 as a stability tilt. Deliberate weight-0 metrics this run: 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, and free_cash_flow_ttm. Sparse fundamentals are normalized by present weight inside each case so missing fields do not mechanically dominate selection."""

ACTIVE_METRICS = (
    "return_3m_pct",
    "return_6m_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",
    "forward_pe",
    "peg",
    "operating_income_growth_pct",
    "free_cash_flow_growth_pct",
    "forward_eps",
    "operating_margin_pct",
    "free_cash_flow_margin_pct",
    "market_cap",
)

REPAIR_WEIGHTS = {
    "from_52w_high_pct": (0.24, -1),
    "from_200d_ma_pct": (0.18, +1),
    "return_3m_pct": (0.16, +1),
    "return_6m_pct": (0.10, +1),
    "operating_margin_pct": (0.08, +1),
    "free_cash_flow_margin_pct": (0.08, +1),
    "operating_income_growth_pct": (0.06, +1),
    "free_cash_flow_growth_pct": (0.05, +1),
    "forward_pe": (0.03, -1),
    "peg": (0.02, -1),
}

LEADERSHIP_WEIGHTS = {
    "momentum_12_1_pct": (0.22, +1),
    "return_6m_pct": (0.18, +1),
    "return_3m_pct": (0.10, +1),
    "from_200d_ma_pct": (0.10, +1),
    "operating_margin_pct": (0.09, +1),
    "free_cash_flow_margin_pct": (0.08, +1),
    "operating_income_growth_pct": (0.07, +1),
    "free_cash_flow_growth_pct": (0.06, +1),
    "forward_eps": (0.05, +1),
    "realized_vol_3m": (0.03, -1),
    "forward_pe": (0.02, -1),
}

DURABILITY_WEIGHTS = {
    "realized_vol_3m": (0.20, -1),
    "operating_margin_pct": (0.16, +1),
    "free_cash_flow_margin_pct": (0.14, +1),
    "dividend_yield_ttm_pct": (0.12, +1),
    "market_cap": (0.10, +1),
    "forward_pe": (0.08, -1),
    "peg": (0.06, -1),
    "from_200d_ma_pct": (0.05, +1),
    "trading_days_3m": (0.05, +1),
    "avg_daily_dollar_volume_3m": (0.04, +1),
}

LIQUIDITY_WEIGHTS = {
    "avg_daily_volume_3m": (0.34, +1),
    "avg_daily_dollar_volume_3m": (0.46, +1),
    "trading_days_3m": (0.20, +1),
}


def _safe_float(value):
    try:
        if value is None:
            return None
        value = float(value)
        if value != value:
            return None
        return value
    except Exception:
        return None


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


def _metric_value(stock, name):
    if isinstance(stock, dict):
        return _safe_float(stock.get(name))
    return None


def _symbol_of(stock, idx):
    if isinstance(stock, dict):
        symbol = stock.get("symbol")
        if symbol is not None:
            return symbol
    return "stock_%s" % idx


def _build_rank_maps(stocks):
    rank_maps = {}
    for metric in ACTIVE_METRICS:
        pairs = []
        i = 0
        while i < len(stocks):
            v = _metric_value(stocks[i], metric)
            if v is not None:
                pairs.append((v, i))
            i += 1
        pairs.sort(key=lambda x: x[0])
        metric_ranks = {}
        n = len(pairs)
        if n == 1:
            metric_ranks[pairs[0][1]] = 0.5
        elif n > 1:
            j = 0
            while j < n:
                metric_ranks[pairs[j][1]] = float(j) / float(n - 1)
                j += 1
        rank_maps[metric] = metric_ranks
    return rank_maps


def _weighted_score(rank_maps, idx, weights):
    total = 0.0
    present = 0.0
    for metric, cfg in weights.items():
        metric_ranks = rank_maps.get(metric, {})
        if idx in metric_ranks:
            w, direction = cfg
            r = metric_ranks[idx]
            if direction < 0:
                r = 1.0 - r
            total += w * r
            present += w
    if present <= 0.0:
        return 0.0
    return total / present


def _regime_branch(regime):
    label = ""
    if isinstance(regime, str):
        label = regime.lower()
    elif isinstance(regime, dict):
        raw = regime.get("label")
        if raw is None:
            raw = regime.get("name")
        if raw is not None:
            label = str(raw).lower()

    if "panic" in label or "crash" in label or "bear" in label or "risk_off" in label or "risk-off" in label:
        return "washout"
    if "bull" in label or "trend" in label or "risk_on" in label or "risk-on" in label:
        return "trend"
    if "defen" in label or "late" in label or "slow" in label:
        return "defensive"
    if "trans" in label or "mixed" in label or "chop" in label:
        return "transition"

    trend = 0.0
    risk = 0.0
    breadth = 0.0
    if isinstance(regime, dict):
        for key in ("trend", "market_trend", "risk_on", "uptrend", "momentum"):
            v = _safe_float(regime.get(key))
            if v is not None:
                trend = v
                break
        for key in ("risk_off", "stress", "volatility", "drawdown_risk", "turbulence"):
            v = _safe_float(regime.get(key))
            if v is not None:
                risk = v
                break
        for key in ("breadth", "participation", "internals"):
            v = _safe_float(regime.get(key))
            if v is not None:
                breadth = v
                break

    if risk >= 0.65 or trend <= -0.35:
        return "washout"
    if trend >= 0.55 and breadth >= 0.45 and risk < 0.50:
        return "trend"
    if risk >= 0.45:
        return "defensive"
    return "transition"


def score_universe(stocks, regime, ctx):
    rank_maps = _build_rank_maps(stocks)
    branch = _regime_branch(regime)
    scores = {}

    i = 0
    while i < len(stocks):
        stock = stocks[i]
        symbol = _symbol_of(stock, i)

        repair = _weighted_score(rank_maps, i, REPAIR_WEIGHTS)
        leadership = _weighted_score(rank_maps, i, LEADERSHIP_WEIGHTS)
        durability = _weighted_score(rank_maps, i, DURABILITY_WEIGHTS)
        liquidity = _weighted_score(rank_maps, i, LIQUIDITY_WEIGHTS)

        drawdown = 1.0 - rank_maps.get("from_52w_high_pct", {}).get(i, 0.5)
        rebound = rank_maps.get("from_200d_ma_pct", {}).get(i, 0.5)
        trend_3m = rank_maps.get("return_3m_pct", {}).get(i, 0.5)
        trend_6m = rank_maps.get("return_6m_pct", {}).get(i, 0.5)
        momo = rank_maps.get("momentum_12_1_pct", {}).get(i, 0.5)
        vol_calm = 1.0 - rank_maps.get("realized_vol_3m", {}).get(i, 0.5)
        valuation = 0.5 * (
            (1.0 - rank_maps.get("forward_pe", {}).get(i, 0.5)) +
            (1.0 - rank_maps.get("peg", {}).get(i, 0.5))
        )
        quality = 0.5 * (
            rank_maps.get("operating_margin_pct", {}).get(i, 0.5) +
            rank_maps.get("free_cash_flow_margin_pct", {}).get(i, 0.5)
        )
        growth = (
            rank_maps.get("operating_income_growth_pct", {}).get(i, 0.5) * 0.45 +
            rank_maps.get("free_cash_flow_growth_pct", {}).get(i, 0.5) * 0.35 +
            rank_maps.get("forward_eps", {}).get(i, 0.5) * 0.20
        )

        repair_ready = _clamp(
            0.45 * drawdown +
            0.30 * rebound +
            0.15 * trend_3m +
            0.10 * quality,
            0.0,
            1.0,
        )
        leader_ready = _clamp(
            0.35 * momo +
            0.25 * trend_6m +
            0.15 * rebound +
            0.15 * quality +
            0.10 * growth,
            0.0,
            1.0,
        )
        durable_ready = _clamp(
            0.35 * durability +
            0.20 * quality +
            0.15 * vol_calm +
            0.10 * valuation +
            0.10 * liquidity +
            0.10 * rebound,
            0.0,
            1.0,
        )

        extension_penalty = _clamp(
            0.55 * (1.0 - drawdown) +
            0.45 * (1.0 - vol_calm),
            0.0,
            1.0,
        )
        broken_penalty = _clamp(
            0.45 * (1.0 - rebound) +
            0.35 * (1.0 - quality) +
            0.20 * (1.0 - liquidity),
            0.0,
            1.0,
        )
        conflict = abs(repair_ready - leader_ready)

        if repair_ready >= 0.62 and drawdown >= 0.58 and trend_3m >= 0.48:
            state = "repair"
        elif leader_ready >= 0.64 and trend_6m >= 0.56 and drawdown <= 0.55:
            state = "leader"
        elif durable_ready >= 0.60 and vol_calm >= 0.55:
            state = "durable"
        else:
            state = "skeptical"

        if branch == "washout":
            if state == "repair":
                score = (
                    0.52 * repair +
                    0.18 * durability +
                    0.12 * valuation +
                    0.10 * liquidity +
                    0.08 * leader_ready
                )
                score -= 0.18 * broken_penalty
            elif state == "durable":
                score = 0.62 * durability + 0.18 * repair + 0.12 * valuation + 0.08 * liquidity
            elif state == "leader":
                score = 0.42 * leadership + 0.24 * durability + 0.16 * repair + 0.18 * liquidity
                score -= 0.22 * extension_penalty
            else:
                score = 0.45 * durability + 0.30 * repair + 0.15 * valuation + 0.10 * liquidity
                score -= 0.16 * broken_penalty

        elif branch == "transition":
            if state == "repair":
                relay_bonus = 0.14 * leader_ready if conflict <= 0.22 else 0.04 * leader_ready
                score = 0.48 * repair + 0.20 * durability + 0.12 * valuation + 0.10 * liquidity + relay_bonus
                score -= 0.10 * broken_penalty
            elif state == "leader":
                relay_bonus = 0.12 * repair_ready if conflict <= 0.22 else 0.04 * repair_ready
                score = 0.42 * leadership + 0.18 * durability + 0.12 * quality + 0.10 * growth + 0.08 * liquidity + relay_bonus
                score -= 0.12 * extension_penalty
            elif state == "durable":
                score = 0.48 * durability + 0.18 * repair + 0.12 * leadership + 0.12 * valuation + 0.10 * liquidity
            else:
                if repair_ready >= leader_ready:
                    score = 0.40 * repair + 0.24 * durability + 0.14 * valuation + 0.12 * liquidity + 0.10 * growth
                    score -= 0.10 * broken_penalty
                else:
                    score = 0.40 * leadership + 0.24 * durability + 0.12 * growth + 0.12 * liquidity + 0.12 * quality
                    score -= 0.10 * extension_penalty

        elif branch == "trend":
            if state == "leader":
                score = (
                    0.50 * leadership +
                    0.16 * durability +
                    0.12 * growth +
                    0.10 * liquidity +
                    0.06 * valuation +
                    0.06 * repair_ready
                )
                score -= 0.14 * extension_penalty
            elif state == "repair":
                score = 0.44 * repair + 0.18 * leadership + 0.16 * durability + 0.10 * growth + 0.12 * liquidity
                score -= 0.12 * broken_penalty
            elif state == "durable":
                score = 0.44 * durability + 0.24 * leadership + 0.12 * growth + 0.10 * liquidity + 0.10 * valuation
            else:
                score = 0.34 * leadership + 0.30 * durability + 0.16 * repair + 0.10 * growth + 0.10 * liquidity
                score -= 0.08 * extension_penalty

        else:  # defensive
            if state == "durable":
                score = 0.56 * durability + 0.14 * valuation + 0.12 * liquidity + 0.10 * repair_ready + 0.08 * leadership
            elif state == "repair":
                score = 0.40 * repair + 0.30 * durability + 0.12 * valuation + 0.10 * liquidity + 0.08 * quality
                score -= 0.12 * broken_penalty
            elif state == "leader":
                score = 0.34 * leadership + 0.34 * durability + 0.10 * valuation + 0.12 * liquidity + 0.10 * quality
                score -= 0.16 * extension_penalty
            else:
                score = 0.50 * durability + 0.18 * valuation + 0.16 * liquidity + 0.08 * repair + 0.08 * quality

        score += 0.04 * liquidity
        score = _clamp(score, 0.0, 1.0)
        scores[symbol] = score
        i += 1

    return scores