update app 1.5

app.py

@@ -1,25 +1,29 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import yfinance as yf
 from datetime import datetime, timedelta
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import warnings
+import yfinance as yf
+from typing import Dict, List, Tuple
+import atexit
+
 warnings.filterwarnings('ignore')
 
 from models import load_timesfm_model, predict_stock_prices
 from utils import (
     get_idx_stocks, fetch_stock_data, prepare_timesfm_data,
-    calculate_metrics, create_forecast_plot, get_stock_info
+    create_forecast_plot, get_stock_info, market_status_manager,
+    calculate_technical_indicators
 )
-from config import IDX_STOCKS, DEFAULT_PERIOD, DEFAULT_FORECAST_HORIZON
+from config import IDX_STOCKS, DEFAULT_PERIOD, DEFAULT_FORECAST_HORIZON, IDX_MARKET_CONFIG
 
 # Load model at startup
 model = None
 
 def load_model():
-    """Load the Chronos pipeline (named load_timesfm_model for compatibility)"""
+    """Load the Chronos Pipeline"""
     global model
     if model is None:
         model = load_timesfm_model()
@@ -29,24 +33,38 @@ def get_stock_choices():
     """Get available stock choices for dropdown"""
     return list(IDX_STOCKS.keys())
 
+def get_idx_market_status() -> str:
+    """Get formatted IDX market status for display"""
+    status = market_status_manager.get_status('IDX_STOCKS')
+    status_emoji = "🟢" if status.is_open else "🔴"
+    status_text = "BUKA" if status.is_open else "TUTUP"
+    
+    info_lines = [
+        f"**Status Saat Ini:** {status.status_text} (WIB)",
+        f"**Waktu Buka/Tutup:** {IDX_MARKET_CONFIG['IDX_STOCKS']['open_time']} - {IDX_MARKET_CONFIG['IDX_STOCKS']['close_time']} WIB",
+        f"**Waktu Sampai Tutup:** {status.time_until_close}",
+        f"**Hari Trading Berikutnya:** {status.next_trading_day}",
+        f"**Waktu Sampai Buka:** {status.time_until_open}",
+        f"**Terakhir Diperbarui:** {status.last_updated}"
+    ]
+    
+    return f"## {status_emoji} {status.market_name}: {status_text}\n\n" + "\n".join(info_lines)
+
 def analyze_stock(symbol, period, forecast_horizon, use_volume):
     """Main analysis function"""
     try:
         # Load model if not already loaded
-        # 'model' here is now the Chronos Pipeline
         model = load_model()
         
-        # Fetch stock data
+        # Fetch stock data. This now includes technical indicators.
         stock_data = fetch_stock_data(symbol, period)
         if stock_data is None or len(stock_data) < 30:
-            return None, None, "Error: Insufficient data. Please try a different stock or longer period."
+            return None, None, None, get_idx_market_status() + f"\n\nError: Data tidak mencukupi untuk {symbol}. Coba periode yang lebih panjang."
         
-        # Prepare data for Chronos
-        # timesfm_data contains RAW 'Close' prices (unscaled), scaler is None
+        # Prepare data for Chronos (unscaled 'Close' prices)
         timesfm_data, scaler = prepare_timesfm_data(stock_data, use_volume)
         
         # Make predictions
-        # forecast_prices now contains the final unscaled prices directly
         forecast_prices = predict_stock_prices(model, timesfm_data, forecast_horizon)
         
         # Create dates for forecast
@@ -57,54 +75,67 @@ def analyze_stock(symbol, period, forecast_horizon, use_volume):
             freq='D'
         )
         
-        # Calculate metrics
-        actual_prices = stock_data['Close'].values
-        last_price = actual_prices[-1]
+        # Calculate last price and technical summary
+        last_price = stock_data['Close'].iloc[-1]
         
-        # Create forecast plot
+        # Create forecast plot (using the simplified utility function)
         fig = create_forecast_plot(stock_data, forecast_dates, forecast_prices, symbol)
         
