Fix indentation error in core/plot.py and update app.py for correct data passing.

app.py

@@ -21,7 +21,7 @@ logging.basicConfig(
         logging.FileHandler(log_path),
         logging.StreamHandler()
     ],
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format=\'%(asctime)s - %(levelname)s - %(message)s\'
 )
 analyzer = SentimentIntensityAnalyzer()
 
@@ -33,10 +33,10 @@ def sentiment_analysis(ticker, start_date, end_date, api_key):
         start = pd.to_datetime(start_date)
         end = pd.to_datetime(end_date)
         articles = newsapi.get_everything(
-            q=ticker, from_param=start.strftime('%Y-%m-%d'), to=end.strftime('%Y-%m-%d'), 
-            language='en', sort_by='relevancy'
+            q=ticker, from_param=start.strftime(\"%Y-%m-%d\"), to=end.strftime(\"%Y-%m-%d\"), 
+            language=\'en\', sort_by=\'relevancy\'
         )
-        sentiments = [analyzer.polarity_scores(article['title'])['compound'] for article in articles['articles']]
+        sentiments = [analyzer.polarity_scores(article[\"title\"])[\"compound\"] for article in articles[\"articles\"]]
         avg_sentiment = np.mean(sentiments) if sentiments else 0.0
         sentiment_text = f"Average sentiment for {ticker}: {avg_sentiment:.2f}"
         return sentiment_text, avg_sentiment
@@ -45,9 +45,9 @@ def sentiment_analysis(ticker, start_date, end_date, api_key):
         return f"Sentiment analysis failed: {str(e)}", None
 
 def update_horizon_label(timeframe):
-    units = {'1m': 'minutes', '5m': 'minutes', '15m': 'minutes', '30m': 'minutes', 
-             '1h': 'hours', '4h': 'hours', '1d': 'days', '1wk': 'weeks'}
-    return gr.update(label=f"Horizon ({units.get(timeframe, 'days')})")
+    units = {\'1m\': \'minutes\', \'5m\': \'minutes\', \'15m\': \'minutes\', \'30m\': \'minutes\', 
+             \'1h\': \'hours\', \'4h\': \'hours\', \'1d\': \'days\', \'1wk\': \'weeks\'}
+    return gr.update(label=f"Horizon ({units.get(timeframe, \'days\')})")
 
 def run_dashboard(data_src, ticker, file_upload, timeframe, start_date, end_date, horizon, indicators, 
                  include_sentiment, news_api_key, alpha_api_key, account_size, risk_percent, model, 
@@ -65,13 +65,13 @@ def run_dashboard(data_src, ticker, file_upload, timeframe, start_date, end_date
             logging.error("Failed to load data")
             return [None] * 12 + ["Failed to load data", None, None, None, None, "Failed to load data"]
 
-        df = add_technical_indicators(df, indicators)
+        df, valid_indicators = add_technical_indicators(df, indicators)
         if include_sentiment and news_api_key:
             df = add_sentiment(df, ticker, news_api_key, start_date, end_date)
         sentiment_text, sentiment_score = sentiment_analysis(ticker, start_date, end_date, news_api_key)
 
-        features = indicators
-        target = 'value'
+        features = valid_indicators # Use valid_indicators for features
+        target = \'value\'
         result = get_model(
             df=df,
             features=features,
@@ -92,23 +92,25 @@ def run_dashboard(data_src, ticker, file_upload, timeframe, start_date, end_date
             importance_threshold=feat_threshold
         )
         if isinstance(result, dict) and result.get("error"):
-            logging.error(f"Model training failed: {result['error']}")
-            return [None] * 12 + [f"Model training failed: {result['error']}", None, None, None, None, f"Model training failed: {result['error']}"]
+            logging.error(f"Model training failed: {result[\"error\"]}")
+            return [None] * 12 + [f"Model training failed: {result[\"error\"]}", None, None, None, None, f"Model training failed: {result[\"error\"]}"]
 
-        signals_df = generate_signals(df, result)
+        signals_df, trades_df, equity_df = generate_signals(df, result)
         if signals_df.empty:
             logging.error("Failed to generate signals")
             return [None] * 12 + ["Failed to generate signals", None, None, None, None, "Failed to generate signals"]
 
         chart_plot = plot_indicators(df, ticker)
         signals_plot = plot_signals(signals_df, ticker)
-        backtest_plot = plot_backtest(signals_df, df, ticker)
-        future_plot = plot_future_forecast(result, df)
+        backtest_plot = plot_backtest(equity_df, trades_df, ticker)
+
+
+        future_plot = plot_future_forecast(df, result, indicators)
         future_table = pd.DataFrame({
-            'Date': [df.index[-1] + timedelta(days=i+1) for i in range(horizon)],
-            'Prediction': result['latest_prediction']
+            \"Date\": [df.index[-1] + timedelta(days=i+1) for i in range(horizon)],
+            \"Prediction\": result[\"latest_prediction\"]
         })
-        signals_table = signals_df.reset_index()[['Date', 'Price', 'Signal', 'Position_Size', 'Stop_Loss', 'Take_Profit', 'Equity']]
+        signals_table = signals_df.reset_index()[[\"Date\", \"Price\", \"Signal\", \"Position_Size\", \"Stop_Loss\", \"Take_Profit\", \"Equity\"]]
         r2_plot = plot_metrics_r2(result)
         error_plot = plot_metrics_errors(result)
         precision_recall_plot = plot_metrics_precision_recall(result)
@@ -118,15 +120,18 @@ def run_dashboard(data_src, ticker, file_upload, timeframe, start_date, end_date
 
         signals_csv = f"signals_{ticker}.csv"
         signals_df.to_csv(signals_csv)
+
+
+
         predictions_csv = f"predictions_{ticker}.csv"
         pd.DataFrame({
-            'Actual': result['actual'],
-            'Forecast': result['forecast']
+            \"Actual\": result[\"actual\"],
+            \"Forecast\": result[\"forecast\"]
         }).to_csv(predictions_csv)
         chart_png = f"chart_{ticker}.png"
-        pio.write(chart_plot, chart_png, format='png')
+        pio.write(chart_plot, chart_png, format=\'png\')
 
-        with open(log_path, 'r') as log_file:
+        with open(log_path, \'r\') as log_file:
             log_output = log_file.read()
 
         logging.info("Dashboard run completed successfully")
@@ -228,4 +233,5 @@ def main_interface():
     return app
 
 if __name__ == "__main__":
-    main_interface().launch(server_name="0.0.0.0", server_port=7860, share=False)
+    main_interface().launch(server_name="0.0.0.0", server_port=7860, share=False)
+

core/data.py

@@ -8,45 +8,46 @@ except ImportError:
     ta = None
 from datetime import datetime, timedelta
 from newsapi import NewsApiClient
-from textblob import TextBlob
-import pickle
-from requests.exceptions import HTTPError, ConnectionError, Timeout
-from alpha_vantage.timeseries import TimeSeries
-import time
 from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 from sklearn.preprocessing import MinMaxScaler
-from sklearn.decomposition import PCA
+from alpha_vantage.timeseries import TimeSeries
+import time
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Use print for logging to ensure visibility in Hugging Face Spaces
-def print_log(message, level="INFO"):
-    print(f"[{level}] {message}")
+def print_log(message, level='INFO'):
+    if level == 'INFO':
+        logging.info(message)
+    elif level == 'WARNING':
+        logging.warning(message)
+    elif level == 'ERROR':
+        logging.error(message)
+    else:
+        logging.debug(message)
 
 analyzer = SentimentIntensityAnalyzer()
 
-def load_data(data_src="yahoo", ticker="AAPL", start="2020-01-01", end="2023-01-01", interval='1d', file_upload=None, alpha_api_key=None):
+def load_data(data_src='yahoo', ticker='AAPL', start='2020-01-01', end='2023-01-01', interval='1d', file_upload=None, alpha_api_key=None):
     try:
-        # Log inputs to console for visibility in Hugging Face Spaces
         print_log(f"Loading data: source={data_src}, ticker={ticker}, start={start}, end={end}, interval={interval}, file_upload={'set' if file_upload else 'unset'}, alpha_api_key={'set' if alpha_api_key else 'unset'}")
 
-        # Validate inputs
-        try:
-            start_date = pd.to_datetime(start)
-            end_date = pd.to_datetime(end)
-            if start_date >= end_date:
-                raise ValueError(f"Start date {start} must be before end date {end}")
-            if end_date > datetime.now():
-                raise ValueError(f"End date {end} cannot be in the future")
-        except Exception as e:
-            print_log(f"Invalid date format or range: {str(e)}", "ERROR")
-            raise ValueError(f"Invalid date format or range: {str(e)}")
-
-        # No caching for Hugging Face Spaces compatibility
-        if data_src == "csv" and file_upload:
+        start_date = pd.to_datetime(start)
+        end_date = pd.to_datetime(end)
+        if start_date >= end_date:
+            raise ValueError(f"Start date {start} must be before end date {end}")
+        if end_date > datetime.now():
+            print_log(f"End date {end} is in the future. Using current date as end date.", 'WARNING')
+            end_date = datetime.now()
+
+        df = pd.DataFrame()
+
+        if data_src == 'csv' and file_upload:
             try:
                 file_path = getattr(file_upload, 'name', file_upload)
                 print_log(f"Loading CSV from {file_path}")
                 df = pd.read_csv(file_path)
-                print_log(f"CSV columns: {df.columns.tolist()}")
                 if 'Date' not in df.columns:
                     raise ValueError("CSV must contain a 'Date' column")
                 df['Date'] = pd.to_datetime(df['Date']).dt.tz_localize(None)
@@ -60,69 +61,63 @@ def load_data(data_src="yahoo", ticker="AAPL", start="2020-01-01", end="2023-01-
                 if df['value'].isna().all():
                     raise ValueError(f"CSV 'value' column contains only NaNs for {ticker}")
             except Exception as e:
-                print_log(f"Failed to load CSV {file_path}: {str(e)}", "ERROR")
+                print_log(f"Failed to load CSV {file_path}: {str(e)}", 'ERROR')
                 raise ValueError(f"Failed to load CSV: {str(e)}")
         else:
             print_log(f"Fetching data for {ticker} from Yahoo Finance")
             try:
-                df = yf.download(ticker, start=start, end=end, interval=interval, progress=False, auto_adjust=False)
-                print_log(f"Yahoo Finance raw columns type: {type(df.columns)}")
-                print_log(f"Yahoo Finance raw columns: {df.columns.tolist() if not isinstance(df.columns, pd.MultiIndex) else df.columns.tolist()}")
-
-                # Fix for MultiIndex columns (common for crypto/forex like BTC-USD in recent yfinance versions)
+                df = yf.download(ticker, start=start_date, end=end_date, interval=interval, progress=False, auto_adjust=False)
                 if isinstance(df.columns, pd.MultiIndex):
-                    print_log(f"Flattening MultiIndex columns for {ticker} (removing ticker level)")
-                    df.columns = df.columns.droplevel(1)  # Drop the ticker level (e.g., 'BTC-USD'), keep fields like 'Close'
-
-                print_log(f"Yahoo Finance processed columns: {df.columns.tolist()}")
+                    df.columns = df.columns.droplevel(1)
                 if df.empty:
                     raise ValueError(f"No data returned from Yahoo Finance for {ticker}")
                 if 'Close' not in df.columns:
                     raise ValueError(f"Yahoo Finance data missing 'Close' column for {ticker}")
                 df = df.rename(columns={'Close': 'value'})
-                df['Date'] = df.index
-                df = df.reset_index(drop=True)
+                # The index is already datetime, no need to create a 'Date' column and then reset
                 if df['value'].isna().all():
                     raise ValueError(f"Yahoo Finance 'value' column contains only NaNs for {ticker}")
                 if df['value'].empty:
                     raise ValueError(f"Yahoo Finance 'value' column is empty for {ticker}")
             except Exception as e:
-                print_log(f"Yahoo Finance failed for {ticker}: {str(e)}", "ERROR")
+                print_log(f"Yahoo Finance failed for {ticker}: {str(e)}", 'ERROR')
                 raise ValueError(f"Yahoo Finance failed for {ticker}: {str(e)}")
 
-        # Alpha Vantage for intraday
-        if interval in ['1m', '5m', '15m', '30m', '60m'] and alpha_api_key:
-            print_log(f"Attempting Alpha Vantage for {ticker}, interval {interval}")
-            try:
-                ts = TimeSeries(key=alpha_api_key, output_format='pandas')
-                df, _ = ts.get_intraday(symbol=ticker, interval=interval, outputsize='full')
-                print_log(f"Alpha Vantage columns: {df.columns.tolist()}")
-                if df.empty:
-                    raise ValueError(f"No data returned from Alpha Vantage for {ticker}")
-                if '4. close' not in df.columns:
-                    raise ValueError(f"Alpha Vantage data missing '4. close' column for {ticker}")
-                df = df.rename(columns={'4. close': 'value', '1. open': 'Open', '2. high': 'High', '3. low': 'Low', '5. volume': 'Volume'})
-                df['Date'] = pd.to_datetime(df.index)
-                df = df.reset_index(drop=True)
-                if df['value'].isna().all():
-                    raise ValueError(f"Alpha Vantage 'value' column contains only NaNs for {ticker}")
-                if df['value'].empty:
-                    raise ValueError(f"Alpha Vantage 'value' column is empty for {ticker}")
-            except Exception as e:
-                print_log(f"Alpha Vantage failed: {str(e)}, using Yahoo Finance data", "WARNING")
+        # Alpha Vantage data loading (if applicable)
+        # Note: Alpha Vantage data loading logic is commented out for now to simplify debugging
+        # if interval in ['1m', '5m', '15m', '30m', '60m'] and alpha_api_key:
+        #     print_log(f"Attempting Alpha Vantage for {ticker}, interval {interval}")
+        #     try:
+        #         ts = TimeSeries(key=alpha_api_key, output_format='pandas')
+        #         df_av, _ = ts.get_intraday(symbol=ticker, interval=interval, outputsize='full')
+        #         if df_av.empty:
+        #             raise ValueError(f"No data returned from Alpha Vantage for {ticker}")
+        #         if '4. close' not in df_av.columns:
+        #             raise ValueError(f"Alpha Vantage data missing '4. close' column for {ticker}")
+        #         df_av = df_av.rename(columns={'4. close': 'value', '1. open': 'Open', '2. high': 'High', '3. low': 'Low', '5. volume': 'Volume'}) # Standardize column names
+        #         df_av['Date'] = pd.to_datetime(df_av.index)
+        #         df_av = df_av.reset_index(drop=True)
+        #         if df_av['value'].isna().all():
+        #             raise ValueError(f"Alpha Vantage 'value' column contains only NaNs for {ticker}")
+        #         if df_av['value'].empty:
+        #             raise ValueError(f"Alpha Vantage 'value' column is empty for {ticker}")
+        #         df = df_av # Use Alpha Vantage data if successful
+        #     except Exception as e:
+        #         print_log(f"Alpha Vantage failed: {str(e)}, using Yahoo Finance data", 'WARNING')
 
         if df.empty:
             raise ValueError(f"No data loaded for {ticker} from {data_src}")
 
-        # Ensure required columns
-        required_cols = ['Date', 'Open', 'High', 'Low', 'value', 'Volume']
-        missing_cols = [col for col in required_cols if col not in df.columns]
-        if missing_cols:
-            print_log(f"Missing columns: {missing_cols}. Adding placeholders with NaNs", "WARNING")
-            for col in missing_cols:
-                df[col] = np.nan
+        # Ensure index is DatetimeIndex and sorted
+        if not isinstance(df.index, pd.DatetimeIndex):
+            df.index = pd.to_datetime(df.index)
+        df = df.sort_index()
+
+        required_cols = ['Open', 'High', 'Low', 'value', 'Volume']
+        for col in required_cols:
+            if col not in df.columns:
+                df[col] = np.nan # Add missing columns with NaNs
 
-        # Validate 'value' column
         if 'value' not in df.columns:
             raise ValueError(f"Target column 'value' is missing for {ticker}")
         if df['value'].isna().all():
@@ -130,30 +125,34 @@ def load_data(data_src="yahoo", ticker="AAPL", start="2020-01-01", end="2023-01-
         if df['value'].empty:
             raise ValueError(f"Target column 'value' is empty for {ticker}")
 
-        print_log(f"Data loaded for {ticker} with date range: {df['Date'].min()} to {df['Date'].max()}, shape: {df.shape}")
-        print_log(f"DataFrame columns: {df.columns.tolist()}")
+        print_log(f"Data loaded for {ticker} with date range: {df.index.min()} to {df.index.max()}, shape: {df.shape}")
         return df
     except Exception as e:
-        print_log(f"Error in load_data for {ticker}: {str(e)}", "ERROR")
+        print_log(f"Error in load_data for {ticker}: {str(e)}", 'ERROR')
         raise ValueError(f"Failed to load data for {ticker}: {str(e)}")
 
 def add_technical_indicators(df, selected_indicators):
     try:
         print_log(f"Starting add_technical_indicators with indicators: {selected_indicators}")
-        print_log(f"DataFrame columns before: {df.columns.tolist()}")
-        print_log(f"DataFrame shape: {df.shape}")
-        print_log(f"Sample data: {df.head().to_dict()}")
+        if df.empty:
+            print_log("DataFrame is empty, skipping technical indicator calculation.", "WARNING")
+            return df, []
 
-        if ta is None:
-            print_log("TA-Lib not available. Cannot compute indicators. Falling back to 'value'.", "ERROR")
-            return df
+        # Ensure columns are numeric and handle missing ones
+        for col in ['Open', 'High', 'Low', 'value', 'Volume']:
+            if col not in df.columns:
+                df[col] = np.nan
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Drop rows with NaN in core columns after indicator calculation
+        df.dropna(subset=['Open', 'High', 'Low', 'value', 'Volume'], inplace=True)
+        if df.empty:
+            print_log("DataFrame is empty after dropping NaNs for technical indicators.", "WARNING")
+            return df, []
 
-        # Ensure required columns
-        required_cols = ['value', 'High', 'Low', 'Open', 'Volume']
-        missing_cols = [col for col in required_cols if col not in df.columns or df[col].isna().all()]
-        if missing_cols:
-            print_log(f"Missing or entirely NaN columns: {missing_cols}. Cannot compute indicators.", "ERROR")
-            return df
+        if ta is None:
+            print_log("TA-Lib not available. Cannot compute indicators. Falling back to 'value'.", 'ERROR')
+            return df, []
 
         close = df['value'].values
         high = df['High'].values
@@ -161,7 +160,6 @@ def add_technical_indicators(df, selected_indicators):
         volume = df['Volume'].values
         open_ = df['Open'].values
 
-        # Updated indicator_map with 'inputs' key to specify required arrays (e.g., ['close'] or ['high', 'low', 'close'])
         indicator_map = {
             'rsi': {'func': ta.RSI, 'inputs': ['close'], 'params': {'timeperiod': 14}, 'output': ['rsi_14']},
             'macd': {'func': ta.MACD, 'inputs': ['close'], 'params': {'fastperiod': 12, 'slowperiod': 26, 'signalperiod': 9}, 'output': ['macd_12_26_9', 'macds_12_26_9', 'macdh_12_26_9']},
@@ -188,7 +186,6 @@ def add_technical_indicators(df, selected_indicators):
                 inputs = config['inputs']
                 params = config['params']
                 try:
-                    # Get input arrays based on 'inputs' key
                     input_arrays = [input_dict[inp] for inp in inputs]
                     result = func(*input_arrays, **params)
                     if isinstance(result, tuple):
@@ -196,58 +193,30 @@ def add_technical_indicators(df, selected_indicators):
                             if isinstance(res, np.ndarray) and len(res) == len(df):
                                 df[out_col] = res
                                 nan_count = np.isnan(res).sum()
-                                print_log(f"Added {out_col}: sample value {res[0] if len(res) > 0 else 'empty'}, NaN count: {nan_count}")
                                 if nan_count < len(res) * 0.5:
                                     valid_indicators.append(out_col)
                                 else:
-                                    print_log(f"{out_col} has excessive NaNs: {nan_count}/{len(res)}. Excluding from valid indicators.", "WARNING")
+                                    print_log(f"{out_col} has excessive NaNs: {nan_count}/{len(res)}. Excluding from valid indicators.", 'WARNING')
                             else:
-                                print_log(f"Invalid output for {out_col}: {type(res)}, length: {len(res) if hasattr(res, '__len__') else 'N/A'}", "WARNING")
+                                print_log(f"Invalid output for {out_col}: {type(res)}, length: {len(res) if hasattr(res, '__len__') else 'N/A'}", 'WARNING')
                     else:
                         if isinstance(result, np.ndarray) and len(result) == len(df):
                             df[config['output'][0]] = result
                             nan_count = np.isnan(result).sum()
-                            print_log(f"Added {config['output'][0]}: sample value {result[0] if len(result) > 0 else 'empty'}, NaN count: {nan_count}")
                             if nan_count < len(result) * 0.5:
                                 valid_indicators.append(config['output'][0])
                             else:
-                                print_log(f"{config['output'][0]} has excessive NaNs: {nan_count}/{len(result)}. Excluding from valid indicators.", "WARNING")
+                                print_log(f"{config['output'][0]} has excessive NaNs: {nan_count}/{len(result)}. Excluding from valid indicators.", 'WARNING')
                         else:
-                            print_log(f"Invalid output for {ind}: {type(result)}, length: {len(result) if hasattr(result, '__len__') else 'N/A'}", "WARNING")
+                            print_log(f"Invalid output for {ind}: {type(result)}, length: {len(result) if hasattr(result, '__len__') else 'N/A'}", 'WARNING')
                 except Exception as e:
-                    print_log(f"Error computing {ind}: {str(e)}", "ERROR")
+                    print_log(f"Error computing {ind}: {str(e)}", 'ERROR')
             else:
-                print_log(f"Indicator {ind} not supported by TA-Lib", "WARNING")
-
-        # Ensure core indicators as fallback
-        core_indicators = ['rsi_14', 'macd_12_26_9', 'macds_12_26_9', 'macdh_12_26_9', 'adx_14', 'pdi_14', 'mdi_14', 'willr_14', 'cci_20', 'atr_14', 'stochk_14_3_3', 'stochd_14_3_3']
-        for ind, config in indicator_map.items():
-            for out_col in config['output']:
-                if out_col not in df.columns and out_col not in valid_indicators:
-                    try:
-                        input_arrays = [input_dict[inp] for inp in config['inputs']]
-                        result = config['func'](*input_arrays, **config['params'])
-                        if isinstance(result, tuple):
-                            for j, (res, col) in enumerate(zip(result, config['output'])):
-                                if col not in df.columns and isinstance(res, np.ndarray) and len(res) == len(df):
-                                    df[col] = res
-                                    nan_count = np.isnan(res).sum()
-                                    print_log(f"Added fallback {col}: sample value {res[0] if len(res) > 0 else 'empty'}, NaN count: {nan_count}")
-                                    if nan_count < len(res) * 0.5:
-                                        valid_indicators.append(col)
-                        else:
-                            if out_col not in df.columns and isinstance(result, np.ndarray) and len(result) == len(df):
-                                df[out_col] = result
-                                nan_count = np.isnan(result).sum()
-                                print_log(f"Added fallback {out_col}: sample value {result[0] if len(result) > 0 else 'empty'}, NaN count: {nan_count}")
-                                if nan_count < len(result) * 0.5:
-                                    valid_indicators.append(out_col)
-                    except Exception as e:
-                        print_log(f"Error adding fallback {out_col}: {str(e)}", "ERROR")
+                print_log(f"Indicator {ind} not supported by TA-Lib", 'WARNING')
 
         # Drop rows with NaN in 'value', preserve valid indicators
         initial_rows = len(df)
-        df = df.dropna(subset=['value']).reset_index(drop=True)
+        df = df.dropna(subset=['value']).reset_index(drop=False) # Keep index as a column for now
         print_log(f"Dropped {initial_rows - len(df)} rows with NaN in 'value'")
 
         # Drop columns with excessive NaNs, but protect 'value'
@@ -255,97 +224,106 @@ def add_technical_indicators(df, selected_indicators):
             if col not in ['Date', 'Open', 'High', 'Low', 'value', 'Volume']:
                 nan_ratio = df[col].isna().mean()
                 if nan_ratio > 0.5:
-                    print_log(f"Dropping {col} due to excessive NaNs: {nan_ratio:.2%}", "WARNING")
+                    print_log(f"Dropping {col} due to excessive NaNs: {nan_ratio:.2%}", 'WARNING')
                     df = df.drop(columns=[col])
                     if col in valid_indicators:
                         valid_indicators.remove(col)
 
-        # Ensure at least one valid feature
         if not valid_indicators:
             print_log("No valid indicators computed. Falling back to 'value'.", "WARNING")
             valid_indicators.append('value')
 
         print_log(f"Valid indicators: {valid_indicators}")
-        print_log(f"DataFrame columns after: {df.columns.tolist()}")
-        print_log(f"Sample data after: {df.head().to_dict()}")
         print_log(f"Technical indicators added successfully, shape: {df.shape}")
-        return df
+        df.set_index('Date', inplace=True) # Set index back to Date after all processing
+        return df, valid_indicators
     except Exception as e:
-        print_log(f"Error in add_technical_indicators: {str(e)}", "ERROR")
-        return df
+        print_log(f"Error in add_technical_indicators: {str(e)}", 'ERROR')
+        # If an error occurs, return the original DataFrame to prevent further errors
+        return df, []
 
 def add_sentiment(df, ticker, news_api_key, start_date, end_date):
     try:
-        print_log(f"Adding sentiment for {ticker}")
+        print_log(f"Starting add_sentiment for {ticker} from {start_date} to {end_date}")
+        if not news_api_key:
+            print_log("News API key not provided. Skipping sentiment analysis.", "WARNING")
+            df['sentiment_score'] = 0.0
+            return df
+
         newsapi = NewsApiClient(api_key=news_api_key)
-        articles = newsapi.get_everything(
-            q=ticker,
-            from_param=start_date,
-            to=end_date,
-            language='en',
-            sort_by='relevancy'
-        )
-        sentiments = []
-        for article in articles['articles']:
-            text = article.get('content', '')
-            if text:
-                score = analyzer.polarity_scores(text)['compound']
-                sentiments.append(score)
-        avg_sentiment = np.mean(sentiments) if sentiments else 0.0
-        df['sentiment'] = avg_sentiment
-        print_log(f"Sentiment added for {ticker}: {avg_sentiment}, based on {len(sentiments)} articles")
+        all_articles = []
+        current_date = pd.to_datetime(start_date)
+        end_date = pd.to_datetime(end_date)
+
+        while current_date <= end_date:
+            from_param = current_date.strftime("%Y-%m-%d")
+            to_param = (current_date + timedelta(days=1)).strftime("%Y-%m-%d")
+            print_log(f"Fetching news for {ticker} from {from_param} to {to_param}")
+            try:
+                articles = newsapi.get_everything(q=ticker, language='en', sort_by='relevancy', from_param=from_param, to=to_param)
+                all_articles.extend(articles["articles"])
+            except Exception as e:
+                print_log(f"Error fetching news for {ticker} on {from_param}: {str(e)}", 'ERROR')
+            current_date += timedelta(days=1)
+            time.sleep(0.1)
+
+        if not all_articles:
+            print_log(f"No articles found for {ticker}. Setting sentiment to 0.", 'WARNING')
+            df['sentiment_score'] = 0.0
+            return df
+
+        sentiment_data = []
+        for article in all_articles:
+            if article["publishedAt"] and article["description"]:
+                date = pd.to_datetime(article["publishedAt"]).tz_localize(None).date()
+                text = article["description"]
+                vs = analyzer.polarity_scores(text)
+                sentiment_data.append({"Date": date, "sentiment_score": vs["compound"]})
+
+        sentiment_df = pd.DataFrame(sentiment_data)
+        sentiment_df["Date"] = pd.to_datetime(sentiment_df["Date"])
+        sentiment_df = sentiment_df.groupby("Date")["sentiment_score"].mean().reset_index()
+
+        df.reset_index(inplace=True)
+        df['Date'] = pd.to_datetime(df['Date'])
+        df = pd.merge(df, sentiment_df, on="Date", how="left")
+        df['sentiment_score'] = df['sentiment_score'].fillna(0.0)
+        df.set_index('Date', inplace=True)
+
+        print_log(f"Sentiment analysis completed for {ticker}. Added sentiment_score column.")
         return df
     except Exception as e:
-        print_log(f"Error in add_sentiment: {str(e)}", "ERROR")
+        print_log(f"Error in add_sentiment for {ticker}: {str(e)}", 'ERROR')
+        df['sentiment_score'] = 0.0
         return df
 
-def preprocess_data(df, features, target, window_size=30, horizon=1):
+def preprocess_data(df, features, target, window_size, horizon):
     try:
-        print_log("Starting preprocess_data")
-        available_columns = df.columns.tolist()
-        print_log(f"Available columns: {available_columns}")
-
-        # Validate target column
-        if target not in df.columns:
-            raise ValueError(f"Target column '{target}' not found in DataFrame")
+        print_log(f"Starting preprocessing: features={features}, target={target}, window={window_size}, horizon={horizon}")
+        
+        # Ensure the DataFrame index is a DatetimeIndex
+        if not isinstance(df.index, pd.DatetimeIndex):
+            raise ValueError("DataFrame index must be a DatetimeIndex for preprocessing.")
 
-        target_series = df[target]
-        if target_series.empty:
-            raise ValueError(f"Target column '{target}' is empty")
-        if target_series.isna().all():
-            raise ValueError(f"Target column '{target}' contains only NaNs")
+        # Filter features to only include those present in the DataFrame columns
+        updated_feature_cols = [f for f in features if f in df.columns]
+        if not updated_feature_cols:
+            raise ValueError("No valid features found in DataFrame after indicator calculation.")
 
-        # Filter valid features, exclude target
-        feature_cols = [col for col in features if col in available_columns and col != target]
-        if not feature_cols:
-            print_log(f"No valid features found in {features}. Falling back to ['value']", "WARNING")
-            feature_cols = ['value'] if 'value' in available_columns else []
-
-        if not feature_cols:
-            raise ValueError("No valid features available, including fallback 'value'")
-
-        feature_data = df[feature_cols].values.astype(float)
-        print_log(f"Feature columns: {feature_cols}, feature_data shape: {feature_data.shape}")
+        full_features = updated_feature_cols + [target]
+        data = df[full_features].copy()
+        data.dropna(inplace=True)
 
-        if feature_data.shape[1] == 0:
-            raise ValueError(f"No valid features available after filtering. Feature columns: {feature_cols}")
+        if data.empty:
+            raise ValueError("DataFrame is empty after dropping NaNs. Cannot proceed with scaling.")
 
         feature_scaler = MinMaxScaler()
-        scaled_features = feature_scaler.fit_transform(feature_data)
         target_scaler = MinMaxScaler()
-        scaled_target = target_scaler.fit_transform(target_series.values.reshape(-1, 1)).flatten()
 
-        pca = None
-        updated_feature_cols = feature_cols
-        if len(feature_cols) > 10:
-            print_log("Applying PCA due to high feature count")
-            pca = PCA(n_components=min(10, len(feature_cols)))
-            scaled_features = pca.fit_transform(scaled_features)
-            updated_feature_cols = [f'pca_{i}' for i in range(min(10, len(feature_cols)))]
-            print_log(f"PCA applied: new feature count: {len(updated_feature_cols)}")
+        data_features_scaled = feature_scaler.fit_transform(data[updated_feature_cols])
+        data_target_scaled = target_scaler.fit_transform(data[[target]])
 
-        full_features = updated_feature_cols + [target]
-        full_scaled = np.column_stack((scaled_features, scaled_target))
+        full_scaled = np.hstack((data_features_scaled, data_target_scaled))
         target_idx = len(updated_feature_cols)
 
         X, y = [], []
@@ -360,7 +338,8 @@ def preprocess_data(df, features, target, window_size=30, horizon=1):
             raise ValueError(f"Insufficient data after preprocessing. Data length: {len(full_scaled)}, window_size: {window_size}, horizon: {horizon}")
 
         print_log(f"Preprocessed data: X.shape={X.shape}, y.shape={y.shape}, Final features: {full_features}, Target idx: {target_idx}")
-        return X, y, feature_scaler, target_scaler, full_features, target_idx, pca, updated_feature_cols
+        return X, y, feature_scaler, target_scaler, full_features, target_idx, None, updated_feature_cols
     except Exception as e:
-        print_log(f"Preprocessing error: {str(e)}", "ERROR")
-        raise
+        print_log(f"Preprocessing error: {str(e)}", 'ERROR')
+        raise ValueError(f"Preprocessing failed: {str(e)}")
+

core/models.py

@@ -1,5 +1,6 @@
 # core/models.py
 import torch
+import logging
 import torch.nn as nn
 import math
 
@@ -31,7 +32,9 @@ class LSTMModel(nn.Module):
         self.dropout = nn.Dropout(dropout)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -62,7 +65,9 @@ class GRUModel(nn.Module):
         self.dropout = nn.Dropout(dropout)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -85,7 +90,9 @@ class CNNModel(nn.Module):
         self.fc = nn.Linear(hidden_size, output_size)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -114,7 +121,9 @@ class MLPModel(nn.Module):
         self.mlp = nn.Sequential(*layers)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -133,7 +142,9 @@ class HybridCNNGRUModel(nn.Module):
         self.dropout = nn.Dropout(dropout)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -160,7 +171,9 @@ class TransformerModel(nn.Module):
         self.fc = nn.Linear(hidden_size, output_size)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(
@@ -190,7 +203,9 @@ class BiLSTMModel(nn.Module):
         self.dropout = nn.Dropout(dropout)
 
     def forward(self, x):
+        logging.debug(f"Inside forward: initial x type={type(x)}, x={x}")
         if isinstance(x, (tuple, list)):
+            logging.debug(f"Model forward received tuple/list: type={type(x)}, length={len(x)}")
             x = x[0]
         if not isinstance(x, torch.Tensor):
             x = torch.tensor(

core/plot.py

@@ -2,14 +2,9 @@ import plotly.graph_objects as go
 import plotly.express as px
 import pandas as pd
 import logging
-
-logging.basicConfig(level=logging.DEBUG, filename="debug.log", filemode="a")
-
-import plotly.graph_objects as go
+import matplotlib.pyplot as plt
 from plotly.subplots import make_subplots
-import pandas as pd
 import numpy as np
-import logging
 
 logging.basicConfig(level=logging.INFO)
 
@@ -27,55 +22,31 @@ def plot_indicators(df, ticker):
         # Price and Moving Averages
         fig.add_trace(
             go.Candlestick(
-                x=df['Date'], open=df['Open'], high=df['High'], low=df['Low'], close=df['value'],
+                x=df.index, open=df['Open'], high=df['High'], low=df['Low'], close=df['value'],
                 name='Price', increasing_line_color='#00CC96', decreasing_line_color='#EF553B'
             ), row=1, col=1
         )
         for ma in ['sma_10', 'sma_20', 'sma_50', 'ema_12', 'ema_26', 'ema_50']:
             if ma in df:
                 fig.add_trace(
-                    go.Scatter(x=df['Date'], y=df[ma], name=ma.upper(), line=dict(width=1.5)),
+                    go.Scatter(x=df.index, y=df[ma], name=ma.upper(), line=dict(width=1.5)),
                     row=1, col=1
                 )
         if 'bbu_20_2' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['bbu_20_2'], name='BB Upper', line=dict(color='gray', dash='dot')),
+                go.Scatter(x=df.index, y=df['bbu_20_2'], name='BB Upper', line=dict(color='gray', dash='dot')),
                 row=1, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['bbm_20_2'], name='BB Middle', line=dict(color='gray')),
+                go.Scatter(x=df.index, y=df['bbm_20_2'], name='BB Middle', line=dict(color='gray')),
                 row=1, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['bbl_20_2'], name='BB Lower', line=dict(color='gray', dash='dot')),
+                go.Scatter(x=df.index, y=df["bbl_20_2"], name="BB Lower", line=dict(color="gray", dash="dot")),
                 row=1, col=1
             )
 
-        # Enhanced Signal Plotting
-        buy_signals = df[df['Signal'] == 'Buy']
-        sell_signals = df[df['Signal'] == 'Sell']
-        hold_signals = df[df['Signal'] == 'Hold']
-        fig.add_trace(
-            go.Scatter(
-                x=buy_signals['Date'], y=buy_signals['value'], mode='markers+text',
-                name='Buy', marker=dict(symbol='triangle-up', size=12, color='green'),
-                text=['Buy'] * len(buy_signals), textposition='top center'
-            ), row=1, col=1
-        )
-        fig.add_trace(
-            go.Scatter(
-                x=sell_signals['Date'], y=sell_signals['value'], mode='markers+text',
-                name='Sell', marker=dict(symbol='triangle-down', size=12, color='red'),
-                text=['Sell'] * len(sell_signals), textposition='bottom center'
-            ), row=1, col=1
-        )
-        fig.add_trace(
-            go.Scatter(
-                x=hold_signals['Date'], y=hold_signals['value'], mode='markers',
-                name='Hold', marker=dict(symbol='circle', size=8, color='gray'),
-                opacity=0.5
-            ), row=1, col=1
-        )
+
 
         # Position Size and Risk Annotation
         if 'atr_14' in df:
@@ -90,57 +61,57 @@ def plot_indicators(df, ticker):
 
         # Volume
         fig.add_trace(
-            go.Bar(x=df['Date'], y=df['Volume'], name='Volume', marker_color='blue', opacity=0.5),
+            go.Bar(x=df.index, y=df["Volume"], name="Volume", marker_color="blue", opacity=0.5),
             row=2, col=1
         )
 
         # MACD & RSI
         if 'macd_12_26_9' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['macd_12_26_9'], name='MACD', line=dict(color='blue')),
+                go.Scatter(x=df.index, y=df['macd_12_26_9'], name='MACD', line=dict(color='blue')),
                 row=3, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['macds_12_26_9'], name='MACD Signal', line=dict(color='orange')),
+                go.Scatter(x=df.index, y=df["macds_12_26_9"], name="MACD Signal", line=dict(color="orange")),
                 row=3, col=1
             )
             fig.add_trace(
-                go.Bar(x=df['Date'], y=df['macdh_12_26_9'], name='MACD Hist', marker_color='gray'),
+                go.Bar(x=df.index, y=df["macdh_12_26_9"], name="MACD Hist", marker_color="gray"),
                 row=3, col=1
             )
         if 'rsi_14' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['rsi_14'], name='RSI 14', line=dict(color='purple')),
+                go.Scatter(x=df.index, y=df["rsi_14"], name="RSI 14", line=dict(color="purple")),
                 row=3, col=1
             )
             fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
             fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1)
         if 'rsi_21' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['rsi_21'], name='RSI 21', line=dict(color='magenta', dash='dash')),
+                go.Scatter(x=df.index, y=df["rsi_21"], name="RSI 21", line=dict(color="magenta", dash="dash")),
                 row=3, col=1
             )
         if 'rsi_50' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['rsi_50'], name='RSI 50', line=dict(color='cyan', dash='dot')),
+                go.Scatter(x=df.index, y=df["rsi_50"], name="RSI 50", line=dict(color="cyan", dash="dot")),
                 row=3, col=1
             )
 
         # Stochastic & Williams %R
         if 'stochk_14_3_3' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['stochk_14_3_3'], name='Stoch %K', line=dict(color='blue')),
+                go.Scatter(x=df.index, y=df["stochk_14_3_3"], name="Stoch %K", line=dict(color="blue")),
                 row=4, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['stochd_14_3_3'], name='Stoch %D', line=dict(color='orange')),
+                go.Scatter(x=df.index, y=df["stochd_14_3_3"], name="Stoch %D", line=dict(color="orange")),
                 row=4, col=1
             )
             fig.add_hline(y=80, line_dash="dash", line_color="red", row=4, col=1)
             fig.add_hline(y=20, line_dash="dash", line_color="green", row=4, col=1)
         if 'willr_14' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['willr_14'], name='Williams %R', line=dict(color='green')),
