model.py

import yfinance as yf
import pandas as pd
import ta
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, r2_score
import xgboost as xgb
from catboost import CatBoostRegressor
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from sklearn.preprocessing import MinMaxScaler
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.tsa.statespace.sarimax import SARIMAX


from logger import get_logger

logger = get_logger(__name__)
# logger.setLevel(logging.DEBUG)
# handler = logging.StreamHandler()
# handler.setLevel(logging.DEBUG)
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# handler.setFormatter(formatter)
# logger.addHandler(handler)

# # Example usage of logger
# logger.info("This is an info message")

# Fetch historical data
def fetch_data(ticker, start_date, end_date):
    logger.info(f"Fetching data for {ticker} from {start_date} to {end_date}")
    data = yf.download(ticker, start=start_date, end=end_date)
    if data.empty:
        logger.warning(f"No data returned for {ticker}.")
        return None
    
    # Reset index to ensure Date is a column
    data.reset_index(inplace=True)
    logger.info(f"Data fetched successfully for {ticker}.")
    return data

def calculate_indicators(data: pd.DataFrame) -> pd.DataFrame:
    logger.info("Calculating indicators with fixed parameters.")
    
    # Check if required columns are present
    required_columns = ['Close', 'High', 'Low', 'Volume']
    missing_columns = [col for col in required_columns if col not in data.columns]
    if missing_columns:
        logger.error(f"Missing columns in data: {', '.join(missing_columns)}")
        raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
    # Calculate fixed moving averages
    ma_period = 50  # Fixed period for moving averages
    try:
        data[f'SMA_{ma_period}'] = data['Close'].rolling(window=ma_period).mean()
        data[f'EMA_{ma_period}'] = data['Close'].ewm(span=ma_period, adjust=False).mean()
    except Exception as e:
        logger.error(f"Error calculating moving averages: {e}")
        raise
    
    # Calculate other indicators
    try:
        data['RSI'] = ta.momentum.RSIIndicator(data['Close']).rsi()
        macd = ta.trend.MACD(data['Close'])
        data['MACD'] = macd.macd()
        data['MACD_Signal'] = macd.macd_signal()
        bollinger = ta.volatility.BollingerBands(data['Close'])
        data['Bollinger_High'] = bollinger.bollinger_hband()
        data['Bollinger_Low'] = bollinger.bollinger_lband()
        data['ATR'] = ta.volatility.AverageTrueRange(data['High'], data['Low'], data['Close']).average_true_range()
        data['OBV'] = ta.volume.OnBalanceVolumeIndicator(data['Close'], data['Volume']).on_balance_volume()
    except Exception as e:
        logger.error(f"Error calculating other indicators: {e}")
        raise
    
    # Debugging line to check the columns
    logger.debug("Columns after calculating indicators: %s", data.columns)
    
    data = data.dropna()
    logger.info("Indicators calculated successfully.")
    return data


# def calculate_indicators(data: pd.DataFrame, ma_type='SMA', ma_period=50) -> pd.DataFrame:
#     logger.info(f"Calculating indicators with {ma_type} of period {ma_period}.")
    
#     # Check if required columns are present
#     required_columns = ['Close', 'High', 'Low', 'Volume']
#     missing_columns = [col for col in required_columns if col not in data.columns]
#     if missing_columns:
#         logger.error(f"Missing columns in data: {', '.join(missing_columns)}")
#         raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
#     # Calculate moving averages
#     if ma_type == 'SMA':
#         data[f'SMA_{ma_period}'] = data['Close'].rolling(window=ma_period).mean()
#     elif ma_type == 'EMA':
#         data[f'EMA_{ma_period}'] = data['Close'].ewm(span=ma_period, adjust=False).mean()
#     else:
#         logger.error(f"Unknown moving average type: {ma_type}")
#         raise ValueError(f"Unknown moving average type: {ma_type}")
    
