Update app.py

app.py

@@ -1,927 +1,927 @@
-import os
-import json
-import math
-from typing import List, Dict, Any, Optional
-import warnings
-warnings.filterwarnings('ignore', category=RuntimeWarning)
-
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass
-
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-
-try:
-    import joblib
-except Exception:
-    joblib = None
-import pickle
-
-try:
-    import numpy as np
-    import pandas as pd
-except Exception as e:
-    print(f"Warning: NumPy/Pandas import issue: {e}")
-    import sys
-    sys.exit(1)
-
-try:
-    import torch
-    import torch.nn as nn
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
-    print("Warning: PyTorch not available. Deep learning models will not load.")
-
-# Import PyTorch model architectures
-if TORCH_AVAILABLE:
-    try:
-        from models import LSTMModel, GRUModel, FeedForwardNN, BiLSTMModel, CNN1DModel
-    except ImportError as e:
-        print(f"Warning: Could not import model architectures: {e}")
-        TORCH_AVAILABLE = False
-
-from datetime import datetime, timedelta
-import requests
-from sklearn.base import BaseEstimator, TransformerMixin
-from sklearn.pipeline import Pipeline
-
-
-API_TITLE = "ELC-V Prediction API"
-API_VERSION = "0.3.0"
-
-RAW_FEATURES = ["Open", "High", "Low", "Close", "Volume"]
-
-MARKETSTACK_API_KEY = os.environ.get("MARKETSTACK_API_KEY")
-print("\n\n\n\n\n", MARKETSTACK_API_KEY, "\n\n\n\n\n")
-MARKETSTACK_BASE_URL = "http://api.marketstack.com/v1"
-
-
-def load_artifact(path: str):
-    # Handle PyTorch models
-    if path.endswith('.pth'):
-        if not TORCH_AVAILABLE:
-            raise ImportError("PyTorch is required to load .pth files")
-        # Use weights_only=False for trusted model files
-        return torch.load(path, map_location=torch.device('cpu'), weights_only=False)
-    
-    # Handle sklearn/joblib models
-    if joblib is not None:
-        try:
-            return joblib.load(path)
-        except Exception:
-            pass
-    with open(path, "rb") as f:
-        return pickle.load(f)
-
-
-class FeatureEngineer(BaseEstimator, TransformerMixin):
-    """Sklearn-compatible feature engineering transformer."""
-    def __init__(self, lookback: int = 7):
-        self.lookback = lookback
-        self.feature_names_ = None
-
-    def fit(self, X, y=None):
-        return self
-
-    def transform(self, X):
-        if not isinstance(X, pd.DataFrame):
-            X = pd.DataFrame(X, columns=RAW_FEATURES)
-        else:
-            X = X.copy()
-
-        for col in RAW_FEATURES:
-            if col not in X.columns:
-                raise ValueError(f"Missing column: {col}")
-
-        for i in range(1, self.lookback + 1):
-            X[f'Close_lag_{i}'] = X['Close'].shift(i).fillna(X['Close'].mean())
-            X[f'Volume_lag_{i}'] = X['Volume'].shift(i).fillna(X['Volume'].mean())
-            X[f'Open_lag_{i}'] = X['Open'].shift(i).fillna(X['Open'].mean())
-            X[f'High_lag_{i}'] = X['High'].shift(i).fillna(X['High'].mean())
-            X[f'Low_lag_{i}'] = X['Low'].shift(i).fillna(X['Low'].mean())
-
-        X['returns'] = X['Close'].pct_change()
-        X['log_returns'] = np.log(X['Close'] / X['Close'].shift(1))
-
-        X['ma_7'] = X['Close'].rolling(window=7, min_periods=1).mean()
-        X['ma_14'] = X['Close'].rolling(window=14, min_periods=1).mean()
-        X['ma_30'] = X['Close'].rolling(window=30, min_periods=1).mean()
-
-        X['volatility_7'] = X['returns'].rolling(window=7, min_periods=1).std()
-        X['volatility_14'] = X['returns'].rolling(window=14, min_periods=1).std()
-
-        X['momentum_7'] = X['Close'] - X['Close'].shift(7).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
-        X['momentum_14'] = X['Close'] - X['Close'].shift(14).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
-
-        delta = X['Close'].diff()
-        gain = (delta.where(delta > 0, 0)).rolling(window=14, min_periods=1).mean()
-        loss = (-delta.where(delta < 0, 0)).rolling(window=14, min_periods=1).mean()
-        rs = gain / loss
-        X['rsi_14'] = 100 - (100 / (1 + rs))
-
-        X['bb_upper'] = X['ma_7'] + (X['volatility_7'] * 2)
-        X['bb_Lower'] = X['ma_7'] - (X['volatility_7'] * 2)
-        X['bb_width'] = X['bb_upper'] - X['bb_Lower']
-
-        X = X.bfill().ffill()
-        for col in X.columns:
-            if X[col].isna().any():
-                X[col] = X[col].fillna(X[col].mean() if X[col].notna().any() else 0)
-        X = X.fillna(0)
-
-        expected_order = [
-            'Close', 'Volume', 'Open', 'High', 'Low',
-            'Close_lag_1', 'Volume_lag_1', 'Open_lag_1', 'High_lag_1', 'Low_lag_1',
-            'Close_lag_2', 'Volume_lag_2', 'Open_lag_2', 'High_lag_2', 'Low_lag_2',
-            'Close_lag_3', 'Volume_lag_3', 'Open_lag_3', 'High_lag_3', 'Low_lag_3',
-            'Close_lag_4', 'Volume_lag_4', 'Open_lag_4', 'High_lag_4', 'Low_lag_4',
-            'Close_lag_5', 'Volume_lag_5', 'Open_lag_5', 'High_lag_5', 'Low_lag_5',
-            'Close_lag_6', 'Volume_lag_6', 'Open_lag_6', 'High_lag_6', 'Low_lag_6',
-            'Close_lag_7', 'Volume_lag_7', 'Open_lag_7', 'High_lag_7', 'Low_lag_7',
-            'returns', 'log_returns', 'ma_7', 'ma_14', 'ma_30',
-            'volatility_7', 'volatility_14', 'momentum_7', 'momentum_14',
-            'rsi_14', 'bb_upper', 'bb_Lower', 'bb_width'
-        ]
-        
-        for col in expected_order:
-            if col not in X.columns:
-                X[col] = 0
-        
-        X = X[expected_order]
-
-        if self.feature_names_ is None:
-            self.feature_names_ = list(X.columns)
-
-        X.columns.name = None
-        return X
-
-    def get_feature_names_out(self, input_features=None):
-        if self.feature_names_ is None:
-            dummy = pd.DataFrame(
-                np.random.randn(30, 5),
-                columns=RAW_FEATURES
-            )
-            self.transform(dummy)
-        return np.array(self.feature_names_)
-
-
-class PyTorchModelWrapper:
-    """Wrapper to make PyTorch models compatible with sklearn pipeline API."""
-    def __init__(self, model):
-        self.model = model
-        if TORCH_AVAILABLE:
-            self.model.eval()  # Set to evaluation mode
-    
-    def predict(self, X):
-        if not TORCH_AVAILABLE:
-            raise ImportError("PyTorch is required for this model")
-        
-        # Convert to numpy if DataFrame
-        if isinstance(X, pd.DataFrame):
-            X = X.values
-        
-        # Convert to torch tensor
-        X_tensor = torch.FloatTensor(X)
-        
-        # Make prediction
-        with torch.no_grad():
-            output = self.model(X_tensor)
-            # Handle different output formats
-            if isinstance(output, torch.Tensor):
-                predictions = output.cpu().numpy()
-                # If output is probabilities (2 classes), take class with higher prob
-                if predictions.shape[-1] == 2:
-                    predictions = predictions.argmax(axis=-1)
-                # Flatten if needed
-                if len(predictions.shape) > 1 and predictions.shape[-1] == 1:
-                    predictions = predictions.flatten()
-            else:
-                predictions = output
-        
-        return predictions
-
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MODELS_DIR = os.path.join(BASE_DIR, "static", "models")
-
-
-def create_app() -> Flask:
-    app = Flask(__name__)
-    CORS(app, resources={
-        r"/*": {
-            "origins": ["http://localhost:3000", "http://127.0.0.1:3000"],
-            "methods": ["GET", "POST", "OPTIONS"],
-            "allow_headers": ["Content-Type"],
-        }
-    })
-
-    app.config["ARTIFACTS"] = {
-        "pipeline": None,
-        "models": {
-            # Tree/linear/boosting models
-            "random_forest": None,
-            "adaboost": None,
-            "extra_trees": None,
-            "gradient_boosting": None,
-            "xgboost": None,
-            "lightgbm": None,
-            "catboost": None,
-            "svm": None,
-            "logistic_regression": None,
-            "knn": None,
-            "best_ensemble": None,
-            "best_individual": None,
-
-            # Deep learning models (can remain unavailable if PyTorch not installed)
-            "lstm": None,
-            "bilstm": None,
-            "gru": None,
-            "1d_cnn": None,
-            "feed_forward_nn": None,
-
-            # Convenience entries for API defaults
-            "ensemble": None,
-            "individual": None,
-        },
-        "summary": None,
-        "scaler": None,
-        "available_models": [],
-    }
-
-    def _artifact_path(name: str) -> str:
-        return os.path.join(MODELS_DIR, name)
-
-    def _load_artifacts() -> Dict[str, Any]:
-        artifacts = app.config["ARTIFACTS"]
-        try:
-            engineer = FeatureEngineer(lookback=7)
-
-            # Load the pipeline with scaler
-            pipeline_path = _artifact_path("random_forest_pipeline.joblib")
-            if os.path.exists(pipeline_path):
-                saved_pipeline = load_artifact(pipeline_path)
-                artifacts["pipeline"] = Pipeline([
-                    ('features', engineer),
-                    ('saved_pipeline', saved_pipeline),
-                ])
-            else:
-                scaler_path = _artifact_path("random_forest_scaler.joblib")
-                scaler = None
-                if os.path.exists(scaler_path):
-                    scaler = load_artifact(scaler_path)
-
-                if scaler is not None:
-                    artifacts["pipeline"] = Pipeline([
-                        ('features', engineer),
-                        ('scaler', scaler),
-                    ])
-                else:
-                    artifacts["pipeline"] = Pipeline([
-                        ('features', engineer),
-                    ])
-
-            # Load individual models (ML first, DL optional)
-            model_mappings = {
-                # Primary models
-                "random_forest": "random_forest.pkl",
-                "adaboost": "adaboost.pkl",
-                "extra_trees": "extra_trees.pkl",
-                "gradient_boosting": "gradient_boosting.pkl",
-                "xgboost": "xgboost.pkl",
-                "lightgbm": "lightgbm.pkl",
-                "catboost": "catboost.pkl",
-                "svm": "svm.pkl",
-                "logistic_regression": "logistic_regression.pkl",
-                "knn": "knn.pkl",
-                "best_ensemble": "best_ensemble_package.pkl",  # Fixed filename
-                "best_individual": "best_individual_model.pkl",
-
-                # Deep learning models (load only if PyTorch available)
-                "lstm": "lstm.pth",
-                "bilstm": "bilstm.pth",
-                "gru": "gru.pth",
-                "1d_cnn": "1d-cnn.pth",
-                "feed_forward_nn": "feed-forward_nn.pth",
-            }
-
-            loaded_models = []
-            for model_name, model_file in model_mappings.items():
-                model_path = _artifact_path(model_file)
-                if os.path.exists(model_path):
-                    try:
-                        loaded = load_artifact(model_path)
-                        # Skip if it's a dict (training metadata) or doesn't have predict method
-                        if isinstance(loaded, dict):
-                            print(f"Skipped {model_name}: loaded as dict (metadata)")
-                            continue
-                        if not hasattr(loaded, 'predict'):
-                            print(f"Skipped {model_name}: no predict method")
-                            continue
-                        # Wrap PyTorch models
-                        if model_file.endswith('.pth') and TORCH_AVAILABLE:
-                            loaded = PyTorchModelWrapper(loaded)
-                        artifacts["models"][model_name] = loaded
-                        loaded_models.append(model_name)
-                        print(f"Loaded model: {model_name}")
-                    except Exception as e:
-                        print(f"Failed to load {model_name}: {e}")
-                else:
-                    print(f"Model file not found: {model_file}")
-
-            artifacts["available_models"] = loaded_models
-
-            # Set defaults: prefer saved best ensemble/individual, then random forest, then first available
-            ensemble_default = artifacts["models"].get("best_ensemble") or artifacts["models"].get("random_forest")
-            individual_default = artifacts["models"].get("best_individual") or artifacts["models"].get("random_forest")
-
-            if ensemble_default is None and loaded_models:
-                ensemble_default = artifacts["models"].get(loaded_models[0])
-            if individual_default is None and loaded_models:
-                individual_default = artifacts["models"].get(loaded_models[0])
-
-            artifacts["models"]["ensemble"] = ensemble_default
-            artifacts["models"]["individual"] = individual_default
-
-            summary_path = _artifact_path("results_summary.pkl")
-            if os.path.exists(summary_path):
-                artifacts["summary"] = load_artifact(summary_path)
-        except Exception as e:
-            artifacts["summary"] = {"error": f"Failed to load artifacts: {e}"}
-
-        return artifacts
-
-    def _validate_instance(instance: Dict[str, Any]) -> List[str]:
-        return [k for k in RAW_FEATURES if k not in instance]
-
-    def _prepare_pipeline_input(instances: List[Dict[str, Any]]) -> pd.DataFrame:
-        data = []
-        for inst in instances:
-            row = {col: inst[col] for col in RAW_FEATURES}
-            data.append(row)
-        return pd.DataFrame(data)
-
-    @app.route("/health", methods=["GET"])
-    def health():
-        artifacts = app.config["ARTIFACTS"]
-        status = {
-            "title": API_TITLE,
-            "version": API_VERSION,
-            "pipeline": artifacts["pipeline"] is not None,
-            "available_models": artifacts["available_models"],
-            "models": {k: artifacts["models"][k] is not None for k in artifacts["models"]},
-            "model_count": len([m for m in artifacts["models"].values() if m is not None]),
-        }
-        has_models = any([m for m in artifacts["models"].values() if m is not None])
-        http_code = 200 if has_models else 503
-        return jsonify(status), http_code
-
-    @app.route("/metadata", methods=["GET"])
-    def metadata():
-        artifacts = app.config["ARTIFACTS"]
-        summary = artifacts.get("summary")
-        try:
-            def _to_jsonable(obj):
-                try:
-                    json.dumps(obj)
-                    return obj
-                except TypeError:
-                    return str(obj)
-
-            if isinstance(summary, dict):
-                return jsonify({k: _to_jsonable(v) for k, v in summary.items()})
-            return jsonify({"summary": _to_jsonable(summary)})
-        except Exception:
-            return jsonify({"summary": "unavailable"})
-
-    @app.route("/predict", methods=["POST"])
-    def predict():
-        artifacts = app.config["ARTIFACTS"]
-        pipeline = artifacts["pipeline"]
-        if pipeline is None:
-            return jsonify({"error": "Pipeline not loaded"}), 503
-
-        models_loaded = any(artifacts["models"].values())
-        pipeline_can_predict = hasattr(pipeline, "predict")
-        if not models_loaded and not pipeline_can_predict:
-            return jsonify({"error": "Models not loaded"}), 503
-
-        payload = request.get_json(silent=True) or {}
-        model_choice = (payload.get("model") or "random_forest").lower()
-        return_all = bool(payload.get("all_models"))
-        
-        # Try to get the requested model
-        model = artifacts["models"].get(model_choice)
-        
-        # Fallback to ensemble, then individual, then first available
-        if model is None:
-            if artifacts["models"].get("ensemble"):
-                model = artifacts["models"]["ensemble"]
-            elif artifacts["models"].get("individual"):
-                model = artifacts["models"]["individual"]
-            elif artifacts["available_models"]:
-                model = artifacts["models"][artifacts["available_models"][0]]
-
-        if model is None:
-            return jsonify({
-                "error": f"Requested model '{model_choice}' not available",
-                "available_models": artifacts["available_models"]
-            }), 400
-
-        instances = []
-        if isinstance(payload.get("instances"), list):
-            instances = payload["instances"]
-        elif all(k in payload for k in RAW_FEATURES):
-            instances = [payload]
-
-        if not instances:
-            return jsonify({
-                "error": "No instances provided",
-                "expected_format": {
-                    "single": {c: "<number>" for c in RAW_FEATURES},
-                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
-                },
-                "input_columns": RAW_FEATURES,
-                "available_models": artifacts["available_models"],
-                "note": "For best results, provide at least 7 rows of history for lagged features"
-            }), 400
-
-        for i, inst in enumerate(instances):
-            missing = _validate_instance(inst)
-            if missing:
-                return jsonify({
-                    "error": f"Instance {i} missing features: {missing}",
-                    "input_columns": RAW_FEATURES
-                }), 400
-
-        try:
-            X_input = _prepare_pipeline_input(instances)
-            pipeline_can_transform = hasattr(pipeline, "transform")
-
-            # Prepare transformed features once
-            if pipeline_can_transform:
-                X_transformed = pipeline.transform(X_input)
-                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
-            else:
-                X_to_predict = X_input[-1:, :]
-
-            # Main prediction using requested/fallback model
-            if pipeline_can_predict:
-                y_all = pipeline.predict(X_input)
-                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
-            elif model is not None:
-                y_pred = model.predict(X_to_predict)
-            else:
-                return jsonify({"error": "Pipeline cannot process data"}), 503
-
-            # Optional per-model predictions
-            predictions_by_model = None
-            if return_all:
-                predictions_by_model = {}
-                for m_name in artifacts["available_models"]:
-                    m = artifacts["models"].get(m_name)
-                    if m is None:
-                        continue
-                    try:
-                        y_m = m.predict(X_to_predict)
-                        pred_val = float(y_m[0].item() if hasattr(y_m[0], "item") else y_m[0])
-                        predictions_by_model[m_name] = pred_val
-                    except Exception as e:
-                        predictions_by_model[m_name] = {"error": str(e)}
-
-            response = {
-                "model": model_choice,
-                "input_columns": RAW_FEATURES,
-                "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
-                "count": len(y_pred),
-                "available_models": artifacts["available_models"],
-                "note": f"Processed {len(instances)} input row(s), predicted on last row"
-            }
-
-            if predictions_by_model is not None:
-                response["predictions_by_model"] = predictions_by_model
-
-            return jsonify(response)
-        except Exception as e:
-            return jsonify({"error": f"Pipeline failed: {str(e)}"}), 400
-
-    @app.route("/predict/symbol", methods=["POST"])
-    def predict_symbol():
-        artifacts = app.config["ARTIFACTS"]
-        pipeline = artifacts["pipeline"]
-        if pipeline is None:
-            return jsonify({"error": "Pipeline not loaded"}), 503
-
-        pipeline_can_transform = hasattr(pipeline, "transform")
-        pipeline_can_predict = hasattr(pipeline, "predict")
-
-        payload = request.get_json(silent=True) or {}
-        symbol = (payload.get("symbol") or "").upper()
-        days = int(payload.get("days", 30))
-        model_choice = (payload.get("model") or "random_forest").lower()
-
-        model = artifacts["models"].get(model_choice)
-        if model is None:
-            if artifacts["models"].get("ensemble"):
-                model = artifacts["models"]["ensemble"]
-            elif artifacts["models"].get("individual"):
-                model = artifacts["models"]["individual"]
-            elif artifacts["available_models"]:
-                model = artifacts["models"][artifacts["available_models"][0]]
-
-        if not symbol:
-            return jsonify({"error": "Symbol required"}), 400
-
-        df = fetch_market_data(symbol, days)
-        if df is None or len(df) == 0:
-            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
-
-        try:
-            if pipeline_can_predict:
-                y_all = pipeline.predict(df)
-                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
-            elif pipeline_can_transform and model is not None:
-                # Create feature engineer to transform raw OHLCV data
-                engineer = FeatureEngineer(lookback=7)
-                print(f"[DEBUG] Input df shape: {df.shape}")
-                X_engineered = engineer.fit_transform(df)
-                print(f"[DEBUG] Engineered shape: {X_engineered.shape}, type: {type(X_engineered)}")
-                
-                # Get the last row for prediction
-                if isinstance(X_engineered, pd.DataFrame):
-                    X_last_row = X_engineered.iloc[-1:].values
-                else:
-                    # Ensure it's a numpy array and 2D
-                    X_engineered = np.array(X_engineered)
-                    if X_engineered.ndim == 1:
-                        X_last_row = X_engineered.reshape(1, -1)
-                    else:
-                        X_last_row = X_engineered[-1:]
-                
-                # Apply scaler if available
-                if hasattr(pipeline, "named_steps") and pipeline.named_steps.get("scaler"):
-                    X_to_predict = pipeline.named_steps["scaler"].transform(X_last_row)
-                else:
-                    X_to_predict = X_last_row
-                    
-                y_pred = model.predict(X_to_predict)
-            else:
-                return jsonify({"error": "Pipeline cannot process data"}), 503
-        except Exception as e:
-            import traceback
-            return jsonify({
-                "error": f"Prediction failed: {str(e)}",
-                "traceback": traceback.format_exc()
-            }), 500
-
-        pred_scalar = y_pred[-1] if hasattr(y_pred, "__len__") else y_pred
-        try:
-            pred_scalar = float(getattr(pred_scalar, "item", lambda: pred_scalar)())
-        except Exception:
-            pred_scalar = float(pred_scalar)
-
-        proba_val = None
-        if hasattr(pipeline, "predict_proba"):
-            try:
-                p_all = pipeline.predict_proba(df)
-                p_last = p_all[-1] if len(p_all) > 1 else p_all[0]
-                proba_val = float(max(p_last))
-            except Exception:
-                pass
-        elif model is not None and hasattr(model, "predict_proba"):
-            try:
-                X_transformed = pipeline.transform(df) if pipeline_can_transform else df
-                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
-                p = model.predict_proba(X_to_predict)
-                proba_val = float(max(p[0]))
-            except Exception:
-                pass
-
-        if proba_val is None or (isinstance(proba_val, float) and math.isnan(proba_val)):
-            proba_val = 1.0 if pred_scalar in (0.0, 1.0) else 0.5
-
-        latest = df.iloc[-1].to_dict()
-        return jsonify({
-            "symbol": symbol,
-            "data_points": len(df),
-            "latest_data": latest,
-            "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
-            "count": len(y_pred),
-            "predicted_price": pred_scalar,
-            "confidence": proba_val,
-            "model": model_choice,
-            "available_models": artifacts["available_models"],
-            "note": "Prediction based on Marketstack historical data"
-        })
-
-    @app.route("/predict/consensus", methods=["POST"])
-    def predict_consensus():
-        """Get consensus (mode) prediction from all models with individual model details for a symbol"""
-        artifacts = app.config["ARTIFACTS"]
-        pipeline = artifacts["pipeline"]
-        if pipeline is None:
-            return jsonify({"error": "Pipeline not loaded"}), 503
-
-        payload = request.get_json(silent=True) or {}
-        symbol = (payload.get("symbol") or "").upper()
-        days = int(payload.get("days", 30))
-
-        if not symbol:
-            return jsonify({"error": "Symbol required"}), 400
-
-        # Fetch market data for the symbol
-        df = fetch_market_data(symbol, days)
-        if df is None or len(df) == 0:
-            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
-
-        try:
-            # Create feature engineer to transform raw OHLCV data
-            engineer = FeatureEngineer(lookback=7)
-            
-            # Transform raw market data to engineered features
-            X_engineered = engineer.fit_transform(df)
-            print(f"Engineered features shape (before conversion): {X_engineered.shape}")
-            
-            # Get the last row for prediction
-            if isinstance(X_engineered, pd.DataFrame):
-                X_last_row = X_engineered.iloc[-1:].values
-            else:
-                # Ensure it's a numpy array and 2D
-                X_engineered = np.array(X_engineered)
-                if X_engineered.ndim == 1:
-                    X_last_row = X_engineered.reshape(1, -1)
-                else:
-                    X_last_row = X_engineered[-1:]
-            
-            print(f"Last row shape for prediction: {X_last_row.shape}")
-            
-            # Then apply scaler from pipeline if available
-            pipeline_can_transform = hasattr(pipeline, "transform")
-            if pipeline_can_transform:
-                # Use the scaler/preprocessing from the pipeline
-                try:
-                    # Get the scaler step from pipeline
-                    scaler = None
-                    if hasattr(pipeline, "named_steps"):
-                        scaler = pipeline.named_steps.get("scaler")
-                    
-                    if scaler is not None:
-                        X_to_predict = scaler.transform(X_last_row)
-                    else:
-                        X_to_predict = X_last_row
-                except Exception as e:
-                    print(f"Scaler error: {e}")
-                    X_to_predict = X_last_row
-            else:
-                X_to_predict = X_last_row
-
-            # Get predictions from all available models with confidence
-            predictions_by_model = {}
-            valid_predictions = []
-            
-            if not artifacts["available_models"]:
-                return jsonify({
-                    "error": "No models available for prediction",
-                    "debug": "available_models is empty"
-                }), 503
-            
-            for model_name in artifacts["available_models"]:
-                model = artifacts["models"].get(model_name)
-                if model is None:
-                    predictions_by_model[model_name] = {"error": "Model not found"}
-                    continue
-                    
-                try:
-                    y_pred = model.predict(X_to_predict)
-                    pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
-                    valid_predictions.append(pred_value)
-                    
-                    # Try to get confidence/probability
-                    confidence = None
-                    if hasattr(model, "predict_proba"):
-                        try:
-                            proba = model.predict_proba(X_to_predict)
-                            confidence = float(np.max(proba[0]))
-                        except Exception as conf_err:
-                            pass
-                    
-                    predictions_by_model[model_name] = {
-                        "prediction": pred_value,
-                        "confidence": confidence
-                    }
-                except Exception as e:
-                    predictions_by_model[model_name] = {"error": str(e)}
-                    print(f"Error predicting with {model_name}: {e}")
-
-            if not valid_predictions:
-                return jsonify({
-                    "error": "No models could make predictions",
-                    "available_models": artifacts["available_models"],
-                    "predictions_by_model": predictions_by_model,
-                    "data_shape": str(X_to_predict.shape) if hasattr(X_to_predict, "shape") else "unknown"
-                }), 503
-
-            # Calculate mode (most common prediction)
-            from collections import Counter
-            # Round to nearest integer for mode calculation (for classification)
-            rounded_preds = [round(p) for p in valid_predictions]
-            pred_counts = Counter(rounded_preds)
-            mode_prediction = pred_counts.most_common(1)[0][0]
-            
-            # Calculate confidence: how many models agree with the mode
-            agreeing_models = sum(1 for p in rounded_preds if p == mode_prediction)
-            confidence_score = agreeing_models / len(valid_predictions)
-            
-            # Map prediction to human-readable label if 0/1 classification
-            pred_label = "HIGH" if mode_prediction == 1 else "LOW"
-            
-            return jsonify({
-                "symbol": symbol,
-                "mode_prediction": mode_prediction,
-                "prediction_label": pred_label,
-                "confidence": round(confidence_score, 2),
-                "agreeing_models": agreeing_models,
-                "total_models": len(valid_predictions),
-                "predictions_by_model": predictions_by_model,
-                "note": "Consensus prediction based on Marketstack historical data"
-            })
-
-        except Exception as e:
-            import traceback
-            return jsonify({
-                "error": f"Consensus prediction failed: {str(e)}",
-                "traceback": traceback.format_exc(),
-                "symbol": symbol if 'symbol' in locals() else "unknown",
-                "data_fetched": len(df) if 'df' in locals() and df is not None else 0
-            }), 400
-
-    @app.route("/predict/ensemble", methods=["POST"])
-    def predict_ensemble():
-        """Make predictions using all available models and return ensemble results"""
-        artifacts = app.config["ARTIFACTS"]
-        pipeline = artifacts["pipeline"]
-        if pipeline is None:
-            return jsonify({"error": "Pipeline not loaded"}), 503
-
-        payload = request.get_json(silent=True) or {}
-        
-        instances = []
-        if isinstance(payload.get("instances"), list):
-            instances = payload["instances"]
-        elif all(k in payload for k in RAW_FEATURES):
-            instances = [payload]
-
-        if not instances:
-            return jsonify({
-                "error": "No instances provided",
-                "expected_format": {
-                    "single": {c: "<number>" for c in RAW_FEATURES},
-                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
-                },
-                "input_columns": RAW_FEATURES,
-                "available_models": artifacts["available_models"],
-            }), 400
-
-        for i, inst in enumerate(instances):
-            missing = _validate_instance(inst)
-            if missing:
-                return jsonify({
-                    "error": f"Instance {i} missing features: {missing}",
-                    "input_columns": RAW_FEATURES
-                }), 400
-
-        try:
-            X_input = _prepare_pipeline_input(instances)
-            pipeline_can_transform = hasattr(pipeline, "transform")
-            
-            if pipeline_can_transform:
-                X_transformed = pipeline.transform(X_input)
-                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
-            else:
-                X_to_predict = X_input[-1:, :]
-
-            # Get predictions from all available models
-            predictions_by_model = {}
-            for model_name in artifacts["available_models"]:
-                model = artifacts["models"].get(model_name)
-                if model is not None:
-                    try:
-                        y_pred = model.predict(X_to_predict)
-                        pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
-                        predictions_by_model[model_name] = pred_value
-                    except Exception as e:
-                        predictions_by_model[model_name] = {"error": str(e)}
-
-            if not predictions_by_model:
-                return jsonify({"error": "No models available for prediction"}), 503
-
-            # Calculate ensemble average (exclude errors)
-            valid_predictions = [v for v in predictions_by_model.values() if isinstance(v, (int, float))]
-            ensemble_prediction = float(np.mean(valid_predictions)) if valid_predictions else None
-
-            return jsonify({
-                "model": "ensemble",
-                "input_columns": RAW_FEATURES,
-                "ensemble_prediction": ensemble_prediction,
-                "predictions_by_model": predictions_by_model,
-                "model_count": len(artifacts["available_models"]),
-                "successful_models": len([v for v in predictions_by_model.values() if isinstance(v, (int, float))]),
-                "count": 1,
-                "note": f"Ensemble prediction based on {len([v for v in predictions_by_model.values() if isinstance(v, (int, float))])} models"
-            })
-
-        except Exception as e:
-            return jsonify({"error": f"Ensemble prediction failed: {str(e)}"}), 400
-
-    @app.route("/market/data", methods=["GET"])
-    def market_data():
-        symbol = (request.args.get("symbol") or "").upper()
-        days = int(request.args.get("days", 30))
-
-        if not symbol:
-            return jsonify({"error": "Symbol required"}), 400
-
-        df = fetch_market_data(symbol, days)
-        if df is None or len(df) == 0:
-            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
-
-        data = df.to_dict(orient="records")
-        return jsonify({
-            "symbol": symbol,
-            "days": days,
-            "data_points": len(data),
-            "data": data,
-        })
-
-    def _startup():
-        try:
-            _load_artifacts()
-        except Exception as e:
-            print(f"Warning: Artifact loading failed: {e}")
-
-    with app.app_context():
-        _startup()
-
-    return app
-
-
-def fetch_market_data(symbol: str, days: int = 30) -> Optional[pd.DataFrame]:
-    try:
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=days)
-
-        url = f"{MARKETSTACK_BASE_URL}/eod"
-        params = {
-            "access_key": MARKETSTACK_API_KEY,
-            "symbols": symbol,
-            "date_from": start_date.strftime("%Y-%m-%d"),
-            "date_to": end_date.strftime("%Y-%m-%d"),
-            "limit": days,
-        }
-
-        response = requests.get(url, params=params, timeout=10)
-        if response.status_code != 200:
-            print(f"API Error: {response.status_code} - {response.text}")
-            return None
-
-        data = response.json()
-        if "data" not in data or not data["data"]:
-            print(f"No data returned for symbol: {symbol}")
-            return None
-
-        df = pd.DataFrame(data["data"])
-        df = df.rename(columns={
-            "open": "Open",
-            "high": "High",
-            "low": "Low",
-            "close": "Close",
-            "volume": "Volume",
-        })
-
-        if "date" in df.columns:
-            df["date"] = pd.to_datetime(df["date"])
-            df = df.sort_values("date")
-
-        df = df[RAW_FEATURES]
-        return df
-    except Exception as exc:
-        print(f"Error fetching market data: {exc}")
-        return None
-
-
-app = create_app()
-@app.route("/", methods=["GET"])
-def root():
-    return jsonify({
-        "status": "ok",
-        "service": API_TITLE,
-        "version": API_VERSION
-    }), 200
-
-# if __name__ == "__main__":
-#     port = int(os.environ.get("PORT", "5000"))
-#     app.run(host="0.0.0.0", port=port)
-
+import os
+import json
+import math
+from typing import List, Dict, Any, Optional
+import warnings
+warnings.filterwarnings('ignore', category=RuntimeWarning)
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+try:
+    import joblib
+except Exception:
+    joblib = None
+import pickle
+
+try:
+    import numpy as np
+    import pandas as pd
+except Exception as e:
+    print(f"Warning: NumPy/Pandas import issue: {e}")
+    import sys
+    sys.exit(1)
+
+try:
+    import torch
+    import torch.nn as nn
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    print("Warning: PyTorch not available. Deep learning models will not load.")
+
+# Import PyTorch model architectures
+if TORCH_AVAILABLE:
+    try:
+        from models import LSTMModel, GRUModel, FeedForwardNN, BiLSTMModel, CNN1DModel
+    except ImportError as e:
+        print(f"Warning: Could not import model architectures: {e}")
+        TORCH_AVAILABLE = False
+
+from datetime import datetime, timedelta
+import requests
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+
+
+API_TITLE = "ELC-V Prediction API"
+API_VERSION = "0.3.0"
+
+RAW_FEATURES = ["Open", "High", "Low", "Close", "Volume"]
+
+MARKETSTACK_API_KEY = os.environ.get("MARKETSTACK_API_KEY")
+print("\n\n\n\n\n", MARKETSTACK_API_KEY, "\n\n\n\n\n")
+MARKETSTACK_BASE_URL = "http://api.marketstack.com/v1"
+
+
+def load_artifact(path: str):
+    # Handle PyTorch models
+    if path.endswith('.pth'):
+        if not TORCH_AVAILABLE:
+            raise ImportError("PyTorch is required to load .pth files")
+        # Use weights_only=False for trusted model files
+        return torch.load(path, map_location=torch.device('cpu'), weights_only=False)
+    
+    # Handle sklearn/joblib models
+    if joblib is not None:
+        try:
+            return joblib.load(path)
+        except Exception:
+            pass
+    with open(path, "rb") as f:
+        return pickle.load(f)
+
+
+class FeatureEngineer(BaseEstimator, TransformerMixin):
+    """Sklearn-compatible feature engineering transformer."""
+    def __init__(self, lookback: int = 7):
+        self.lookback = lookback
+        self.feature_names_ = None
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        if not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X, columns=RAW_FEATURES)
+        else:
+            X = X.copy()
+
+        for col in RAW_FEATURES:
+            if col not in X.columns:
+                raise ValueError(f"Missing column: {col}")
+
+        for i in range(1, self.lookback + 1):
+            X[f'Close_lag_{i}'] = X['Close'].shift(i).fillna(X['Close'].mean())
+            X[f'Volume_lag_{i}'] = X['Volume'].shift(i).fillna(X['Volume'].mean())
+            X[f'Open_lag_{i}'] = X['Open'].shift(i).fillna(X['Open'].mean())
+            X[f'High_lag_{i}'] = X['High'].shift(i).fillna(X['High'].mean())
+            X[f'Low_lag_{i}'] = X['Low'].shift(i).fillna(X['Low'].mean())
+
+        X['returns'] = X['Close'].pct_change()
+        X['log_returns'] = np.log(X['Close'] / X['Close'].shift(1))
+
+        X['ma_7'] = X['Close'].rolling(window=7, min_periods=1).mean()
+        X['ma_14'] = X['Close'].rolling(window=14, min_periods=1).mean()
+        X['ma_30'] = X['Close'].rolling(window=30, min_periods=1).mean()
+
+        X['volatility_7'] = X['returns'].rolling(window=7, min_periods=1).std()
+        X['volatility_14'] = X['returns'].rolling(window=14, min_periods=1).std()
+
+        X['momentum_7'] = X['Close'] - X['Close'].shift(7).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
+        X['momentum_14'] = X['Close'] - X['Close'].shift(14).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
+
+        delta = X['Close'].diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=14, min_periods=1).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=14, min_periods=1).mean()
+        rs = gain / loss
+        X['rsi_14'] = 100 - (100 / (1 + rs))
+
+        X['bb_upper'] = X['ma_7'] + (X['volatility_7'] * 2)
+        X['bb_Lower'] = X['ma_7'] - (X['volatility_7'] * 2)
+        X['bb_width'] = X['bb_upper'] - X['bb_Lower']
+
+        X = X.bfill().ffill()
+        for col in X.columns:
+            if X[col].isna().any():
+                X[col] = X[col].fillna(X[col].mean() if X[col].notna().any() else 0)
+        X = X.fillna(0)
+
+        expected_order = [
+            'Close', 'Volume', 'Open', 'High', 'Low',
+            'Close_lag_1', 'Volume_lag_1', 'Open_lag_1', 'High_lag_1', 'Low_lag_1',
+            'Close_lag_2', 'Volume_lag_2', 'Open_lag_2', 'High_lag_2', 'Low_lag_2',
+            'Close_lag_3', 'Volume_lag_3', 'Open_lag_3', 'High_lag_3', 'Low_lag_3',
+            'Close_lag_4', 'Volume_lag_4', 'Open_lag_4', 'High_lag_4', 'Low_lag_4',
+            'Close_lag_5', 'Volume_lag_5', 'Open_lag_5', 'High_lag_5', 'Low_lag_5',
+            'Close_lag_6', 'Volume_lag_6', 'Open_lag_6', 'High_lag_6', 'Low_lag_6',
+            'Close_lag_7', 'Volume_lag_7', 'Open_lag_7', 'High_lag_7', 'Low_lag_7',
+            'returns', 'log_returns', 'ma_7', 'ma_14', 'ma_30',
+            'volatility_7', 'volatility_14', 'momentum_7', 'momentum_14',
+            'rsi_14', 'bb_upper', 'bb_Lower', 'bb_width'
+        ]
+        
+        for col in expected_order:
+            if col not in X.columns:
+                X[col] = 0
+        
+        X = X[expected_order]
+
+        if self.feature_names_ is None:
+            self.feature_names_ = list(X.columns)
+
+        X.columns.name = None
+        return X
+
+    def get_feature_names_out(self, input_features=None):
+        if self.feature_names_ is None:
+            dummy = pd.DataFrame(
+                np.random.randn(30, 5),
+                columns=RAW_FEATURES
+            )
+            self.transform(dummy)
+        return np.array(self.feature_names_)
+
+
+class PyTorchModelWrapper:
+    """Wrapper to make PyTorch models compatible with sklearn pipeline API."""
+    def __init__(self, model):
+        self.model = model
+        if TORCH_AVAILABLE:
+            self.model.eval()  # Set to evaluation mode
+    
+    def predict(self, X):
+        if not TORCH_AVAILABLE:
+            raise ImportError("PyTorch is required for this model")
+        
+        # Convert to numpy if DataFrame
+        if isinstance(X, pd.DataFrame):
+            X = X.values
+        
+        # Convert to torch tensor
+        X_tensor = torch.FloatTensor(X)
+        
+        # Make prediction
+        with torch.no_grad():
+            output = self.model(X_tensor)
+            # Handle different output formats
+            if isinstance(output, torch.Tensor):
+                predictions = output.cpu().numpy()
+                # If output is probabilities (2 classes), take class with higher prob
+                if predictions.shape[-1] == 2:
+                    predictions = predictions.argmax(axis=-1)
+                # Flatten if needed
+                if len(predictions.shape) > 1 and predictions.shape[-1] == 1:
+                    predictions = predictions.flatten()
+            else:
+                predictions = output
+        
+        return predictions
+
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "static", "models")
+
+
+def create_app() -> Flask:
+    app = Flask(__name__)
+    CORS(app, resources={
+        r"/*": {
+            "origins": ["http://localhost:3000", "http://127.0.0.1:3000"],
+            "methods": ["GET", "POST", "OPTIONS"],
+            "allow_headers": ["Content-Type"],
+        }
+    })
+
+    app.config["ARTIFACTS"] = {
+        "pipeline": None,
+        "models": {
+            # Tree/linear/boosting models
+            "random_forest": None,
+            "adaboost": None,
+            "extra_trees": None,
+            "gradient_boosting": None,
+            "xgboost": None,
+            "lightgbm": None,
+            "catboost": None,
+            "svm": None,
+            "logistic_regression": None,
+            "knn": None,
+            "best_ensemble": None,
+            "best_individual": None,
+
+            # Deep learning models (can remain unavailable if PyTorch not installed)
+            "lstm": None,
+            "bilstm": None,
+            "gru": None,
+            "1d_cnn": None,
+            "feed_forward_nn": None,
+
+            # Convenience entries for API defaults
+            "ensemble": None,
+            "individual": None,
+        },
+        "summary": None,
+        "scaler": None,
+        "available_models": [],
+    }
+
+    def _artifact_path(name: str) -> str:
+        return os.path.join(MODELS_DIR, name)
+
+    def _load_artifacts() -> Dict[str, Any]:
+        artifacts = app.config["ARTIFACTS"]
+        try:
+            engineer = FeatureEngineer(lookback=7)
+
+            # Load the pipeline with scaler
+            pipeline_path = _artifact_path("random_forest_pipeline.joblib")
+            if os.path.exists(pipeline_path):
+                saved_pipeline = load_artifact(pipeline_path)
+                artifacts["pipeline"] = Pipeline([
+                    ('features', engineer),
+                    ('saved_pipeline', saved_pipeline),
+                ])
+            else:
+                scaler_path = _artifact_path("random_forest_scaler.joblib")
+                scaler = None
+                if os.path.exists(scaler_path):
+                    scaler = load_artifact(scaler_path)
+
+                if scaler is not None:
+                    artifacts["pipeline"] = Pipeline([
+                        ('features', engineer),
+                        ('scaler', scaler),
+                    ])
+                else:
+                    artifacts["pipeline"] = Pipeline([
+                        ('features', engineer),
+                    ])
+
+            # Load individual models (ML first, DL optional)
+            model_mappings = {
+                # Primary models
+                "random_forest": "random_forest.pkl",
+                "adaboost": "adaboost.pkl",
+                "extra_trees": "extra_trees.pkl",
+                "gradient_boosting": "gradient_boosting.pkl",
+                "xgboost": "xgboost.pkl",
+                "lightgbm": "lightgbm.pkl",
+                "catboost": "catboost.pkl",
+                "svm": "svm.pkl",
+                "logistic_regression": "logistic_regression.pkl",
+                "knn": "knn.pkl",
+                "best_ensemble": "best_ensemble_package.pkl",  # Fixed filename
+                "best_individual": "best_individual_model.pkl",
+
+                # Deep learning models (load only if PyTorch available)
+                "lstm": "lstm.pth",
+                "bilstm": "bilstm.pth",
+                "gru": "gru.pth",
+                "1d_cnn": "1d-cnn.pth",
+                "feed_forward_nn": "feed-forward_nn.pth",
+            }
+
+            loaded_models = []
+            for model_name, model_file in model_mappings.items():
+                model_path = _artifact_path(model_file)
+                if os.path.exists(model_path):
+                    try:
+                        loaded = load_artifact(model_path)
+                        # Skip if it's a dict (training metadata) or doesn't have predict method
+                        if isinstance(loaded, dict):
+                            print(f"Skipped {model_name}: loaded as dict (metadata)")
+                            continue
+                        if not hasattr(loaded, 'predict'):
+                            print(f"Skipped {model_name}: no predict method")
+                            continue
+                        # Wrap PyTorch models
+                        if model_file.endswith('.pth') and TORCH_AVAILABLE:
+                            loaded = PyTorchModelWrapper(loaded)
+                        artifacts["models"][model_name] = loaded
+                        loaded_models.append(model_name)
+                        print(f"Loaded model: {model_name}")
+                    except Exception as e:
+                        print(f"Failed to load {model_name}: {e}")
+                else:
+                    print(f"Model file not found: {model_file}")
+
+            artifacts["available_models"] = loaded_models
+
+            # Set defaults: prefer saved best ensemble/individual, then random forest, then first available
+            ensemble_default = artifacts["models"].get("best_ensemble") or artifacts["models"].get("random_forest")
+            individual_default = artifacts["models"].get("best_individual") or artifacts["models"].get("random_forest")
+
+            if ensemble_default is None and loaded_models:
+                ensemble_default = artifacts["models"].get(loaded_models[0])
+            if individual_default is None and loaded_models:
+                individual_default = artifacts["models"].get(loaded_models[0])
+
+            artifacts["models"]["ensemble"] = ensemble_default
+            artifacts["models"]["individual"] = individual_default
+
+            summary_path = _artifact_path("results_summary.pkl")
+            if os.path.exists(summary_path):
+                artifacts["summary"] = load_artifact(summary_path)
+        except Exception as e:
+            artifacts["summary"] = {"error": f"Failed to load artifacts: {e}"}
+
+        return artifacts
+
+    def _validate_instance(instance: Dict[str, Any]) -> List[str]:
+        return [k for k in RAW_FEATURES if k not in instance]
+
+    def _prepare_pipeline_input(instances: List[Dict[str, Any]]) -> pd.DataFrame:
+        data = []
+        for inst in instances:
+            row = {col: inst[col] for col in RAW_FEATURES}
+            data.append(row)
+        return pd.DataFrame(data)
+
+    @app.route("/health", methods=["GET"])
+    def health():
+        artifacts = app.config["ARTIFACTS"]
+        status = {
+            "title": API_TITLE,
+            "version": API_VERSION,
+            "pipeline": artifacts["pipeline"] is not None,
+            "available_models": artifacts["available_models"],
+            "models": {k: artifacts["models"][k] is not None for k in artifacts["models"]},
+            "model_count": len([m for m in artifacts["models"].values() if m is not None]),
+        }
+        has_models = any([m for m in artifacts["models"].values() if m is not None])
+        http_code = 200 if has_models else 503
+        return jsonify(status), http_code
+
+    @app.route("/metadata", methods=["GET"])
+    def metadata():
+        artifacts = app.config["ARTIFACTS"]
+        summary = artifacts.get("summary")
+        try:
+            def _to_jsonable(obj):
+                try:
+                    json.dumps(obj)
+                    return obj
+                except TypeError:
+                    return str(obj)
+
+            if isinstance(summary, dict):
+                return jsonify({k: _to_jsonable(v) for k, v in summary.items()})
+            return jsonify({"summary": _to_jsonable(summary)})
+        except Exception:
+            return jsonify({"summary": "unavailable"})
+
+    @app.route("/predict", methods=["POST"])
+    def predict():
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        models_loaded = any(artifacts["models"].values())
+        pipeline_can_predict = hasattr(pipeline, "predict")
+        if not models_loaded and not pipeline_can_predict:
+            return jsonify({"error": "Models not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        model_choice = (payload.get("model") or "random_forest").lower()
+        return_all = bool(payload.get("all_models"))
+        
+        # Try to get the requested model
+        model = artifacts["models"].get(model_choice)
+        
+        # Fallback to ensemble, then individual, then first available
+        if model is None:
+            if artifacts["models"].get("ensemble"):
+                model = artifacts["models"]["ensemble"]
+            elif artifacts["models"].get("individual"):
+                model = artifacts["models"]["individual"]
+            elif artifacts["available_models"]:
+                model = artifacts["models"][artifacts["available_models"][0]]
+
+        if model is None:
+            return jsonify({
+                "error": f"Requested model '{model_choice}' not available",
+                "available_models": artifacts["available_models"]
+            }), 400
+
+        instances = []
+        if isinstance(payload.get("instances"), list):
+            instances = payload["instances"]
+        elif all(k in payload for k in RAW_FEATURES):
+            instances = [payload]
+
+        if not instances:
+            return jsonify({
+                "error": "No instances provided",
+                "expected_format": {
+                    "single": {c: "<number>" for c in RAW_FEATURES},
+                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
+                },
+                "input_columns": RAW_FEATURES,
+                "available_models": artifacts["available_models"],
+                "note": "For best results, provide at least 7 rows of history for lagged features"
+            }), 400
+
+        for i, inst in enumerate(instances):
+            missing = _validate_instance(inst)
+            if missing:
+                return jsonify({
+                    "error": f"Instance {i} missing features: {missing}",
+                    "input_columns": RAW_FEATURES
+                }), 400
+
+        try:
+            X_input = _prepare_pipeline_input(instances)
+            pipeline_can_transform = hasattr(pipeline, "transform")
+
+            # Prepare transformed features once
+            if pipeline_can_transform:
+                X_transformed = pipeline.transform(X_input)
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+            else:
+                X_to_predict = X_input[-1:, :]
+
+            # Main prediction using requested/fallback model
+            if pipeline_can_predict:
+                y_all = pipeline.predict(X_input)
+                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
+            elif model is not None:
+                y_pred = model.predict(X_to_predict)
+            else:
+                return jsonify({"error": "Pipeline cannot process data"}), 503
+
+            # Optional per-model predictions
+            predictions_by_model = None
+            if return_all:
+                predictions_by_model = {}
+                for m_name in artifacts["available_models"]:
+                    m = artifacts["models"].get(m_name)
+                    if m is None:
+                        continue
+                    try:
+                        y_m = m.predict(X_to_predict)
+                        pred_val = float(y_m[0].item() if hasattr(y_m[0], "item") else y_m[0])
+                        predictions_by_model[m_name] = pred_val
+                    except Exception as e:
+                        predictions_by_model[m_name] = {"error": str(e)}
+
+            response = {
+                "model": model_choice,
+                "input_columns": RAW_FEATURES,
+                "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
+                "count": len(y_pred),
+                "available_models": artifacts["available_models"],
+                "note": f"Processed {len(instances)} input row(s), predicted on last row"
+            }
+
+            if predictions_by_model is not None:
+                response["predictions_by_model"] = predictions_by_model
+
+            return jsonify(response)
+        except Exception as e:
+            return jsonify({"error": f"Pipeline failed: {str(e)}"}), 400
+
+    @app.route("/predict/symbol", methods=["POST"])
+    def predict_symbol():
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        pipeline_can_transform = hasattr(pipeline, "transform")
+        pipeline_can_predict = hasattr(pipeline, "predict")
+
+        payload = request.get_json(silent=True) or {}
+        symbol = (payload.get("symbol") or "").upper()
+        days = int(payload.get("days", 30))
+        model_choice = (payload.get("model") or "random_forest").lower()
+
+        model = artifacts["models"].get(model_choice)
+        if model is None:
+            if artifacts["models"].get("ensemble"):
+                model = artifacts["models"]["ensemble"]
+            elif artifacts["models"].get("individual"):
+                model = artifacts["models"]["individual"]
+            elif artifacts["available_models"]:
+                model = artifacts["models"][artifacts["available_models"][0]]
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        try:
+            if pipeline_can_predict:
+                y_all = pipeline.predict(df)
+                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
+            elif pipeline_can_transform and model is not None:
+                # Create feature engineer to transform raw OHLCV data
+                engineer = FeatureEngineer(lookback=7)
+                print(f"[DEBUG] Input df shape: {df.shape}")
+                X_engineered = engineer.fit_transform(df)
+                print(f"[DEBUG] Engineered shape: {X_engineered.shape}, type: {type(X_engineered)}")
+                
+                # Get the last row for prediction
+                if isinstance(X_engineered, pd.DataFrame):
+                    X_last_row = X_engineered.iloc[-1:].values
+                else:
+                    # Ensure it's a numpy array and 2D
+                    X_engineered = np.array(X_engineered)
+                    if X_engineered.ndim == 1:
+                        X_last_row = X_engineered.reshape(1, -1)
+                    else:
+                        X_last_row = X_engineered[-1:]
+                
+                # Apply scaler if available
+                if hasattr(pipeline, "named_steps") and pipeline.named_steps.get("scaler"):
+                    X_to_predict = pipeline.named_steps["scaler"].transform(X_last_row)
+                else:
+                    X_to_predict = X_last_row
+                    
+                y_pred = model.predict(X_to_predict)
+            else:
+                return jsonify({"error": "Pipeline cannot process data"}), 503
+        except Exception as e:
+            import traceback
+            return jsonify({
+                "error": f"Prediction failed: {str(e)}",
+                "traceback": traceback.format_exc()
+            }), 500
+
+        pred_scalar = y_pred[-1] if hasattr(y_pred, "__len__") else y_pred
+        try:
+            pred_scalar = float(getattr(pred_scalar, "item", lambda: pred_scalar)())
+        except Exception:
+            pred_scalar = float(pred_scalar)
+
+        proba_val = None
+        if hasattr(pipeline, "predict_proba"):
+            try:
+                p_all = pipeline.predict_proba(df)
+                p_last = p_all[-1] if len(p_all) > 1 else p_all[0]
+                proba_val = float(max(p_last))
+            except Exception:
+                pass
+        elif model is not None and hasattr(model, "predict_proba"):
+            try:
+                X_transformed = pipeline.transform(df) if pipeline_can_transform else df
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+                p = model.predict_proba(X_to_predict)
+                proba_val = float(max(p[0]))
+            except Exception:
+                pass
+
+        if proba_val is None or (isinstance(proba_val, float) and math.isnan(proba_val)):
+            proba_val = 1.0 if pred_scalar in (0.0, 1.0) else 0.5
+
+        latest = df.iloc[-1].to_dict()
+        return jsonify({
+            "symbol": symbol,
+            "data_points": len(df),
+            "latest_data": latest,
+            "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
+            "count": len(y_pred),
+            "predicted_price": pred_scalar,
+            "confidence": proba_val,
+            "model": model_choice,
+            "available_models": artifacts["available_models"],
+            "note": "Prediction based on Marketstack historical data"
+        })
+
+    @app.route("/predict/consensus", methods=["POST"])
+    def predict_consensus():
+        """Get consensus (mode) prediction from all models with individual model details for a symbol"""
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        symbol = (payload.get("symbol") or "").upper()
+        days = int(payload.get("days", 30))
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        # Fetch market data for the symbol
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        try:
+            # Create feature engineer to transform raw OHLCV data
+            engineer = FeatureEngineer(lookback=7)
+            
+            # Transform raw market data to engineered features
+            X_engineered = engineer.fit_transform(df)
+            print(f"Engineered features shape (before conversion): {X_engineered.shape}")
+            
+            # Get the last row for prediction
+            if isinstance(X_engineered, pd.DataFrame):
+                X_last_row = X_engineered.iloc[-1:].values
+            else:
+                # Ensure it's a numpy array and 2D
+                X_engineered = np.array(X_engineered)
+                if X_engineered.ndim == 1:
+                    X_last_row = X_engineered.reshape(1, -1)
+                else:
+                    X_last_row = X_engineered[-1:]
+            
+            print(f"Last row shape for prediction: {X_last_row.shape}")
+            
+            # Then apply scaler from pipeline if available
+            pipeline_can_transform = hasattr(pipeline, "transform")
+            if pipeline_can_transform:
+                # Use the scaler/preprocessing from the pipeline
+                try:
+                    # Get the scaler step from pipeline
+                    scaler = None
+                    if hasattr(pipeline, "named_steps"):
+                        scaler = pipeline.named_steps.get("scaler")
+                    
+                    if scaler is not None:
+                        X_to_predict = scaler.transform(X_last_row)
+                    else:
+                        X_to_predict = X_last_row
+                except Exception as e:
+                    print(f"Scaler error: {e}")
+                    X_to_predict = X_last_row
+            else:
+                X_to_predict = X_last_row
+
+            # Get predictions from all available models with confidence
+            predictions_by_model = {}
+            valid_predictions = []
+            
+            if not artifacts["available_models"]:
+                return jsonify({
+                    "error": "No models available for prediction",
+                    "debug": "available_models is empty"
+                }), 503
+            
+            for model_name in artifacts["available_models"]:
+                model = artifacts["models"].get(model_name)
+                if model is None:
+                    predictions_by_model[model_name] = {"error": "Model not found"}
+                    continue
+                    
+                try:
+                    y_pred = model.predict(X_to_predict)
+                    pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
+                    valid_predictions.append(pred_value)
+                    
+                    # Try to get confidence/probability
+                    confidence = None
+                    if hasattr(model, "predict_proba"):
+                        try:
+                            proba = model.predict_proba(X_to_predict)
+                            confidence = float(np.max(proba[0]))
+                        except Exception as conf_err:
+                            pass
+                    
+                    predictions_by_model[model_name] = {
+                        "prediction": pred_value,
+                        "confidence": confidence
+                    }
+                except Exception as e:
+                    predictions_by_model[model_name] = {"error": str(e)}
+                    print(f"Error predicting with {model_name}: {e}")
+
+            if not valid_predictions:
+                return jsonify({
+                    "error": "No models could make predictions",
+                    "available_models": artifacts["available_models"],
+                    "predictions_by_model": predictions_by_model,
+                    "data_shape": str(X_to_predict.shape) if hasattr(X_to_predict, "shape") else "unknown"
+                }), 503
+
+            # Calculate mode (most common prediction)
+            from collections import Counter
+            # Round to nearest integer for mode calculation (for classification)
+            rounded_preds = [round(p) for p in valid_predictions]
+            pred_counts = Counter(rounded_preds)
+            mode_prediction = pred_counts.most_common(1)[0][0]
+            
+            # Calculate confidence: how many models agree with the mode
+            agreeing_models = sum(1 for p in rounded_preds if p == mode_prediction)
+            confidence_score = agreeing_models / len(valid_predictions)
+            
+            # Map prediction to human-readable label if 0/1 classification
+            pred_label = "HIGH" if mode_prediction == 1 else "LOW"
+            
+            return jsonify({
+                "symbol": symbol,
+                "mode_prediction": mode_prediction,
+                "prediction_label": pred_label,
+                "confidence": round(confidence_score, 2),
+                "agreeing_models": agreeing_models,
+                "total_models": len(valid_predictions),
+                "predictions_by_model": predictions_by_model,
+                "note": "Consensus prediction based on Marketstack historical data"
+            })
+
+        except Exception as e:
+            import traceback
+            return jsonify({
+                "error": f"Consensus prediction failed: {str(e)}",
+                "traceback": traceback.format_exc(),
+                "symbol": symbol if 'symbol' in locals() else "unknown",
+                "data_fetched": len(df) if 'df' in locals() and df is not None else 0
+            }), 400
+
+    @app.route("/predict/ensemble", methods=["POST"])
+    def predict_ensemble():
+        """Make predictions using all available models and return ensemble results"""
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        
+        instances = []
+        if isinstance(payload.get("instances"), list):
+            instances = payload["instances"]
+        elif all(k in payload for k in RAW_FEATURES):
+            instances = [payload]
+
+        if not instances:
+            return jsonify({
+                "error": "No instances provided",
+                "expected_format": {
+                    "single": {c: "<number>" for c in RAW_FEATURES},
+                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
+                },
+                "input_columns": RAW_FEATURES,
+                "available_models": artifacts["available_models"],
+            }), 400
+
+        for i, inst in enumerate(instances):
+            missing = _validate_instance(inst)
+            if missing:
+                return jsonify({
+                    "error": f"Instance {i} missing features: {missing}",
+                    "input_columns": RAW_FEATURES
+                }), 400
+
+        try:
+            X_input = _prepare_pipeline_input(instances)
+            pipeline_can_transform = hasattr(pipeline, "transform")
+            
+            if pipeline_can_transform:
+                X_transformed = pipeline.transform(X_input)
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+            else:
+                X_to_predict = X_input[-1:, :]
+
+            # Get predictions from all available models
+            predictions_by_model = {}
+            for model_name in artifacts["available_models"]:
+                model = artifacts["models"].get(model_name)
+                if model is not None:
+                    try:
+                        y_pred = model.predict(X_to_predict)
+                        pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
+                        predictions_by_model[model_name] = pred_value
+                    except Exception as e:
+                        predictions_by_model[model_name] = {"error": str(e)}
+
+            if not predictions_by_model:
+                return jsonify({"error": "No models available for prediction"}), 503
+
+            # Calculate ensemble average (exclude errors)
+            valid_predictions = [v for v in predictions_by_model.values() if isinstance(v, (int, float))]
+            ensemble_prediction = float(np.mean(valid_predictions)) if valid_predictions else None
+
+            return jsonify({
+                "model": "ensemble",
+                "input_columns": RAW_FEATURES,
+                "ensemble_prediction": ensemble_prediction,
+                "predictions_by_model": predictions_by_model,
+                "model_count": len(artifacts["available_models"]),
+                "successful_models": len([v for v in predictions_by_model.values() if isinstance(v, (int, float))]),
+                "count": 1,
+                "note": f"Ensemble prediction based on {len([v for v in predictions_by_model.values() if isinstance(v, (int, float))])} models"
+            })
+
+        except Exception as e:
+            return jsonify({"error": f"Ensemble prediction failed: {str(e)}"}), 400
+
+    @app.route("/market/data", methods=["GET"])
+    def market_data():
+        symbol = (request.args.get("symbol") or "").upper()
+        days = int(request.args.get("days", 30))
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        data = df.to_dict(orient="records")
+        return jsonify({
+            "symbol": symbol,
+            "days": days,
+            "data_points": len(data),
+            "data": data,
+        })
+
+    def _startup():
+        try:
+            _load_artifacts()
+        except Exception as e:
+            print(f"Warning: Artifact loading failed: {e}")
+
+    with app.app_context():
+        _startup()
+
+    return app
+
+
+def fetch_market_data(symbol: str, days: int = 30) -> Optional[pd.DataFrame]:
+    try:
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days)
+
+        url = f"{MARKETSTACK_BASE_URL}/eod"
+        params = {
+            "access_key": MARKETSTACK_API_KEY,
+            "symbols": symbol,
+            "date_from": start_date.strftime("%Y-%m-%d"),
+            "date_to": end_date.strftime("%Y-%m-%d"),
+            "limit": days,
+        }
+
+        response = requests.get(url, params=params, timeout=10)
+        if response.status_code != 200:
+            print(f"API Error: {response.status_code} - {response.text}")
+            return None
+
+        data = response.json()
+        if "data" not in data or not data["data"]:
+            print(f"No data returned for symbol: {symbol}")
+            return None
+
+        df = pd.DataFrame(data["data"])
+        df = df.rename(columns={
+            "open": "Open",
+            "high": "High",
+            "low": "Low",
+            "close": "Close",
+            "volume": "Volume",
+        })
+
+        if "date" in df.columns:
+            df["date"] = pd.to_datetime(df["date"])
+            df = df.sort_values("date")
+
+        df = df[RAW_FEATURES]
+        return df
+    except Exception as exc:
+        print(f"Error fetching market data: {exc}")
+        return None
+
+
+app = create_app()
+@app.route("/", methods=["GET"])
+def root():
+    return jsonify({
+        "status": "ok",
+        "service": API_TITLE,
+        "version": API_VERSION
+    }), 200
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", "5000"))
+    app.run(host="0.0.0.0", port=port)
+