+                go.Scatter(x=df.index, y=df["willr_14"], name="Williams %R", line=dict(color="green")),
                 row=4, col=1
             )
             fig.add_hline(y=-20, line_dash="dash", line_color="red", row=4, col=1)
@@ -149,15 +120,15 @@ def plot_indicators(df, ticker):
         # ADX & DI
         if 'adx_14' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['adx_14'], name='ADX', line=dict(color='blue')),
+                go.Scatter(x=df.index, y=df['adx_14'], name='ADX', line=dict(color='blue')),
                 row=5, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df.get('pdi_14'), name='+DI', line=dict(color='green')),
+                go.Scatter(x=df.index, y=df.get('pdi_14'), name='+DI', line=dict(color='green')),
                 row=5, col=1
             )
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df.get('mdi_14'), name='-DI', line=dict(color='red')),
+                go.Scatter(x=df.index, y=df.get('mdi_14'), name='-DI', line=dict(color='red')),
                 row=5, col=1
             )
             fig.add_hline(y=25, line_dash="dash", line_color="black", row=5, col=1)
@@ -165,12 +136,12 @@ def plot_indicators(df, ticker):
         # ATR & CCI
         if 'atr_14' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['atr_14'], name='ATR', line=dict(color='orange')),
+                go.Scatter(x=df.index, y=df["atr_14"], name="ATR", line=dict(color="orange")),
                 row=6, col=1
             )
         if 'cci_20' in df:
             fig.add_trace(
-                go.Scatter(x=df['Date'], y=df['cci_20'], name='CCI', line=dict(color='purple')),
+                go.Scatter(x=df.index, y=df["cci_20"], name="CCI", line=dict(color="purple")),
                 row=6, col=1
             )
             fig.add_hline(y=100, line_dash="dash", line_color="red", row=6, col=1)