#     # Calculate other indicators
#     try:
#         data['RSI'] = ta.momentum.RSIIndicator(data['Close']).rsi()
#         macd = ta.trend.MACD(data['Close'])
#         data['MACD'] = macd.macd()
#         data['MACD_Signal'] = macd.macd_signal()
#         bollinger = ta.volatility.BollingerBands(data['Close'])
#         data['Bollinger_High'] = bollinger.bollinger_hband()
#         data['Bollinger_Low'] = bollinger.bollinger_lband()
#         data['ATR'] = ta.volatility.AverageTrueRange(data['High'], data['Low'], data['Close']).average_true_range()
#         data['OBV'] = ta.volume.OnBalanceVolumeIndicator(data['Close'], data['Volume']).on_balance_volume()
#     except Exception as e:
#         logger.error(f"Error calculating indicators: {e}")
#         raise
    
    # Debugging line to check the columns
    logger.debug("Columns after calculating indicators: %s", data.columns)
    
    data = data.dropna()
    logger.info("Indicators calculated successfully.")
    return data


# # Calculate technical indicators
# def calculate_indicators(data, ma_type='SMA', ma_period=50):
#     logger.info(f"Calculating indicators with {ma_type} of period {ma_period}.")
    
#     if ma_type == 'SMA':
#         data[f'SMA_{ma_period}'] = data['Close'].rolling(window=ma_period).mean()
#     elif ma_type == 'EMA':
#         data[f'EMA_{ma_period}'] = data['Close'].ewm(span=ma_period, adjust=False).mean()
    
#     data['RSI'] = ta.momentum.RSIIndicator(data['Close']).rsi()
#     macd = ta.trend.MACD(data['Close'])
#     data['MACD'] = macd.macd()
#     data['MACD_Signal'] = macd.macd_signal()
#     bollinger = ta.volatility.BollingerBands(data['Close'])
#     data['Bollinger_High'] = bollinger.bollinger_hband()
#     data['Bollinger_Low'] = bollinger.bollinger_lband()
#     data['ATR'] = ta.volatility.AverageTrueRange(data['High'], data['Low'], data['Close']).average_true_range()
#     data['OBV'] = ta.volume.OnBalanceVolumeIndicator(data['Close'], data['Volume']).on_balance_volume()
    
#     # Debugging line to check the columns
#     logger.debug("Columns after calculating indicators: %s", data.columns)
    
#     data = data.dropna()
#     logger.info("Indicators calculated successfully.")
#     return data

# Calculate support and resistance levels
def calculate_support_resistance(data, window=30):
    logger.info(f"Calculating support and resistance with a window of {window}.")
    
    recent_data = data.tail(window)
    rolling_max = data['Close'].rolling(window=window).max()
    rolling_min = data['Close'].rolling(window=window).min()
    recent_max = recent_data['Close'].max()
    recent_min = recent_data['Close'].min()
    
    support = min(rolling_min.iloc[-1], recent_min)
    resistance = max(rolling_max.iloc[-1], recent_max)
    
    logger.debug("Support: %f, Resistance: %f", support, resistance)
    return support, resistance

# Prepare data for LSTM model
def prepare_lstm_data(data):
    logger.info("Preparing data for LSTM model.")
    
    features = data[['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']].values
    target = data['Close'].values
    scaler = MinMaxScaler()
    features = scaler.fit_transform(features)
    
    X, y = [], []
    for i in range(len(features) - 60):
        X.append(features[i:i+60])
        y.append(target[i+60])
        
    logger.info("Data preparation for LSTM completed.")
    return np.array(X), np.array(y)


