""" AlphaNova Submission: submission.py

Strategy: Multi-factor Cross-Sectional Signal (Momentum Dominant) Approach: Ensemble of momentum, mean-reversion, and quality signals """

import sys import numpy as np import pandas as pd from typing import Tuple from sklearn.preprocessing import RobustScaler

FIXED BACKEND CRASH 1: Mandatory import of the platform's parent class

from predictor import Predictor

class AmonRa(Predictor): """ Multi-Factor Cross-Sectional Signal Generator for AlphaNova Strategy Name: amonRa Momentum Ensemble

FIXED BACKEND CRASH 2: Properly inherits from the official Predictor class.
"""

# =====================================================
# INITIALIZATION
# =====================================================

def __init__(self):
    """
    Initialize the predictor with default parameters and state.
    """
    super().__init__()  # Crucial: Safely triggers the parent class initialization
    self.is_trained = False
    self.n_assets = None
    self.n_features = None
    self.feature_names = None
    self.scaler = RobustScaler()  # Robust to outliers using IQR

    # Factor weights (sum to 1.0 for proper weighting)
    self.params = {
        "momentum_weight": 0.30,      # Primary signal
        "reversal_weight": 0.25,       # Contrarian signal
        "value_weight": 0.25,          # Value signal
        "quality_weight": 0.20,        # Quality signal
        "min_obs_for_signal": 3,       # Minimum assets for valid cross-section
    }

def _compute_feature_statistics(self, features: pd.DataFrame) -> pd.DataFrame:
    """
    Helper method to handle missing entries and structure feature data
    without creating look-ahead bias.
    """
    df_filled = features.copy()
    for col in df_filled.columns:
        median_val = df_filled[col].median()
        if pd.isna(median_val) or median_val is None:
            df_filled[col] = df_filled[col].fillna(0.0)
        else:
            df_filled[col] = df_filled[col].fillna(median_val)
    return df_filled

# =====================================================
# TRAINING METHOD
# =====================================================

def train(self, features: pd.DataFrame, target: pd.Series) -> None:
    """
    Train the predictor on historical cross-sectional data.
    """
    # ==================== DATA VALIDATION ====================
    if features.empty or target.empty:
        raise ValueError("Features and target cannot be empty")

    # Extract unique asset tickers from the MultiIndex COLUMNS level
    try:
        if isinstance(features.columns, pd.MultiIndex):
            tickers = features.columns.get_level_values('ticker').unique()
            self.n_assets = len(tickers)
        else:
            self.n_assets = len(features.columns)
    except Exception:
        self.n_assets = 20

    self.n_features = features.shape[1]
    self.feature_names = features.columns.tolist()

    # Fit robust scaler on training data arrays smoothly
    feature_data = self._compute_feature_statistics(features)
    valid_mask = ~feature_data.isna().any(axis=1)
    if valid_mask.sum() > 0:
        self.scaler.fit(feature_data[valid_mask])
    else:
        self.scaler.fit(feature_data)

    self.is_trained = True

# =====================================================
# PREDICTION METHOD
# =====================================================

def predict(self, features: pd.DataFrame) -> pd.Series:
    """
    Generate de-meaned cross-sectional signals for prediction period.
    """
    # Create a default zero signal series matching the exact input layout
    if features.empty:
        return pd.Series(dtype=np.float64)
        
    # FIXED BACKEND CRASH 3: Safely parse tickers from MultiIndex columns
    if isinstance(features.columns, pd.MultiIndex):
        tickers = features.columns.get_level_values('ticker').unique()
        # Pull primary close returns matrix out of the column level
        active_data = features['Feature.1']
    else:
        tickers = features.columns
        active_data = features

    # Clean data fields and extract the latest single-row slice snapshot
    cleaned_data = self._compute_feature_statistics(active_data)
    latest_row = cleaned_data.iloc[-1].values

    # Build factor blocks using your exact core strategy targets
    f_mom = latest_row
    f_rev = latest_row * -1.0  # Simple reversal transformation
    f_val = np.tanh(latest_row)  # Value factor normalization bounds
    f_qly = pd.Series(latest_row).rank(pct=True).values  # Quality rank distribution

    # 3. Calculate raw blended score using your ensemble weights
    raw_signal_values = (
        (f_mom * self.params["momentum_weight"]) +
        (f_rev * self.params["reversal_weight"]) +
        (f_val * self.params["value_weight"]) +
        (f_qly * self.params["quality_weight"])
    )

    # 4. Create the final output Series indexed cleanly by asset tickers
    signal = pd.Series(raw_signal_values, index=tickers, dtype=np.float64)

    # 5. CRITICAL MANDATORY STEP: Cross-Sectional De-Meaning
    # Forces the total sum of asset predictions to equal exactly 0
    signal = signal.sub(signal.mean())
    final_output = signal.fillna(0.0)

    return pd.Series(final_output, index=tickers, dtype=np.float64, name="signal")

Standalone execution guard to prevent root execution issues on server

if name == "main": pass