-        # Create summary table
+        # --- Create Summary Table ---
+        # Get last technical indicator values
+        last_rsi = stock_data['RSI'].iloc[-1]
+        last_macd = stock_data['MACD'].iloc[-1]
+        last_macd_signal = stock_data['MACD_Signal'].iloc[-1]
+        
         summary_data = {
-            'Metric': ['Current Price', 'Forecast High', 'Forecast Low', 
-                      'Forecast Change (%)', 'Volatility'],
-            'Value': [
+            'Metrik': ['Harga Saat Ini', 'Puncak Prediksi', 'Dasar Prediksi', 
+                      'Perubahan Prediksi (%)', 'Volatilitas Historis', 'RSI (14 Hari)', 'Sinyal MACD'],
+            'Nilai': [
                 f"Rp {last_price:,.2f}",
                 f"Rp {np.max(forecast_prices):,.2f}",
                 f"Rp {np.min(forecast_prices):,.2f}",
                 f"{((np.mean(forecast_prices) - last_price) / last_price * 100):.2f}%",
-                f"{np.std(forecast_prices) / np.mean(forecast_prices) * 100:.2f}%"
+                f"{stock_data['Volatility'].iloc[-1] * np.sqrt(252) * 100:.2f}% (Tahunan)",
+                f"{last_rsi:.2f}",
+                f"{'Beli' if last_macd > last_macd_signal else 'Jual' if last_macd < last_macd_signal else 'Netral'}"
             ]
         }
         
         summary_df = pd.DataFrame(summary_data)
         
-        # Get additional stock info
+        # --- Get Additional Stock Info ---
         stock_info = get_stock_info(symbol)
         info_text = f"""
         **{stock_info.get('shortName', symbol)}**
         
-        **Current Statistics:**
-        - Market Cap: {stock_info.get('marketCap', 'N/A')}
-        - Volume: {stock_data['Volume'].iloc[-1]:,.0f}
-        - 52W High: {stock_info.get('fiftyTwoWeekHigh', 'N/A')}
-        - 52W Low: {stock_info.get('fiftyTwoWeekLow', 'N/A')}
+        **Statistik Saat Ini:**
+        - Kapitalisasi Pasar: {stock_info.get('marketCap', 'N/A')}
+        - Volume Trading: {stock_data['Volume'].iloc[-1]:,.0f}
+        - 52W Tertinggi: Rp {stock_info.get('fiftyTwoWeekHigh', 'N/A'):,.0f}
+        - 52W Terendah: Rp {stock_info.get('fiftyTwoWeekLow', 'N/A'):,.0f}
         
-        **Forecast Summary:**
-        - Period: {forecast_horizon} days
-        - Expected Trend: {'Upward' if np.mean(forecast_prices) > last_price else 'Downward'}
-        - Price Range: Rp {np.min(forecast_prices):,.2f} - Rp {np.max(forecast_prices):,.2f}
+        **Ringkasan Prediksi:**
+        - Periode Prediksi: {forecast_horizon} hari
+        - Tren Harapan: {'Naik' if np.mean(forecast_prices) > last_price else 'Turun'}
+        - Rentang Harga: Rp {np.min(forecast_prices):,.2f} - Rp {np.max(forecast_prices):,.2f}
         """
         
-        return fig, summary_df, info_text
+        return fig, summary_df, info_text, get_idx_market_status()
         
     except Exception as e:
-        return None, None, f"Error occurred: {str(e)}"
+        return None, None, None, get_idx_market_status() + f"\n\nError occurred during analysis: {str(e)}"
 
 def create_interface():
     """Create the Gradio interface"""
+    # Register cleanup function
+    def cleanup_on_exit():
+        market_status_manager.stop()
+        print("Market status manager stopped successfully")
+    
+    atexit.register(cleanup_on_exit)
+
     with gr.Blocks(
-        title="IDX Stock Price Predictor",
+        title="IDX Stock Price Predictor (Chronos-Bolt)",
         theme=gr.themes.Soft(),
         css="""
         .gradio-container {
@@ -120,27 +151,35 @@ def create_interface():
             """
             # 🇮🇩 IDX Stock Price Predictor
             
-            **Built with [anycoder](https://huggingface.co/spaces/akhaliq/anycoder)**
+            **Didukung oleh Model Chronos-Bolt (Base) Amazon**
             
-            Predict Indonesian Stock Exchange (IDX) stock prices using Chronos-Bolt-Base model.
+            Memprediksi harga saham Bursa Efek Indonesia (IDX) menggunakan model *Time Series Foundation Model* Chronos-Bolt.
             
-            **Instructions:**
-            1. Select a stock from the dropdown
-            2. Choose the historical data period
-            3. Set forecast horizon (days)
-            4. Click "Analyze Stock" to generate predictions
+            **Instruksi:**
+            1. Pilih saham IDX dari *dropdown*
+            2. Tentukan periode data historis (Hari)
+            3. Tentukan horison prediksi (Hari)
+            4. Klik "Analisis Saham" untuk melihat prediksi
             """
         )
         
+        # --- Market Status Display ---
+        market_status_output = gr.Markdown(
+            value=get_idx_market_status(),
+            label="Status Pasar IDX Saat Ini"
+        )
+        
+        gr.Markdown("---")
+        
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### 📊 Analysis Parameters")
+                gr.Markdown("### 📊 Parameter Analisis")
                 
                 stock_dropdown = gr.Dropdown(
                     choices=get_stock_choices(),
                     value="BBCA.JK",
-                    label="Select Stock",
-                    info="Choose from major IDX stocks"
+                    label="Pilih Saham",
+                    info="Pilih dari saham-saham utama IDX"
                 )
                 
                 period_slider = gr.Slider(
@@ -148,8 +187,8 @@ def create_interface():
                     maximum=365,
                     value=DEFAULT_PERIOD,
                     step=1,
-                    label="Historical Period (days)",
-                    info="Number of days of historical data to use"
+                    label="Periode Historis (Hari)",
+                    info="Jumlah hari data historis yang akan digunakan"
                 )
                 
                 forecast_slider = gr.Slider(
@@ -157,45 +196,45 @@ def create_interface():
                     maximum=30,
                     value=DEFAULT_FORECAST_HORIZON,
                     step=1,
-                    label="Forecast Horizon (days)",
-                    info="Number of days to predict ahead"
+                    label="Horison Prediksi (Hari)",
+                    info="Jumlah hari ke depan yang akan diprediksi"
                 )
                 
                 volume_checkbox = gr.Checkbox(
-                    label="Include Volume in Analysis",
+                    label="Sertakan Volume dalam Analisis (Eksperimental)",
                     value=False,
-                    info="Use trading volume as additional feature"
+                    info="Gunakan volume trading sebagai fitur tambahan (mungkin tidak kompatibel dengan Chronos-Bolt)"
                 )
                 
                 analyze_btn = gr.Button(
-                    "🔍 Analyze Stock",
+                    "🔍 Analisis Saham",
                     variant="primary",
                     size="lg"
                 )
                 
             with gr.Column(scale=2):
-                gr.Markdown("### 📈 Results")
+                gr.Markdown("### 📈 Hasil Prediksi")
                 
-                with gr.Tab("Forecast Chart"):
+                info_output = gr.Markdown(
+                    label="Detail Saham",
+                    value="Pilih saham dan klik analisis untuk melihat informasi."
+                )
+                
+                with gr.Tab("Grafik Prediksi"):
                     plot_output = gr.Plot(
-                        label="Price Forecast",
+                        label="Prediksi Harga",
                         show_label=False
                     )
                 
-                with gr.Tab("Summary Statistics"):
+                with gr.Tab("Ringkasan Statistik"):
                     summary_output = gr.DataFrame(
-                        label="Forecast Summary",
+                        label="Ringkasan Prediksi",
                         show_label=False
                     )
-                
-                with gr.Tab("Stock Information"):
-                    info_output = gr.Markdown(
-                        label="Stock Details",
-                        value="Select a stock and click analyze to see information."
-                    )
+
         
         # Examples section
-        gr.Markdown("### 💡 Quick Examples")
+        gr.Markdown("### 💡 Contoh Cepat")
         examples = gr.Examples(
             examples=[
                 ["BBCA.JK", 90, 7, False],
@@ -204,7 +243,7 @@ def create_interface():
                 ["BMRI.JK", 180, 5, True],
             ],
             inputs=[stock_dropdown, period_slider, forecast_slider, volume_checkbox],
-            outputs=[plot_output, summary_output, info_output],
+            outputs=[plot_output, summary_output, info_output, market_status_output],
             fn=analyze_stock,
             cache_examples=False
         )
@@ -213,9 +252,9 @@ def create_interface():
         gr.Markdown(
             """
             ---
-            **⚠️ Disclaimer:** This tool is for educational purposes only. Stock market predictions are uncertain and should not be used as financial advice. Always consult with a qualified financial advisor before making investment decisions.
+            **⚠️ Disclaimer:** Alat ini hanya untuk tujuan edukasi. Prediksi pasar saham tidak pasti dan tidak boleh digunakan sebagai nasihat keuangan. Selalu berkonsultasi dengan penasihat keuangan yang berkualifikasi sebelum membuat keputusan investasi.
             
-            **Data Source:** Yahoo Finance | **Model:** Amazon Chronos-Bolt-Base
+            **Sumber Data:** Yahoo Finance | **Model:** Amazon Chronos-Bolt-Base
             """
         )
         
@@ -223,15 +262,22 @@ def create_interface():
         analyze_btn.click(
             fn=analyze_stock,
             inputs=[stock_dropdown, period_slider, forecast_slider, volume_checkbox],
-            outputs=[plot_output, summary_output, info_output],
+            outputs=[plot_output, summary_output, info_output, market_status_output],
             show_progress=True
         )
         
-        # Load model on startup
-        demo.load(fn=load_model)
+        # Initial load to update market status and load model
+        demo.load(
+            fn=lambda: (load_model(), get_idx_market_status()), 
+            outputs=[gr.State(), market_status_output], 
+            show_progress=False
+        )
     
     return demo
 
 if __name__ == "__main__":
+    import atexit
+    
     demo = create_interface()
+    # Cleanup atexit is registered inside create_interface
     demo.launch(share=True, server_name="0.0.0.0")