def predict_future_prices(data, algorithm, days=10):
    logger.info(f"Predicting future prices using {algorithm}.")
    
    # Check if required columns are present
    required_columns = ['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']
    missing_columns = [col for col in required_columns if col not in data.columns]
    
    if missing_columns:
        logger.error("Missing columns in data: %s", ', '.join(missing_columns))
        raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
    features = data[required_columns]
    target = data['Close']
    
    X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)
    
    mae, r2 = None, None  # Initialize variables for metrics
    
    if algorithm == 'Linear Regression':
        model = LinearRegression()
        
    elif algorithm == 'Decision Tree':
        model = DecisionTreeRegressor()
        
    elif algorithm == 'Random Forest':
        model = RandomForestRegressor(n_estimators=100)
        
    elif algorithm == 'XGBoost':
        model = xgb.XGBRegressor(objective='reg:squarederror', eval_metric='rmse')
        
    elif algorithm == 'CatBoost':
        model = CatBoostRegressor(learning_rate=0.1, depth=6, iterations=500, verbose=0)
        
    elif algorithm == 'LSTM':
        X, y = prepare_lstm_data(data)
        model = Sequential()
        model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1], X.shape[2])))
        model.add(LSTM(50))
        model.add(Dense(1))
        model.compile(optimizer='adam', loss='mean_squared_error')
        model.fit(X, y, epochs=10, batch_size=32, verbose=0)
        last_data_point = np.expand_dims(X[-1], axis=0)
        future_prices = [model.predict(last_data_point)[0][0] for _ in range(days)]
        logger.info("Future prices predicted using LSTM model.")
        return future_prices, None, None, None, None
        
    elif algorithm == 'ARIMA':
        model = ARIMA(data['Close'], order=(5, 1, 0))
        model_fit = model.fit()
        future_prices = model_fit.forecast(steps=days)
        
    elif algorithm == 'SARIMA':
        model = SARIMAX(data['Close'], order=(5, 1, 0), seasonal_order=(1, 1, 0, 12))
        model_fit = model.fit()
        future_prices = model_fit.forecast(steps=days)
        
    else:
        logger.error("Algorithm not recognized: %s", algorithm)
        return None, None, None, None, None

    if algorithm in ['Linear Regression', 'Decision Tree', 'Random Forest', 'XGBoost', 'CatBoost']:
        model.fit(X_train, y_train)
        predictions = model.predict(X_test)
        mae = mean_absolute_error(y_test, predictions)
        r2 = r2_score(y_test, predictions)
        
        future_prices = []
        last_data_point = features.iloc[-1].values.reshape(1, -1)  # Ensure it's 2D
        
        for _ in range(days):
            future_price = model.predict(last_data_point)[0]
            future_prices.append(future_price)
            last_data_point = last_data_point + 1  # Update last data point (simplified, better methods should be used)
        
    logger.info("Future prices predicted using %s model.", algorithm)
    return future_prices, mae, r2, None, None



# def predict_future_prices(data, algorithm, days=10):
#     logger.info(f"Predicting future prices using {algorithm}.")
    
#     # Check if required columns are present
#     required_columns = ['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']
#     missing_columns = [col for col in required_columns if col not in data.columns]
    
#     if missing_columns:
#         logger.error("Missing columns in data: %s", ', '.join(missing_columns))
#         raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
#     features = data[required_columns]
#     target = data['Close']
    
#     X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)
    
#     if algorithm == 'Linear Regression':
#         model = LinearRegression()
        
#     elif algorithm == 'Decision Tree':
#         model = DecisionTreeRegressor()
        
#     elif algorithm == 'Random Forest':
#         model = RandomForestRegressor(n_estimators=100)
        
#     elif algorithm == 'XGBoost':
#         model = xgb.XGBRegressor(objective='reg:squarederror', eval_metric='rmse')
        
#     elif algorithm == 'CatBoost':
#         model = CatBoostRegressor(learning_rate=0.1, depth=6, iterations=500, verbose=0)
        
#     elif algorithm == 'LSTM':
#         X, y = prepare_lstm_data(data)
#         model = Sequential()
#         model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1], X.shape[2])))
#         model.add(LSTM(50))
#         model.add(Dense(1))
#         model.compile(optimizer='adam', loss='mean_squared_error')
#         model.fit(X, y, epochs=10, batch_size=32, verbose=0)
#         last_data_point = np.expand_dims(X[-1], axis=0)
#         future_prices = [model.predict(last_data_point)[0][0] for _ in range(days)]
#         logger.info("Future prices predicted using LSTM model.")
#         return future_prices, None, None, None, None
        