@@ -187,7 +158,7 @@ def plot_indicators(df, ticker):
             )
             fig.add_trace(
                 go.Scatter(
-                    x=df['Date'], y=signal_strength, name='Signal Strength',
+                    x=df.index, y=signal_strength, name='Signal Strength',
                     line=dict(color='teal'), fill='tozeroy'
                 ), row=7, col=1
             )
@@ -212,15 +183,15 @@ def plot_indicators(df, ticker):
         return None
 def plot_future_forecast(df, result, indicators):
     fig, ax = plt.subplots(figsize=(10, 6))
-    ax.plot(df['Date'], df['Close'], label="Historical Close", color="blue", linewidth=2)
+    ax.plot(df.index, df["value"], label="Historical Value", color="blue", linewidth=2)
     for ind in indicators:
         if ind in df.columns:
-            ax.plot(df['Date'], df[ind], label=ind, linestyle='--')
+            ax.plot(df.index, df[ind], label=ind, linestyle='--')
     if "latest_prediction" in result:
-        last_date = df['Date'].iloc[-1]
+        last_date = df.index[-1]
         horizon = len(result["latest_prediction"])
         future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=horizon, freq='B')
-        ax.plot(future_dates, result["latest_prediction"], label="Forecast Close", color="orange", linestyle="--", linewidth=2)
+        ax.plot(future_dates, result["latest_prediction"], label="Forecast Value", color="orange", linestyle="--", linewidth=2)
         for i, val in enumerate(result["latest_prediction"]):
             ax.text(future_dates[i], val, f"{val:.2f}", color="orange")
     ax.legend()
