exp_1109

FORMULA_NAME = "Acceleration Relay Into 52-Week Repairs (Explore v1109)"
LOGIC_VARIANT_COUNT = 3
NOTES = """mode=explore; family=acceleration-contrarian-52w-hybrid
New hybrid family that combines the acceleration ladder with the contrarian 52-week recovery leader, but not as a flat blend: each regime computes separate acceleration and repair sleeves, then explicitly arbitrates between them so strong tapes prefer improving trend-continuation unless price is already overheated, while choppier or risk-off tapes only admit rebounds when the 52-week drawdown sits in a repairable band and liquidity/fundamental confirmation is good enough.
Deliberate metric coverage this run: actively use one momentum cluster (1m, 3m, 6m, 12m, and 12_1 through acceleration and repair-confirmation relationships), one recovery cluster (from_52w_high_pct plus from_200d_ma_pct), one volatility check, one liquidity cluster (dollar volume plus trading days), one income check, one valuation check, one growth cluster, one quality cluster, and one size tilt. Deliberately weight avg_daily_volume_3m, dividend_ttm, pe, peg, eps_growth_pct, operating_income_growth_pct, free_cash_flow_growth_pct, free_cash_flow_margin_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 so the backtest can isolate whether the acceleration-versus-repair arbitration adds value beyond the parent families."""

# Deliberate weight-0 metrics this run:
# - Liquidity: avg_daily_volume_3m
# - Income: dividend_ttm
# - Valuation: pe, peg
# - Growth: eps_growth_pct, operating_income_growth_pct, free_cash_flow_growth_pct
# - Quality: free_cash_flow_margin_pct
# - Size/raw levels: shares_outstanding, close, adj_close, high_52w, ma_200d,
#   eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm

OPEN_THRUST = {
    "return_1m_pct": 0.12,
    "return_3m_pct": 0.15,
    "return_6m_pct": 0.12,
    "from_200d_ma_pct": 0.12,
    "realized_vol_3m": -0.09,
    "avg_daily_dollar_volume_3m": 0.09,
    "trading_days_3m": 0.05,
    "revenue_growth_pct": 0.07,
    "forward_eps": 0.05,
    "forward_pe": -0.06,
    "dividend_yield_ttm_pct": 0.03,
    "market_cap": -0.05,
}

REPAIR_BULL = {
    "from_52w_high_pct": -0.15,
    "from_200d_ma_pct": 0.14,
    "return_6m_pct": 0.10,
    "momentum_12_1_pct": 0.08,
    "realized_vol_3m": -0.10,
    "avg_daily_dollar_volume_3m": 0.08,
    "trading_days_3m": 0.05,
    "operating_margin_pct": 0.08,
    "revenue_growth_pct": 0.05,
    "forward_eps": 0.04,
    "forward_pe": -0.05,
    "dividend_yield_ttm_pct": 0.04,
    "market_cap": -0.04,
}

SHELTER = {
    "from_52w_high_pct": -0.08,
    "from_200d_ma_pct": 0.15,
    "realized_vol_3m": -0.16,
    "avg_daily_dollar_volume_3m": 0.10,
    "trading_days_3m": 0.08,
    "operating_margin_pct": 0.10,
    "revenue_growth_pct": 0.06,
    "forward_eps": 0.06,
    "forward_pe": -0.07,
    "dividend_yield_ttm_pct": 0.08,
}


def _branch(regime):
    if regime.get("bull"):
        if regime.get("breadth", 0.0) >= 0.64 and regime.get("median_momentum_12_1_pct", 0.0) >= 6:
            return OPEN_THRUST, "open_thrust"
        return REPAIR_BULL, "repair_bull"
    return SHELTER, "shelter"


def _bounded(value, low, high):
    if value < low:
        return low
    if value > high:
        return high
    return value