#     elif algorithm == 'ARIMA':
#         model = ARIMA(data['Close'], order=(5, 1, 0))
#         model_fit = model.fit()
#         future_prices = model_fit.forecast(steps=days)
        
#     elif algorithm == 'SARIMA':
#         model = SARIMAX(data['Close'], order=(5, 1, 0), seasonal_order=(1, 1, 0, 12))
#         model_fit = model.fit()
#         future_prices = model_fit.forecast(steps=days)
        
#     else:
#         logger.error("Algorithm not recognized: %s", algorithm)
#         return None, None, None, None, None

#     if algorithm in ['Linear Regression', 'Decision Tree', 'Random Forest', 'XGBoost', 'CatBoost']:
#         model.fit(X_train, y_train)
#         predictions = model.predict(X_test)
#         mae = mean_absolute_error(y_test, predictions)
#         r2 = r2_score(y_test, predictions)
        
#         future_prices = []
#         last_data_point = features.iloc[-1].values.reshape(1, -1)  # Ensure it's 2D
        
#         for _ in range(days):
#             future_price = model.predict(last_data_point)[0]
#             future_prices.append(future_price)
#             last_data_point = last_data_point + 1  # Update last data point (simplified, better methods should be used)
        
#     logger.info("Future prices predicted using %s model.", algorithm)
#     return future_prices, mae, r2, None, None












# # Predict future prices using the selected algorithm
# def predict_future_prices(data, algorithm, days=10):
#     logger.info(f"Predicting future prices using {algorithm}.")
    
#     # Check if required columns are present
#     required_columns = ['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']
#     missing_columns = [col for col in required_columns if col not in data.columns]
    
#     if missing_columns:
#         logger.error("Missing columns in data: %s", ', '.join(missing_columns))
#         raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
#     features = data[required_columns]
#     target = data['Close']
    
#     X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)
    
#     if algorithm == 'Linear Regression':
#         model = LinearRegression()
#     elif algorithm == 'Decision Tree':
#         model = DecisionTreeRegressor()
#     elif algorithm == 'Random Forest':
#         model = RandomForestRegressor(n_estimators=100)
#     elif algorithm == 'XGBoost':
#         model = xgb.XGBRegressor(objective='reg:squarederror', eval_metric='rmse')
#     elif algorithm == 'CatBoost':
#         model = CatBoostRegressor(learning_rate=0.1, depth=6, iterations=500, verbose=0)
#     elif algorithm == 'LSTM':

#         X, y = prepare_lstm_data(data)
#         model = Sequential()
#         model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1], X.shape[2])))
#         model.add(LSTM(50))
#         model.add(Dense(1))
#         model.compile(optimizer='adam', loss='mean_squared_error')
#         model.fit(X, y, epochs=10, batch_size=32, verbose=0)
#         last_data_point = np.expand_dims(X[-1], axis=0)
#         future_prices = [model.predict(last_data_point)[0][0] for _ in range(days)]
        
#     elif algorithm == 'ARIMA':
#             model = ARIMA(data['Close'], order=(5, 1, 0))
#             model_fit = model.fit()
#             future_prices = model_fit.forecast(steps=10)

#     elif algorithm == 'SARIMA':
#             model = SARIMAX(data['Close'], order=(5, 1, 0), seasonal_order=(1, 1, 0, 12))
#             model_fit = model.fit()
#             forecast = model_fit.forecast(steps=10)

#         logger.info("Future prices predicted using LSTM model.")
#         return future_prices, None, None, None, None
#     else:
#         logger.error("Algorithm not recognized: %s", algorithm)
#         return None, None, None, None, None

#     model.fit(X_train, y_train)
    
#     predictions = model.predict(X_test)
#     mae = mean_absolute_error(y_test, predictions)
#     r2 = r2_score(y_test, predictions)
    
#     future_prices = []
#     last_data_point = features.iloc[-1].values.reshape(1, -1)  # Ensure it's 2D
    