@@ -238,7 +209,7 @@ def plot_forecast(result, df):
         forecast = result.get("forecast", [])
         if not actual or not forecast:
             return None
-        dates = df['Date'].iloc[-len(actual):]
+        dates = df.index[-len(actual):]
         fig = go.Figure()
         fig.add_trace(go.Scatter(x=dates, y=actual, name='Actual', line=dict(color='blue')))
         fig.add_trace(go.Scatter(x=dates, y=forecast, name='Forecast', line=dict(color='orange')))
@@ -423,8 +394,7 @@ def plot_model_architecture(result):
             xaxis=dict(visible=False),
             yaxis=dict(visible=False),
             plot_bgcolor="white",
-            paper_bgcolor="white",
-            margin=dict(l=20, r=20, t=50, b=20)
+            paper_bgcolor="white"
         )
         return fig
     except Exception as e:
@@ -433,40 +403,88 @@ def plot_model_architecture(result):
 
 def plot_signals(signals_df, ticker):
     try:
-        logging.debug(f"Plotting signals for {ticker}")
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=signals_df.index, y=signals_df['Price'], mode='lines', name='Price', line=dict(color='blue')))
+        fig.add_trace(go.Scatter(
+            x=signals_df.index,
+            y=signals_df['Price'],
+            mode='lines',
+            name='Price'
+        ))
         buy_signals = signals_df[signals_df['Signal'] == 'Buy']
         sell_signals = signals_df[signals_df['Signal'] == 'Sell']