def score_universe(stocks, regime, ctx):
    book, branch = _branch(regime)
    zmaps = {}
    for metric in book:
        zmaps[metric] = ctx.z(metric)

    scores = {}

    for row in stocks:
        sym = row["symbol"]

        base_total = 0.0
        base_weight = 0.0
        for metric, weight in book.items():
            z = zmaps[metric].get(sym)
            if z is not None:
                base_total += weight * z
                base_weight += abs(weight)
        total = base_total / base_weight if base_weight > 0 else 0.0

        ret1 = row.get("return_1m_pct")
        ret3 = row.get("return_3m_pct")
        ret6 = row.get("return_6m_pct")
        ret12 = row.get("return_12m_pct")
        mom = row.get("momentum_12_1_pct")
        drawdown = row.get("from_52w_high_pct")
        trend = row.get("from_200d_ma_pct")
        vol = row.get("realized_vol_3m")
        dollar_vol = row.get("avg_daily_dollar_volume_3m")
        trading_days = row.get("trading_days_3m")
        div_yield = row.get("dividend_yield_ttm_pct")
        forward_pe = row.get("forward_pe")
        revenue_growth = row.get("revenue_growth_pct")
        forward_eps = row.get("forward_eps")
        op_margin = row.get("operating_margin_pct")
        cap = row.get("market_cap")

        accel = 0.0
        accel_count = 0.0
        if ret1 is not None and ret3 is not None:
            accel += ret1 - (ret3 / 3.0)
            accel_count += 1.0
        if ret3 is not None and ret6 is not None:
            accel += ret3 - (ret6 / 2.0)
            accel_count += 1.0
        if ret6 is not None and ret12 is not None:
            accel += ret6 - (ret12 / 2.0)
            accel_count += 1.0
        if mom is not None and ret6 is not None:
            accel += mom - (ret6 * 0.4)
            accel_count += 1.0
        accel_value = accel / accel_count if accel_count > 0 else None

        accel_score = 0.0
        accel_weight = 0.0

        if accel_value is not None:
            accel_weight += 1.2
            if branch == "open_thrust":
                if accel_value > 8:
                    accel_score += 1.05
                elif accel_value > 3:
                    accel_score += 0.55
                elif accel_value > 0:
                    accel_score += 0.18
                elif accel_value < -5:
                    accel_score -= 0.95
                elif accel_value < -1:
                    accel_score -= 0.30
            elif branch == "repair_bull":
                if accel_value > 5:
                    accel_score += 0.80
                elif accel_value > 1:
                    accel_score += 0.35
                elif accel_value < -4:
                    accel_score -= 0.85
                elif accel_value < -1:
                    accel_score -= 0.25
            else:
                if accel_value > 4 and accel_value < 12:
                    accel_score += 0.40
                elif accel_value >= 12:
                    accel_score -= 0.18
                elif accel_value < -3:
                    accel_score -= 0.70

        if ret1 is not None:
            accel_weight += 0.7
            if branch == "open_thrust":
                if ret1 > 6 and ret1 < 18:
                    accel_score += 0.45
                elif ret1 >= 18:
                    accel_score -= 0.20
                elif ret1 < -8:
                    accel_score -= 0.55
            elif branch == "repair_bull":
                if ret1 > 4 and ret1 < 15:
                    accel_score += 0.28
                elif ret1 < -9:
                    accel_score -= 0.50
            else:
                if ret1 > 8:
                    accel_score -= 0.12
                elif ret1 < -8:
                    accel_score -= 0.25

        if ret3 is not None:
            accel_weight += 0.8
            if ret3 > 10:
                accel_score += 0.35
            elif ret3 > 3:
                accel_score += 0.18
            elif ret3 < -10:
                accel_score -= 0.55
            elif ret3 < 0:
                accel_score -= 0.15

        if trend is not None:
            accel_weight += 1.0
            if branch == "open_thrust":
                if trend > 5 and trend < 24:
                    accel_score += 0.55
                elif trend >= 24:
                    accel_score -= 0.18
                elif trend < -2:
                    accel_score -= 0.85
            elif branch == "repair_bull":
                if trend > 3 and trend < 18:
                    accel_score += 0.42
                elif trend < -2:
                    accel_score -= 0.80
            else:
                if trend > 1 and trend < 14:
                    accel_score += 0.28
                elif trend < 0:
                    accel_score -= 0.75

        if vol is not None:
            accel_weight += 0.7
            if vol < 22:
                accel_score += 0.20
            elif vol > 46:
                accel_score -= 0.50
            elif vol > 34:
                accel_score -= 0.15

        if accel_weight > 0:
            accel_score = accel_score / accel_weight

        recovery_score = 0.0
        recovery_weight = 0.0

        if drawdown is not None:
            recovery_weight += 1.3
            if branch == "open_thrust":
                if drawdown < -40:
                    recovery_score -= 0.75
                elif drawdown < -26:
                    recovery_score += 0.20
                elif drawdown < -12:
                    recovery_score += 0.48
                elif drawdown < -4:
                    recovery_score -= 0.04
                else:
                    recovery_score -= 0.38
            elif branch == "repair_bull":
                if drawdown < -45:
                    recovery_score -= 0.70
                elif drawdown < -32:
                    recovery_score += 0.12
                elif drawdown < -18:
                    recovery_score += 1.05
                elif drawdown < -8:
                    recovery_score += 0.60
                elif drawdown < -3:
                    recovery_score += 0.08
                else:
                    recovery_score -= 0.30
            else:
                if drawdown < -34:
                    recovery_score -= 0.62
                elif drawdown < -18:
                    recovery_score -= 0.05
                elif drawdown < -6:
                    recovery_score += 0.78
                else:
                    recovery_score -= 0.18

        if trend is not None:
            recovery_weight += 1.0
            if branch == "open_thrust":
                if trend > 8:
                    recovery_score += 0.45
                elif trend < 0:
                    recovery_score -= 0.62
            elif branch == "repair_bull":
                if trend > 10:
                    recovery_score += 0.78
                elif trend > 2:
                    recovery_score += 0.34
                elif trend < -2:
                    recovery_score -= 0.92
            else:
                if trend > 6:
                    recovery_score += 0.62
                elif trend > 1:
                    recovery_score += 0.28
                elif trend < 0:
                    recovery_score -= 0.90

        if ret6 is not None:
            recovery_weight += 0.9
            if ret6 > 16:
                recovery_score += 0.40
            elif ret6 > 6:
                recovery_score += 0.24
            elif ret6 < -8:
                recovery_score -= 0.62
            elif ret6 < 0:
                recovery_score -= 0.20

        if mom is not None:
            recovery_weight += 0.8
            if mom >= 3 and mom <= 24:
                recovery_score += 0.42
            elif mom > 24:
                recovery_score += 0.10
            elif mom < -12:
                recovery_score -= 0.65
            elif mom < 0:
                recovery_score -= 0.18

        if vol is not None:
            recovery_weight += 0.6
            if vol < 24:
                recovery_score += 0.22
            elif vol > 42:
                recovery_score -= 0.42

        if recovery_weight > 0:
            recovery_score = recovery_score / recovery_weight

        confirm_score = 0.0
        confirm_weight = 0.0

        if dollar_vol is not None:
            confirm_weight += 0.8
            if dollar_vol > 30000000:
                confirm_score += 0.50
            elif dollar_vol > 10000000:
                confirm_score += 0.25
            elif dollar_vol < 2500000:
                confirm_score -= 0.70
            elif dollar_vol < 6000000:
                confirm_score -= 0.25

        if trading_days is not None:
            confirm_weight += 0.7
            if trading_days >= 62:
                confirm_score += 0.28
            elif trading_days <= 57:
                confirm_score -= 0.55

        if revenue_growth is not None:
            confirm_weight += 0.7
            if revenue_growth > 14:
                confirm_score += 0.45
            elif revenue_growth > 5:
                confirm_score += 0.18
            elif revenue_growth < -10:
                confirm_score -= 0.55
            elif revenue_growth < 0:
                confirm_score -= 0.18

        if forward_eps is not None:
            confirm_weight += 0.5
            if forward_eps > 0:
                confirm_score += 0.22
            else:
                confirm_score -= 0.70

        if op_margin is not None:
            confirm_weight += 0.7
            if op_margin > 16:
                confirm_score += 0.42
            elif op_margin > 6:
                confirm_score += 0.16
            elif op_margin < 0:
                confirm_score -= 0.70
            elif op_margin < 4:
                confirm_score -= 0.15

        if forward_pe is not None:
            confirm_weight += 0.6
            if forward_pe > 0 and forward_pe < 18:
                confirm_score += 0.26
            elif forward_pe > 40:
                confirm_score -= 0.42

        if div_yield is not None:
            confirm_weight += 0.4
            if div_yield >= 0.7 and div_yield <= 4.0:
                confirm_score += 0.18
            elif div_yield > 5.5:
                confirm_score -= 0.20
            elif div_yield == 0 and branch == "shelter":
                confirm_score -= 0.10

        if confirm_weight > 0:
            confirm_score = confirm_score / confirm_weight

        if branch == "open_thrust":
            if accel_weight > 0 and accel_score > 0.30:
                if recovery_weight > 0 and drawdown is not None and drawdown > -4:
                    total += 0.52 * accel_score - 0.10
                else:
                    total += 0.62 * accel_score

            if recovery_weight > 0 and recovery_score > 0.18:
                total += 0.22 * recovery_score

            if accel_weight > 0 and recovery_weight > 0:
                if accel_score > 0.35 and recovery_score > 0.12:
                    total += 0.22
                elif accel_score > 0.35 and recovery_score < -0.12:
                    total -= 0.26
                elif recovery_score > 0.30 and accel_score < -0.10:
                    total -= 0.16

            if cap is not None:
                if cap < 3000000000:
                    total += 0.14
                elif cap > 180000000000:
                    total -= 0.10

        elif branch == "repair_bull":
            if recovery_weight > 0:
                total += 0.52 * recovery_score

            if accel_weight > 0:
                if recovery_weight > 0 and recovery_score > 0.22:
                    total += 0.30 * accel_score
                else:
                    total += 0.16 * accel_score

            if recovery_weight > 0 and accel_weight > 0:
                if recovery_score > 0.35 and accel_score > 0.12:
                    total += 0.28
                elif recovery_score > 0.45 and accel_score < -0.12:
                    total -= 0.42
                elif accel_score > 0.32 and recovery_score < -0.08:
                    total -= 0.30

            if drawdown is not None and trend is not None:
                if drawdown < -12 and drawdown > -30 and trend > 4:
                    total += 0.20

            if cap is not None:
                if cap < 6000000000:
                    total += 0.10
                elif cap > 180000000000:
                    total -= 0.08

        else:
            if recovery_weight > 0:
                total += 0.34 * recovery_score
            if accel_weight > 0 and accel_score > 0.10:
                total += 0.12 * accel_score

            if recovery_weight > 0 and accel_weight > 0:
                if recovery_score > 0.25 and accel_score > 0.08:
                    total += 0.12
                elif recovery_score > 0.30 and accel_score < -0.15:
                    total -= 0.22

            if vol is not None:
                if vol < 24:
                    total += 0.12
                elif vol > 36:
                    total -= 0.24

            if trend is not None and trend < 0:
                total -= 0.22

        if confirm_weight > 0:
            if branch == "open_thrust":
                total += 0.18 * confirm_score
            elif branch == "repair_bull":
                total += 0.26 * confirm_score
            else:
                total += 0.34 * confirm_score

        if recovery_weight > 0 and confirm_weight > 0:
            if recovery_score > 0.35 and confirm_score > 0.18:
                total += 0.18
            elif recovery_score > 0.40 and confirm_score < -0.18:
                total -= 0.38
            elif recovery_score < -0.20 and confirm_score > 0.35 and branch == "shelter":
                total += 0.06

        if accel_weight > 0 and confirm_weight > 0:
            if accel_score > 0.35 and confirm_score < -0.18:
                total -= 0.24
            elif accel_score < -0.20 and confirm_score > 0.25 and branch != "open_thrust":
                total += 0.05

        if accel_weight > 0 and recovery_weight > 0:
            total += 0.08 * _bounded(accel_score - recovery_score, -1.5, 1.5) * (0.55 if branch == "open_thrust" else -0.45 if branch == "shelter" else 0.10)

        scores[sym] = total

    return scores