#     for _ in range(days):
#         future_price = model.predict(last_data_point)[0]
#         future_prices.append(future_price)
#         last_data_point = last_data_point + 1  # Update last data point (simplified, better methods should be used)
    
#     logger.info("Future prices predicted using %s model.", algorithm)
#     return future_prices, mae, r2, None, None

# import pandas as pd
# import numpy as np
# import yfinance as yf
# import ta
# from sklearn.model_selection import train_test_split
# from sklearn.linear_model import LinearRegression
# from sklearn.tree import DecisionTreeRegressor
# from sklearn.ensemble import RandomForestRegressor
# from sklearn.metrics import mean_absolute_error, r2_score
# import xgboost as xgb
# from catboost import CatBoostRegressor
# from tensorflow.keras.models import Sequential
# from tensorflow.keras.layers import LSTM, Dense
# from sklearn.preprocessing import MinMaxScaler
# from statsmodels.tsa.arima_model import ARIMA
# from statsmodels.tsa.statespace.sarimax import SARIMAX

# from logger import get_logger

# logger = get_logger(__name__)

# # Fetch historical data
# def fetch_data(ticker, start_date, end_date):
#     logger.info(f"Fetching data for {ticker} from {start_date} to {end_date}")
#     data = yf.download(ticker, start=start_date, end=end_date)
#     if data.empty:
#         logger.warning(f"No data returned for {ticker}.")
#         return None
    
#     # Reset index to ensure Date is a column
#     data.reset_index(inplace=True)
#     logger.info(f"Data fetched successfully for {ticker}.")
#     return data

# def calculate_indicators(data: pd.DataFrame) -> pd.DataFrame:
#     logger.info("Calculating indicators with fixed parameters.")
    
#     # Check if required columns are present
#     required_columns = ['Close', 'High', 'Low', 'Volume']
#     missing_columns = [col for col in required_columns if col not in data.columns]
#     if missing_columns:
#         logger.error(f"Missing columns in data: {', '.join(missing_columns)}")
#         raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
#     # Calculate fixed moving averages
#     ma_period = 50  # Fixed period for moving averages
#     try:
#         data[f'SMA_{ma_period}'] = data['Close'].rolling(window=ma_period).mean()
#         data[f'EMA_{ma_period}'] = data['Close'].ewm(span=ma_period, adjust=False).mean()
#     except Exception as e:
#         logger.error(f"Error calculating moving averages: {e}")
#         raise
    
#     # Calculate other indicators
#     try:
#         data['RSI'] = ta.momentum.RSIIndicator(data['Close']).rsi()
#         macd = ta.trend.MACD(data['Close'])
#         data['MACD'] = macd.macd()
#         data['MACD_Signal'] = macd.macd_signal()
#         bollinger = ta.volatility.BollingerBands(data['Close'])
#         data['Bollinger_High'] = bollinger.bollinger_hband()
#         data['Bollinger_Low'] = bollinger.bollinger_lband()
#         data['ATR'] = ta.volatility.AverageTrueRange(data['High'], data['Low'], data['Close']).average_true_range()
#         data['OBV'] = ta.volume.OnBalanceVolumeIndicator(data['Close'], data['Volume']).on_balance_volume()
#     except Exception as e:
#         logger.error(f"Error calculating other indicators: {e}")
#         raise
    
#     # Debugging line to check the columns
#     logger.debug("Columns after calculating indicators: %s", data.columns)
    
#     data = data.dropna()
#     logger.info("Indicators calculated successfully.")
#     return data

# # Calculate support and resistance levels
# def calculate_support_resistance(data, window=30):
#     logger.info(f"Calculating support and resistance with a window of {window}.")
    
#     recent_data = data.tail(window)
#     rolling_max = data['Close'].rolling(window=window).max()
#     rolling_min = data['Close'].rolling(window=window).min()
#     recent_max = recent_data['Close'].max()
#     recent_min = recent_data['Close'].min()
    
#     support = min(rolling_min.iloc[-1], recent_min)
#     resistance = max(rolling_max.iloc[-1], recent_max)
    