-        fig.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Price'], mode='markers', name='Buy', marker=dict(symbol='triangle-up', size=10, color='green')))
-        fig.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Price'], mode='markers', name='Sell', marker=dict(symbol='triangle-down', size=10, color='red')))
+
+        fig.add_trace(go.Scatter(
+            x=buy_signals.index,
+            y=buy_signals['Price'],
+            mode='markers',
+            marker=dict(symbol='triangle-up', size=10, color='green'),
+            name='Buy Signal'
+        ))
+        fig.add_trace(go.Scatter(
+            x=sell_signals.index,
+            y=sell_signals['Price'],
+            mode='markers',
+            marker=dict(symbol='triangle-down', size=10, color='red'),
+            name='Sell Signal'
+        ))
+
         fig.update_layout(
-            title=f"{ticker} Trading Signals",
-            xaxis_title="Date",
-            yaxis_title="Price",
-            template="plotly_dark",
-            showlegend=True
+            title=f'{ticker} Trading Signals',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            template="plotly_white",
+            xaxis_rangeslider_visible=False
         )
-        logging.info(f"Signals plot generated for {ticker}")
         return fig
     except Exception as e:
-        logging.error(f"Error in plot_signals: {str(e)}")
-        return go.Figure()
+        logging.error(f"Plot signals error: {e}")
+        return None
 
