exp_1180

FORMULA_NAME = "Contrarian 52-Week Hybrid with Repair-Leadership Arbitration (v1180)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=contrarian-52w-hybrid
New hybrid family that combines the strongest orthogonal elements of the winning parent families without mechanically averaging them: deep 52-week contrarian repair, quality-filtered recovery durability, and regime-aware momentum leadership. The arbitration is explicit. In damaged tapes, washed-out names only qualify when recovery evidence, balance-sheet durability proxies, and tradability confirm the repair. In strong tapes, momentum leaders can dominate, but only when they are not excessively extended, too volatile, or obviously low-quality. In mixed tapes, the strategy prefers names where short-horizon repair and medium-horizon leadership are converging rather than fighting each other.
Deliberate metric coverage this run: actively use momentum (return_1m_pct, return_3m_pct, return_6m_pct, return_12m_pct, momentum_12_1_pct), trend/recovery (from_200d_ma_pct, from_52w_high_pct), volatility (realized_vol_3m), liquidity (avg_daily_volume_3m, avg_daily_dollar_volume_3m, trading_days_3m), income (dividend_yield_ttm_pct), valuation (pe, forward_pe, peg), growth (eps_growth_pct, operating_income_growth_pct, free_cash_flow_growth_pct, forward_eps), quality (operating_margin_pct, free_cash_flow_margin_pct), and size (market_cap). Deliberately weight dividend_ttm, revenue_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, and free_cash_flow_ttm at zero this run to avoid correlated price-level duplication and to keep the family structurally distinct from prior hybrids. Sparse fundamentals are normalized within each sleeve so missing fields do not automatically dominate or disqualify a stock.
Regime branches: panic-repair, transition, clean-trend, and defensive-carry. The branch count is exactly four."""

ACTIVE_METRICS = (
    "return_1m_pct",
    "return_3m_pct",
    "return_6m_pct",
    "return_12m_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",
    "pe",
    "forward_pe",
    "peg",
    "eps_growth_pct",
    "operating_income_growth_pct",
    "free_cash_flow_growth_pct",
    "forward_eps",
    "operating_margin_pct",
    "free_cash_flow_margin_pct",
    "market_cap",
)

ZERO_WEIGHT_METRICS = (
    "dividend_ttm",
    "revenue_growth_pct",
    "shares_outstanding",
    "close",
    "adj_close",
    "high_52w",
    "ma_200d",
    "eps_ttm",
    "revenue_ttm",
    "operating_income_ttm",
    "free_cash_flow_ttm",
)


def score_universe(stocks, regime, ctx):
    def get_field(obj, key, default=None):
        if isinstance(obj, dict):
            return obj.get(key, default)
        return getattr(obj, key, default)

    def as_number(value):
        if value is None or value == "":
            return None
        if isinstance(value, bool):
            return 1.0 if value else 0.0
        try:
            number = float(value)
        except Exception:
            return None
        if number != number:
            return None
        if number == float("inf") or number == float("-inf"):
            return None
        return number

    def symbol_of(stock, idx):
        sym = get_field(stock, "symbol")
        if sym is None:
            sym = get_field(stock, "ticker")
        if sym is None:
            sym = get_field(stock, "name")
        if sym is None:
            sym = "stock_%s" % idx
        return str(sym)

    universe = list(stocks or [])
    if not universe:
        return {}

    symbols = [symbol_of(stock, i) for i, stock in enumerate(universe)]

    def rank_map(metric, high_is_good=True):
        values = []
        for i, stock in enumerate(universe):
            val = as_number(get_field(stock, metric))
            if val is not None:
                values.append((i, val))
        result = {}
        if not values:
            return result
        values.sort(key=lambda item: item[1], reverse=high_is_good)
        n = len(values)
        if n == 1:
            result[values[0][0]] = 1.0
            return result
        for rank, (idx, _) in enumerate(values):
            result[idx] = 1.0 - (rank / float(n - 1))
        return result

    ranks = {
        "return_1m_pct": rank_map("return_1m_pct", True),
        "return_3m_pct": rank_map("return_3m_pct", True),
        "return_6m_pct": rank_map("return_6m_pct", True),
        "return_12m_pct": rank_map("return_12m_pct", True),
        "momentum_12_1_pct": rank_map("momentum_12_1_pct", True),
        "from_200d_ma_pct": rank_map("from_200d_ma_pct", True),
        "from_52w_high_pct": rank_map("from_52w_high_pct", True),
        "deep_drawdown": rank_map("from_52w_high_pct", False),
        "realized_vol_3m_low": rank_map("realized_vol_3m", False),
        "avg_daily_volume_3m": rank_map("avg_daily_volume_3m", True),
        "avg_daily_dollar_volume_3m": rank_map("avg_daily_dollar_volume_3m", True),
        "trading_days_3m": rank_map("trading_days_3m", True),
        "dividend_yield_ttm_pct": rank_map("dividend_yield_ttm_pct", True),
        "pe_low": rank_map("pe", False),
        "forward_pe_low": rank_map("forward_pe", False),
        "peg_low": rank_map("peg", False),
        "eps_growth_pct": rank_map("eps_growth_pct", True),
        "operating_income_growth_pct": rank_map("operating_income_growth_pct", True),
        "free_cash_flow_growth_pct": rank_map("free_cash_flow_growth_pct", True),
        "forward_eps": rank_map("forward_eps", True),
        "operating_margin_pct": rank_map("operating_margin_pct", True),
        "free_cash_flow_margin_pct": rank_map("free_cash_flow_margin_pct", True),
        "market_cap": rank_map("market_cap", True),
        "smaller_cap": rank_map("market_cap", False),
    }

    def present(idx, key):
        return 1.0 if idx in ranks[key] else 0.0

    def mix(idx, weighted_keys):
        total = 0.0
        weight = 0.0
        for key, w in weighted_keys:
            if idx in ranks[key]:
                total += ranks[key][idx] * w
                weight += w
        if weight <= 0.0:
            return 0.5
        return total / weight

    avg_6m = 0.0
    avg_200d = 0.0
    avg_vol = 0.0
    n_6m = 0
    n_200d = 0
    n_vol = 0
    for stock in universe:
        v = as_number(get_field(stock, "return_6m_pct"))
        if v is not None:
            avg_6m += v
            n_6m += 1
        v = as_number(get_field(stock, "from_200d_ma_pct"))
        if v is not None:
            avg_200d += v
            n_200d += 1
        v = as_number(get_field(stock, "realized_vol_3m"))
        if v is not None:
            avg_vol += v
            n_vol += 1
    avg_6m = avg_6m / n_6m if n_6m else 0.0
    avg_200d = avg_200d / n_200d if n_200d else 0.0
    avg_vol = avg_vol / n_vol if n_vol else 0.0

    def pull_regime_number(source, keys):
        for key in keys:
            val = None
            if isinstance(source, dict):
                val = source.get(key)
            else:
                val = getattr(source, key, None)
            num = as_number(val)
            if num is not None:
                return num
        return None

    regime_risk_on = pull_regime_number(regime, ("risk_on", "risk_on_score", "bull", "bullish"))
    regime_trend = pull_regime_number(regime, ("trend", "trend_score", "market_trend"))
    regime_breadth = pull_regime_number(regime, ("breadth", "breadth_score"))
    regime_vol = pull_regime_number(regime, ("volatility", "vol", "vol_score", "stress"))
    regime_drawdown = pull_regime_number(regime, ("drawdown", "damage", "damage_score"))

    if regime_risk_on is None:
        regime_risk_on = 1.0 if avg_6m > 8.0 else (0.0 if avg_6m < -4.0 else 0.5)
    if regime_trend is None:
        regime_trend = 1.0 if avg_200d > 5.0 else (0.0 if avg_200d < -3.0 else 0.5)
    if regime_breadth is None:
        regime_breadth = 1.0 if avg_6m > 4.0 and avg_200d > 0.0 else (0.0 if avg_6m < 0.0 and avg_200d < 0.0 else 0.5)
    if regime_vol is None:
        regime_vol = 1.0 if avg_vol > 45.0 else (0.0 if avg_vol < 25.0 else 0.5)
    if regime_drawdown is None:
        regime_drawdown = 1.0 if avg_200d < -5.0 else (0.0 if avg_200d > 3.0 else 0.5)

    regime_strength = (regime_risk_on + regime_trend + regime_breadth) / 3.0
    regime_stress = (regime_vol + regime_drawdown) / 2.0

    if regime_strength < 0.38 and regime_stress > 0.58:
        branch = 0  # panic-repair
    elif regime_strength > 0.68 and regime_stress < 0.48:
        branch = 2  # clean-trend
    elif regime_stress > 0.62:
        branch = 3  # defensive-carry
    else:
        branch = 1  # transition

    scores = {}
    for idx, stock in enumerate(universe):
        liquidity = mix(
            idx,
            (
                ("avg_daily_volume_3m", 0.25),
                ("avg_daily_dollar_volume_3m", 0.50),
                ("trading_days_3m", 0.25),
            ),
        )

        value = mix(
            idx,
            (
                ("pe_low", 0.30),
                ("forward_pe_low", 0.35),
                ("peg_low", 0.35),
            ),
        )

        quality = mix(
            idx,
            (
                ("operating_margin_pct", 0.55),
                ("free_cash_flow_margin_pct", 0.45),
            ),
        )

        growth = mix(
            idx,
            (
                ("eps_growth_pct", 0.30),
                ("operating_income_growth_pct", 0.25),
                ("free_cash_flow_growth_pct", 0.25),
                ("forward_eps", 0.20),
            ),
        )

        momentum = mix(
            idx,
            (
                ("return_1m_pct", 0.18),
                ("return_3m_pct", 0.24),
                ("return_6m_pct", 0.22),
                ("return_12m_pct", 0.10),
                ("momentum_12_1_pct", 0.26),
            ),
        )

        trend = mix(
            idx,
            (
                ("from_200d_ma_pct", 0.60),
                ("from_52w_high_pct", 0.40),
            ),
        )

        drawdown = mix(idx, (("deep_drawdown", 1.0),))
        low_vol = mix(idx, (("realized_vol_3m_low", 1.0),))
        income = mix(idx, (("dividend_yield_ttm_pct", 1.0),))
        size = mix(idx, (("market_cap", 1.0),))
        smaller = mix(idx, (("smaller_cap", 1.0),))

        repair_evidence = mix(
            idx,
            (
                ("return_1m_pct", 0.25),
                ("return_3m_pct", 0.30),
                ("from_200d_ma_pct", 0.25),
                ("realized_vol_3m_low", 0.20),
            ),
        )

        repair_score = (
            0.30 * drawdown
            + 0.26 * repair_evidence
            + 0.16 * quality
            + 0.12 * value
            + 0.08 * growth
            + 0.08 * liquidity
        )

        leadership_score = (
            0.33 * momentum
            + 0.24 * trend
            + 0.14 * quality
            + 0.11 * growth
            + 0.10 * liquidity
            + 0.08 * low_vol
        )

        defensive_score = (
            0.24 * quality
            + 0.20 * low_vol
            + 0.16 * value
            + 0.15 * income
            + 0.15 * liquidity
            + 0.10 * size
        )

        bridge_score = (
            0.28 * repair_evidence
            + 0.20 * momentum
            + 0.16 * quality
            + 0.12 * growth
            + 0.12 * value
            + 0.12 * drawdown
        )

        repair_gap = repair_score - leadership_score
        convergence = 1.0 - repair_gap if repair_gap >= 0.0 else 1.0 + repair_gap
        if convergence < 0.0:
            convergence = 0.0

        extension_penalty = 0.0
        broken_penalty = 0.0
        junk_penalty = 0.0

        raw_from_high = as_number(get_field(stock, "from_52w_high_pct"))
        raw_from_200d = as_number(get_field(stock, "from_200d_ma_pct"))
        raw_vol = as_number(get_field(stock, "realized_vol_3m"))
        raw_pe = as_number(get_field(stock, "pe"))
        raw_fpe = as_number(get_field(stock, "forward_pe"))
        raw_mom_1m = as_number(get_field(stock, "return_1m_pct"))
        raw_mom_3m = as_number(get_field(stock, "return_3m_pct"))

        if raw_from_high is not None and raw_from_high > -5.0 and raw_mom_1m is not None and raw_mom_1m > 18.0:
            extension_penalty += 0.08
        if raw_from_200d is not None and raw_from_200d < -12.0 and raw_mom_3m is not None and raw_mom_3m < 0.0:
            broken_penalty += 0.12
        if raw_vol is not None and raw_vol > 70.0:
            junk_penalty += 0.08
        if raw_pe is not None and raw_pe < 0.0:
            junk_penalty += 0.06
        if raw_fpe is not None and raw_fpe > 60.0:
            extension_penalty += 0.04
        if quality < 0.30 and growth < 0.30:
            junk_penalty += 0.07
        if liquidity < 0.22:
            junk_penalty += 0.08

        if branch == 0:
            score = (
                1.18 * repair_score
                + 0.32 * defensive_score
                + 0.18 * bridge_score
                + 0.10 * smaller
                - 0.85 * broken_penalty
                - 0.65 * junk_penalty
                - 0.35 * extension_penalty
            )
            if repair_evidence < 0.42:
                score -= 0.10
            if drawdown < 0.45:
                score -= 0.04
        elif branch == 1:
            score = (
                0.72 * (repair_score if repair_score > leadership_score else leadership_score)
                + 0.44 * (repair_score if repair_score < leadership_score else leadership_score)
                + 0.30 * bridge_score
                + 0.16 * defensive_score
                + 0.06 * value
                - 0.35 * junk_penalty
                - 0.18 * extension_penalty
                - 0.18 * broken_penalty
            )
            score += 0.10 * convergence
            if momentum < 0.35 and repair_evidence < 0.40:
                score -= 0.08
        elif branch == 2:
            score = (
                1.14 * leadership_score
                + 0.22 * defensive_score
                + 0.16 * bridge_score
                + 0.08 * quality
                - 0.70 * extension_penalty
                - 0.25 * junk_penalty
                - 0.40 * broken_penalty
            )
            if trend < 0.40:
                score -= 0.10
            if drawdown > 0.80 and repair_evidence < 0.50:
                score -= 0.06
        else:
            score = (
                1.10 * defensive_score
                + 0.34 * repair_score
                + 0.12 * leadership_score
                + 0.10 * income
                + 0.06 * value
                - 0.45 * junk_penalty
                - 0.20 * extension_penalty
                - 0.24 * broken_penalty
            )
            if low_vol < 0.35:
                score -= 0.08
            if size < 0.20 and liquidity < 0.35:
                score -= 0.05

        score += 0.03 * liquidity
        scores[symbols[idx]] = score

    return scores