#     logger.debug("Support: %f, Resistance: %f", support, resistance)
#     return support, resistance

# # Prepare data for LSTM model
# def prepare_lstm_data(data):
#     logger.info("Preparing data for LSTM model.")
    
#     features = data[['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']].values
#     target = data['Close'].values
#     scaler = MinMaxScaler()
#     features = scaler.fit_transform(features)
    
#     X, y = [], []
#     for i in range(len(features) - 60):
#         X.append(features[i:i+60])
#         y.append(target[i+60])
        
#     logger.info("Data preparation for LSTM completed.")
#     return np.array(X), np.array(y)

# # Predict future prices using the selected algorithm
# def predict_future_prices(data, algorithm, days=10):
#     logger.info(f"Predicting future prices using {algorithm}.")
    
#     # Check if required columns are present
#     required_columns = ['Open', 'SMA_50', 'EMA_50', 'RSI', 'MACD', 'MACD_Signal', 'Bollinger_High', 'Bollinger_Low', 'ATR', 'OBV']
#     missing_columns = [col for col in required_columns if col not in data.columns]
    
#     if missing_columns:
#         logger.error("Missing columns in data: %s", ', '.join(missing_columns))
#         raise KeyError(f"Missing columns in data: {', '.join(missing_columns)}")
    
#     features = data[required_columns]
#     target = data['Close']
    
#     X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)
    
#     if algorithm == 'Linear Regression':
#         model = LinearRegression()
#     elif algorithm == 'Decision Tree':
#         model = DecisionTreeRegressor()
#     elif algorithm == 'Random Forest':
#         model = RandomForestRegressor(n_estimators=100)
#     elif algorithm == 'XGBoost':
#         model = xgb.XGBRegressor(objective='reg:squarederror', eval_metric='rmse')
#     elif algorithm == 'CatBoost':
#         model = CatBoostRegressor(learning_rate=0.1, depth=6, iterations=500, verbose=0)
#     elif algorithm == 'LSTM':
#         X, y = prepare_lstm_data(data)
#         model = Sequential()
#         model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1], X.shape[2])))
#         model.add(LSTM(50))
#         model.add(Dense(1))
#         model.compile(optimizer='adam', loss='mean_squared_error')
#         model.fit(X, y, epochs=10, batch_size=32, verbose=0)
#         last_data_point = np.expand_dims(X[-1], axis=0)
#         future_prices = [model.predict(last_data_point)[0][0] for _ in range(days)]
        
#         logger.info("Future prices predicted using LSTM model.")
#         return future_prices, None, None, None, None
#     elif algorithm == 'ARIMA':
#         model = ARIMA(data['Close'], order=(5, 1, 0))
#         model_fit = model.fit(disp=0)
#         forecast = model_fit.forecast(steps=days)[0]
        
#         mae = mean_absolute_error(target[-days:], forecast[:days])
#         r2 = r2_score(target[-days:], forecast[:days])
        
#         logger.info("Future prices predicted using ARIMA model.")
#         return forecast.tolist(), mae, r2, None, None
#     elif algorithm == 'SARIMA':
#         model = SARIMAX(data['Close'], order=(5, 1, 0), seasonal_order=(1, 1, 0, 12))
#         model_fit = model.fit(disp=0)
#         forecast = model_fit.forecast(steps=days)
        
#         mae = mean_absolute_error(target[-days:], forecast[:days])
#         r2 = r2_score(target[-days:], forecast[:days])
        
#         logger.info("Future prices predicted using SARIMA model.")
#         return forecast.tolist(), mae, r2, None, None
#     else:
#         logger.error("Algorithm not recognized: %s", algorithm)
#         return None, None, None, None, None

#     model.fit(X_train, y_train)
    
#     predictions = model.predict(X_test)
#     mae = mean_absolute_error(y_test, predictions)
#     r2 = r2_score(y_test, predictions)
    
#     future_prices = []
#     last_data_point = features.iloc[-1].values.reshape(1, -1)  # Ensure it's 2D
    