-def plot_backtest(signals_df, df, ticker):
+def plot_backtest(equity_df, trades_df, ticker):
     try:
-        logging.debug(f"Plotting backtest for {ticker}")
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=df['Date'], y=signals_df['Equity'], mode='lines', name='Equity', line=dict(color='purple')))
+        fig.add_trace(go.Scatter(
+            x=equity_df.index,
+            y=equity_df['Equity'],
+            mode='lines',
+            name='Equity Curve'
+        ))
+
+        buy_trades = trades_df[trades_df['Type'] == 'Buy']
+        sell_trades = trades_df[trades_df['Type'] == 'Sell']
+        exit_trades = trades_df[trades_df['Type'] == 'Exit']
+
+        fig.add_trace(go.Scatter(
+            x=buy_trades['Date'],
+            y=buy_trades['Price'],
+            mode='markers',
+            marker=dict(symbol='triangle-up', size=10, color='green'),
+            name='Buy Trades'
+        ))
+        fig.add_trace(go.Scatter(
+            x=sell_trades['Date'],
+            y=sell_trades['Price'],
+            mode='markers',
+            marker=dict(symbol='triangle-down', size=10, color='red'),
+            name='Sell Trades'
+        ))
+        fig.add_trace(go.Scatter(
+            x=exit_trades['Date'],
+            y=exit_trades['Price'],
+            mode='markers',
+            marker=dict(symbol='circle', size=8, color='blue'),
+            name='Exit Trades'
+        ))
+
         fig.update_layout(
-            title=f"{ticker} Backtest Equity Curve",
-            xaxis_title="Date",
-            yaxis_title="Equity",
-            template="plotly_dark",
-            showlegend=True
+            title=f'{ticker} Backtest Equity Curve and Trades',
+            xaxis_title='Date',
+            yaxis_title='Equity / Price',
+            template="plotly_white",
+            xaxis_rangeslider_visible=False
         )
-        logging.info(f"Backtest plot generated for {ticker}")
         return fig
     except Exception as e:
-        logging.error(f"Error in plot_backtest: {str(e)}")
-        return go.Figure()
+        logging.error(f"Plot backtest error: {e}")
+        return None
+

core/signals.py

@@ -7,19 +7,19 @@ logging.basicConfig(level=logging.DEBUG, filename="debug.log", filemode="a")
 def generate_signals(df, result, volatility_window=14):
     try:
         signals_df = pd.DataFrame(index=df.index)
-        signals_df['Price'] = df['value']
-        signals_df['Signal'] = 'Hold'
-        signals_df['Position_Size'] = 0.0
-        signals_df['Stop_Loss'] = np.nan
-        signals_df['Take_Profit'] = np.nan
-
-        rsi_key = 'rsi_14'
-        macd_key = 'macdh_12_26_9'
-        adx_key = 'adx_14'
-        pdi_key = 'pdi_14'
-        mdi_key = 'mdi_14'
-        atr_key = 'atr_14'
-        sentiment_key = 'sentiment'
+        signals_df["Price"] = df["value"]
+        signals_df["Signal"] = "Hold"
+        signals_df["Position_Size"] = 0.0
+        signals_df["Stop_Loss"] = np.nan
+        signals_df["Take_Profit"] = np.nan
+
+        rsi_key = "rsi_14"
+        macd_key = "macdh_12_26_9"
+        adx_key = "adx_14"
+        pdi_key = "pdi_14"
+        mdi_key = "mdi_14"
+        atr_key = "atr_14"
+        sentiment_key = "sentiment"
 
         for i in range(1, len(df)):
             vote = 0
@@ -29,14 +29,14 @@ def generate_signals(df, result, volatility_window=14):
                 rsi = df[rsi_key].iloc[i]
                 rsi_signal = 1 if rsi < 50 else -1 if rsi > 50 else 0
                 vote += rsi_signal
-                logging.debug(f"RSI at {df['Date'].iloc[i]}: value={rsi:.2f}, signal={rsi_signal}")
+                logging.debug(f"RSI at {df.index[i]}: value={rsi:.2f}, signal={rsi_signal}")
 
             if macd_key in df.columns and not pd.isna(df[macd_key].iloc[i]):
                 macd = df[macd_key].iloc[i]
                 macd_prev = df[macd_key].iloc[i-1] if i > 0 else 0
                 macd_signal = 1 if macd > 0 and macd_prev <= 0 else -1 if macd < 0 and macd_prev >= 0 else 0
                 vote += macd_signal
-                logging.debug(f"MACD at {df['Date'].iloc[i]}: value={macd:.2f}, prev={macd_prev:.2f}, signal={macd_signal}")
+                logging.debug(f"MACD at {df.index[i]}: value={macd:.2f}, prev={macd_prev:.2f}, signal={macd_signal}")
 
             if adx_key in df.columns and pdi_key in df.columns and mdi_key in df.columns:
                 adx = df[adx_key].iloc[i]
@@ -45,43 +45,45 @@ def generate_signals(df, result, volatility_window=14):
                 if not pd.isna(adx) and adx > 20:
                     adx_signal = 1 if pdi > mdi else -1 if mdi > pdi else 0
                     vote += adx_signal
-                logging.debug(f"ADX at {df['Date'].iloc[i]}: adx={adx:.2f}, pdi={pdi:.2f}, mdi={mdi:.2f}, signal={adx_signal}")
+                logging.debug(f"ADX at {df.index[i]}: adx={adx:.2f}, pdi={pdi:.2f}, mdi={mdi:.2f}, signal={adx_signal}")
 
             if sentiment_key in df.columns and not pd.isna(df[sentiment_key].iloc[i]):
                 sentiment = df[sentiment_key].iloc[i]
                 sentiment_signal = 1 if sentiment > 0.1 else -1 if sentiment < -0.1 else 0
                 vote += sentiment_signal
-                logging.debug(f"Sentiment at {df['Date'].iloc[i]}: value={sentiment:.2f}, signal={sentiment_signal}")
+                logging.debug(f"Sentiment at {df.index[i]}: value={sentiment:.2f}, signal={sentiment_signal}")
 
-            if 'forecast' in result and len(result['forecast']) > i:
-                forecast = result['forecast'][i]
-                actual = df['value'].iloc[i]
+            if "forecast" in result and len(result["forecast"]) > i:
+                forecast = result["forecast"][i]
+                actual = df["value"].iloc[i]
                 model_signal = 1 if forecast > actual * 1.01 else -1 if forecast < actual * 0.99 else 0
                 vote += model_signal
-                logging.debug(f"Model at {df['Date'].iloc[i]}: forecast={forecast:.2f}, actual={actual:.2f}, signal={model_signal}")
+                logging.debug(f"Model at {df.index[i]}: forecast={forecast:.2f}, actual={actual:.2f}, signal={model_signal}")
 
-            signals_df.loc[df.index[i], 'Signal'] = 'Buy' if vote >= 2 else 'Sell' if vote <= -2 else 'Hold'
-            signals_df.loc[df.index[i], 'Position_Size'] = min(0.1 * abs(vote), 1.0)
+            signals_df.loc[df.index[i], "Signal"] = "Buy" if vote >= 2 else "Sell" if vote <= -2 else "Hold"
+            signals_df.loc[df.index[i], "Position_Size"] = min(0.1 * abs(vote), 1.0)
 
             if atr_key in df.columns and not pd.isna(df[atr_key].iloc[i]):
                 atr = df[atr_key].iloc[i]
-                signals_df.loc[df.index[i], 'Stop_Loss'] = df['value'].iloc[i] - 2 * atr if vote >= 2 else df['value'].iloc[i] + 2 * atr if vote <= -2 else np.nan
-                signals_df.loc[df.index[i], 'Take_Profit'] = df['value'].iloc[i] + 3 * atr if vote >= 2 else df['value'].iloc[i] - 3 * atr if vote <= -2 else np.nan
+                signals_df.loc[df.index[i], "Stop_Loss"] = df["value"].iloc[i] - 2 * atr if vote >= 2 else df["value"].iloc[i] + 2 * atr if vote <= -2 else np.nan
+                signals_df.loc[df.index[i], "Take_Profit"] = df["value"].iloc[i] + 3 * atr if vote >= 2 else df["value"].iloc[i] - 3 * atr if vote <= -2 else np.nan
 
-            logging.debug(f"Signal at {df['Date'].iloc[i]}: RSI={rsi_signal}, MACD={macd_signal}, ADX={adx_signal}, Sentiment={sentiment_signal}, Model={model_signal}, Vote={vote}, Signal={signals_df['Signal'].iloc[i]}")
+            current_signal = signals_df.iloc[i]["Signal"]
+            logging.debug(f"Signal at {df.index[i]}: RSI={rsi_signal}, MACD={macd_signal}, ADX={adx_signal}, Sentiment={sentiment_signal}, Model={model_signal}, Vote={vote}, Signal={current_signal}")
 
         trades_df, equity_df = backtest_signals(signals_df, df)
-        signals_df['Equity'] = equity_df['Equity']
+        signals_df["Equity"] = equity_df["Equity"]
 
-        signal_counts = signals_df['Signal'].value_counts().to_dict()
+        signal_counts = signals_df["Signal"].value_counts().to_dict()
         total = sum(signal_counts.values())
         signal_dist = {k: f"{v} ({v/total*100:.2f}%)" for k, v in signal_counts.items()}
-        logging.info(f"Signal distribution: {', '.join([f'{k}={v}' for k, v in signal_dist.items()])}")
+        signal_dist_str = ", ".join([f'{k}={v}' for k, v in signal_dist.items()])
+        logging.info(f"Signal distribution: {signal_dist_str}")
         logging.info(f"Signals generated: {signal_counts}")
-        return signals_df
+        return signals_df, trades_df, equity_df
     except Exception as e:
         logging.error(f"Error in generate_signals: {e}")
-        return pd.DataFrame()
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
 def backtest_signals(signals_df, df, initial_balance=10000):
     try:
@@ -91,39 +93,50 @@ def backtest_signals(signals_df, df, initial_balance=10000):
         equity_curve = [balance]
         entry_price = 0
         
-        for i, row in signals_df.iterrows():
-            price = row['Price']
-            signal = row['Signal']
-            position_size = row['Position_Size']
-            stop_loss = row['Stop_Loss']
-            take_profit = row['Take_Profit']
-            
-            if signal == 'Buy' and position == 0:
-                shares = position_size * balance / price
-                position = shares
-                entry_price = price
-                trades.append({'Date': df['Date'].iloc[i], 'Type': 'Buy', 'Price': price, 'Shares': shares})
-                logging.debug(f"Buy at {price:.2f}, Shares: {shares:.2f}")
-            
-            elif signal == 'Sell' and position > 0:
-                balance += position * (price - entry_price)
-                trades.append({'Date': df['Date'].iloc[i], 'Type': 'Sell', 'Price': price, 'Shares': position, 'Profit': position * (price - entry_price)})
-                position = 0
-                logging.debug(f"Sell at {price:.2f}, Profit: {trades[-1]['Profit']:.2f}")
-            
-            if position > 0 and not pd.isna(stop_loss) and not pd.isna(take_profit):
-                if price <= stop_loss or price >= take_profit:
+        # Iterate through the original DataFrame's index to ensure equity_curve aligns
+        for idx, row in df.iterrows():
+            # Find the corresponding signal for this date
+            signal_row = signals_df.loc[idx] if idx in signals_df.index else None
+
+            if signal_row is not None:
+                price = signal_row["Price"]
+                signal = signal_row["Signal"]
+                position_size = signal_row["Position_Size"]
+                stop_loss = signal_row["Stop_Loss"]
+                take_profit = signal_row["Take_Profit"]
+                
+                if signal == "Buy" and position == 0:
+                    shares = position_size * balance / price
+                    position = shares
+                    entry_price = price
+                    trades.append({"Date": str(idx.date()), "Type": "Buy", "Price": price, "Shares": shares})
+                    logging.debug(f"Buy at {price:.2f}, Shares: {shares:.2f}")
+                
+                elif signal == "Sell" and position > 0:
                     balance += position * (price - entry_price)
-                    trades.append({'Date': df['Date'].iloc[i], 'Type': 'Exit', 'Price': price, 'Shares': position, 'Profit': position * (price - entry_price)})
+                    trades.append({"Date": str(idx.date()), "Type": "Sell", "Price": price, "Shares": position, "Profit": position * (price - entry_price)})
                     position = 0
-                    logging.debug(f"Exit at {price:.2f}, Profit: {trades[-1]['Profit']:.2f}")
+                    profit_val = trades[-1]["Profit"]
+                    logging.debug(f"Sell at {price:.2f}, Profit: {profit_val:.2f}")
+                
+                if position > 0 and not pd.isna(stop_loss) and not pd.isna(take_profit):
+                    if price <= stop_loss or price >= take_profit:
+                        balance += position * (price - entry_price)
+                        trades.append({"Date": str(idx.date()), "Type": "Exit", "Price": price, "Shares": position, "Profit": position * (price - entry_price)})
+                        position = 0
+                        profit_val = trades[-1]["Profit"]
+                        logging.debug(f"Exit at {price:.2f}, Profit: {profit_val:.2f}")
             
-            equity_curve.append(balance + position * (price - entry_price) if position > 0 else balance)
+            current_equity = balance + position * (row["value"] - entry_price) if position > 0 else balance
+            equity_curve.append(current_equity)
         
+        # The first element of equity_curve is the initial balance, remove it to align with df.index
+        equity_curve = equity_curve[1:]
+
         trades_df = pd.DataFrame(trades)
-        equity_df = pd.DataFrame({'Date': df['Date'], 'Equity': equity_curve[:len(df)]})
+        equity_df = pd.DataFrame({"Equity": equity_curve}, index=df.index)
         logging.info(f"Backtest completed: {len(trades)} trades, Final Balance: {balance:.2f}")
         return trades_df, equity_df
     except Exception as e:
         logging.error(f"Backtest error: {e}")
-        return pd.DataFrame(), pd.DataFrame()
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame()

core/train_eval.py