#     for _ in range(days):
#         future_price = model.predict(last_data_point)[0]
#         future_prices.append(future_price)
#         last_data_point = last_data_point + 1  # Update last data point (simplified, better methods should be used)
    
#     logger.info("Future prices predicted using %s model.", algorithm)
#     return future_prices, mae, r2, predictions, y_test




# # model.py

# import pandas as pd
# import numpy as np
# import yfinance as yf
# import statsmodels.api as sm
# from statsmodels.tsa.arima.model import ARIMA
# from statsmodels.tsa.statespace.sarimax import SARIMAX
# from sklearn.metrics import mean_absolute_error, r2_score

# def fetch_data(ticker, start_date, end_date):
#     try:
#         df = yf.download(ticker, start=start_date, end=end_date)
#         return df
#     except Exception as e:
#         print(f"An error occurred while fetching data: {e}")
#         return None

# def calculate_indicators(data):
#     # Example indicators - these should be tailored to your requirements
#     data['SMA_50'] = data['Close'].rolling(window=50).mean()
#     data['EMA_50'] = data['Close'].ewm(span=50, adjust=False).mean()
#     data['RSI'] = calculate_rsi(data['Close'])
#     data['MACD'], data['MACD_Signal'] = calculate_macd(data['Close'])
#     data['Bollinger_High'], data['Bollinger_Low'] = calculate_bollinger_bands(data['Close'])
#     data['ATR'] = calculate_atr(data)
#     data['OBV'] = calculate_obv(data)
#     return data

# def calculate_rsi(series, period=14):
#     delta = series.diff()
#     gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
#     loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
#     rs = gain / loss
#     return 100 - (100 / (1 + rs))

# def calculate_macd(series):
#     macd = series.ewm(span=12, adjust=False).mean() - series.ewm(span=26, adjust=False).mean()
#     macd_signal = macd.ewm(span=9, adjust=False).mean()
#     return macd, macd_signal

# def calculate_bollinger_bands(series, window=20):
#     rolling_mean = series.rolling(window=window).mean()
#     rolling_std = series.rolling(window=window).std()
#     high = rolling_mean + (rolling_std * 2)
#     low = rolling_mean - (rolling_std * 2)
#     return high, low

# def calculate_atr(data, window=14):
#     high_low = data['High'] - data['Low']
#     high_close = np.abs(data['High'] - data['Close'].shift())
#     low_close = np.abs(data['Low'] - data['Close'].shift())
#     tr = np.max(np.array([high_low, high_close, low_close]), axis=0)
#     atr = tr.rolling(window=window).mean()
#     return atr

# def calculate_obv(data):
#     obv = (data['Volume'] * np.sign(data['Close'].diff())).fillna(0).cumsum()
#     return obv

# def calculate_support_resistance(data):
#     # Example calculation - you may need to refine this based on your requirements
#     support = data['Close'].min()
#     resistance = data['Close'].max()
#     return support, resistance

# def predict_future_prices(data, model_type='ARIMA'):
#     try:
#         # Use ARIMA
#         if model_type == 'ARIMA':
#             model = ARIMA(data['Close'], order=(5, 1, 0))
#             model_fit = model.fit()
#             forecast = model_fit.forecast(steps=10)
#         # Use SARIMA
#         elif model_type == 'SARIMA':
#             model = SARIMAX(data['Close'], order=(5, 1, 0), seasonal_order=(1, 1, 0, 12))
#             model_fit = model.fit()
#             forecast = model_fit.forecast(steps=10)
#         else:
#             raise ValueError("Unsupported model type. Use 'ARIMA' or 'SARIMA'.")
        
#         # Calculate MAE and R2 for evaluation
#         y_true = data['Close'][-10:]  # last 10 days as true values for comparison
#         mae = mean_absolute_error(y_true, forecast[:len(y_true)])
#         r2 = r2_score(y_true, forecast[:len(y_true)])
        
#         # Return results
#         return forecast, mae, r2
#     except Exception as e:
#         print(f"An error occurred while predicting future prices: {e}")
#         return None, None, None