@@ -152,7 +152,7 @@ def train_and_evaluate(
         logging.info(f"Selected features: {selected_features}")
         
         X, y, feature_scaler, target_scaler, full_features, target_idx, pca, updated_feature_cols = preprocess_data(df, selected_features, target, window, horizon)
-        logging.debug(f"Preprocess: type(X)={type(X)}, X_shape={X.shape if isinstance(X, np.ndarray) else 'not ndarray'}, type(y)={type(y)}, y_shape={y.shape if isinstance(y, np.ndarray) else 'not ndarray'}")
+        logging.debug(f"Preprocess: type(X)={type(X)}, example={X if isinstance(X, tuple) else X.shape}, type(y)={type(y)}, example={y if isinstance(y, tuple) else y.shape}")
         
         if X.shape[0] < 10:
             logging.error(f"Insufficient data samples: {X.shape[0]}")
@@ -184,15 +184,15 @@ def train_and_evaluate(
         model = model_cls(input_size=input_size, hidden_size=hidden, num_layers=layers, output_size=horizon, dropout=dropout).to(device)
         logging.debug(f"Model initialized: {model_cls.__name__}, input_size={input_size}, hidden={hidden}, layers={layers}")
 
-        if verbose and summary:
-            try:
-                output = StringIO()
-                sys.stdout = output
-                summary(model, input_size=(window, input_size))
-                sys.stdout = sys.__stdout__
-                logging.debug(f"Model summary:\n{output.getvalue()}")
-            except Exception as e:
-                logging.warning(f"Failed to generate model summary: {str(e)}")
+        # if verbose and summary:
+        #     try:
+        #         output = StringIO()
+        #         sys.stdout = output
+        #         summary(model, input_size=(window, input_size))
+        #         sys.stdout = sys.__stdout__
+        #         logging.debug(f"Model summary:\n{output.getvalue()}")
+        #     except Exception as e:
+        #         logging.warning(f"Failed to generate model summary: {str(e)}")
 
         optimizer = optim.Adam(model.parameters(), lr=lr, betas=(beta1, beta2), weight_decay=weight_decay)
         criterion = nn.MSELoss()
@@ -213,7 +213,7 @@ def train_and_evaluate(
                 logging.debug(f"Training Batch_X type: {type(batch_X)}, shape: {batch_X.shape}")
                 logging.debug(f"Training Batch_Y type: {type(batch_y)}, shape: {batch_y.shape}")
                 optimizer.zero_grad()
-                logging.debug(f"Training input to model: type={type(batch_X)}, shape={batch_X.shape}")
+                logging.debug(f"Training input to model: type={type(batch_X)}, example={batch_X if isinstance(batch_X, tuple) else batch_X.shape}")
                 try:
                     outputs = model(batch_X)
                     logging.debug(f"Training model output shape: {outputs.shape}")
@@ -233,7 +233,7 @@ def train_and_evaluate(
                 for batch_X, batch_y in test_loader:
                     logging.debug(f"Validation Batch_X type: {type(batch_X)}, shape: {batch_X.shape}")
                     logging.debug(f"Validation Batch_Y type: {type(batch_y)}, shape: {batch_y.shape}")
-                    logging.debug(f"Validation input to model: type={type(batch_X)}, shape={batch_X.shape}")
+                    logging.debug(f"Validation input to model: type={type(batch_X)}, example={batch_X if isinstance(batch_X, tuple) else batch_X.shape}")
                     try:
                         outputs = model(batch_X)
                         logging.debug(f"Validation model output shape: {outputs.shape}")
@@ -256,7 +256,7 @@ def train_and_evaluate(
         model.eval()
         with torch.no_grad():
             X_test_tensor = torch.tensor(X_test, dtype=torch.float32).to(device)
-            logging.debug(f"Eval model call: type={type(X_test_tensor)}, shape={X_test_tensor.shape}")
+            logging.debug(f"Eval model call: type={type(X_test_tensor)}, example={X_test_tensor if isinstance(X_test_tensor, tuple) else X_test_tensor.shape}")
             try:
                 y_pred_scaled = model(X_test_tensor).cpu().numpy()
                 logging.debug(f"Eval model output shape: {y_pred_scaled.shape}")

test_app.py

@@ -0,0 +1,164 @@
+
+import pandas as pd
+import numpy as np
+import os
+from datetime import datetime, timedelta
+import logging
+from core.data import load_data, add_technical_indicators, add_sentiment, preprocess_data
+from core.model_runner import get_model
+from core.plot import plot_forecast, plot_metrics_r2, plot_metrics_errors, plot_metrics_precision_recall, plot_metrics_risk, plot_loss_curve, plot_model_architecture, plot_future_forecast, plot_indicators, plot_signals, plot_backtest
+import plotly.io as pio
+from core.signals import generate_signals
+from config import AVAILABLE_MODELS, DEFAULT_TICKERS, AVAILABLE_TIMEFRAMES, AVAILABLE_INDICATORS
+from newsapi import NewsApiClient
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+
+log_path = "/tmp/app_log.txt"
+os.makedirs("/tmp", exist_ok=True)
+logging.basicConfig(
+    level=logging.DEBUG,
+    handlers=[
+        logging.FileHandler(log_path),
+        logging.StreamHandler()
+    ],
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+analyzer = SentimentIntensityAnalyzer()
+
+def sentiment_analysis(ticker, start_date, end_date, api_key):
+    try:
+        if not api_key:
+            return "No API key provided", None
+        newsapi = NewsApiClient(api_key=api_key)
+        start = pd.to_datetime(start_date)
+        end = pd.to_datetime(end_date)
+        articles = newsapi.get_everything(
+            q=ticker, from_param=start.strftime("%Y-%m-%d"), to=end.strftime("%Y-%m-%d"), 
+            language='en', sort_by='relevancy'
+        )
+        sentiments = [analyzer.polarity_scores(article["title"])["compound"] for article in articles["articles"]]
+        avg_sentiment = np.mean(sentiments) if sentiments else 0.0
+        sentiment_text = f"Average sentiment for {ticker}: {avg_sentiment:.2f}"
+        return sentiment_text, avg_sentiment
+    except Exception as e:
+        logging.error(f"Sentiment analysis failed: {str(e)}")
+        return f"Sentiment analysis failed: {str(e)}", None
+
+def run_dashboard_test():
+    print("Starting run_dashboard_test...")
+    try:
+        # Sample parameters for run_dashboard
+        data_src = "yahoo"
+        ticker = "AAPL"
+        file_upload = None
+        timeframe = "1d"
+        start_date = "2020-01-01"
+        end_date = "2023-01-01"
+        horizon = 1
+        indicators = ["rsi", "macd", "bbands"]
+        include_sentiment = False
+        news_api_key = None # Replace with your News API key if testing sentiment
+        alpha_api_key = None # Replace with your Alpha Vantage API key if testing intraday
+        account_size = 10000
+        risk_percent = 0.01
+        model = "LSTM"
+        hidden_units = 64
+        n_layers = 1
+        epochs = 10 # Reduced for faster testing
+        learning_rate = 0.001
+        beta1 = 0.9
+        beta2 = 0.999
+        weight_decay = 0.01
+        dropout = 0.2
+        window_size = 30
+        test_split = 0.2
+        rsi_mid = 50
+        macd_sens = 0.0
+        adx_thr = 20
+        sent_thr = 0.1
+        vote_buy = 2
+        vote_sell = -2
+        feat_selector = "RandomForest"
+        feat_threshold = 0.0
+
+        print(f"Loading data for {ticker}...")
+        df = load_data(data_src=data_src, ticker=ticker, start=start_date, end=end_date, 
+                       interval=timeframe, file_upload=file_upload, alpha_api_key=alpha_api_key)
+        print(f"Data loaded. Shape: {df.shape}")
+
+        print("Adding technical indicators...")
+        df, valid_indicators = add_technical_indicators(df, indicators)
+        # Update the indicators list to use only valid ones for the model
+        indicators = valid_indicators
+        print(f"Indicators added. Shape: {df.shape}")
+
+        if include_sentiment and news_api_key:
+            print("Adding sentiment data...")
+            df = add_sentiment(df, ticker, news_api_key, start_date, end_date)
+            print(f"Sentiment added. Shape: {df.shape}")
+        sentiment_text, sentiment_score = sentiment_analysis(ticker, start_date, end_date, news_api_key)
+        print(f"Sentiment analysis result: {sentiment_text}")
+
+        print("Getting model...")
+        result = get_model(
+            df=df,
+            features=indicators,
+            target='value',
+            model_name=model,
+            horizon=horizon,
+            hidden_units=hidden_units,
+            n_layers=n_layers,
+            epochs=epochs,
+            learning_rate=learning_rate,
+            beta1=beta1,
+            beta2=beta2,
+            weight_decay=weight_decay,
+            dropout=dropout,
+            window_size=window_size,
+            test_split=test_split,
+            selector_method=feat_selector,
+            importance_threshold=feat_threshold
+        )
+        if isinstance(result, dict) and result.get("error"):
+            print(f"Model training failed: {result['error']}")
+            return
+        print("Model obtained.")
+
+        print("Generating signals...")
+        signals_df, trades_df, equity_df = generate_signals(df, result)
+        if signals_df.empty: # signals_df is the DataFrame after unpacking
+            print("Failed to generate signals")
+            return
+        print(f"Signals generated. Shape: {signals_df.shape}")
+
+        # Just print confirmation for plots, actual plot generation is not needed for local test
+        print("Generating plots...")
+        chart_plot = plot_indicators(df, ticker)
+
+        signals_plot = plot_signals(signals_df, ticker)
+
+        backtest_plot = plot_backtest(equity_df, trades_df, ticker)
+
+        future_plot = plot_future_forecast(df, result, indicators)
+        future_table = pd.DataFrame({
+            'Date': [df.index[-1] + timedelta(days=i+1) for i in range(horizon)],
+            'Prediction': result["latest_prediction"]
+        })
+        signals_table = signals_df.reset_index()[['Date', 'Price', 'Signal', 'Position_Size', 'Stop_Loss', 'Take_Profit', 'Equity']]
+        r2_plot = plot_metrics_r2(result)
+        error_plot = plot_metrics_errors(result)
+        precision_recall_plot = plot_metrics_precision_recall(result)
+        risk_plot = plot_metrics_risk(result)
+        loss_plot = plot_loss_curve(result)
+        architecture_plot = plot_model_architecture(result)
+        print("Plots generated.")
+
+        print("Dashboard run completed successfully.")
+
+    except Exception as e:
+        logging.error(f"Dashboard test error: {str(e)}")
+        print(f"Dashboard test error: {str(e)}")
+
+if __name__ == "__main__":
+    run_dashboard_test()
+