Update app.py

app.py

@@ -5,6 +5,7 @@ from prophet import Prophet
 import logging
 import plotly.graph_objs as go
 import math
+import numpy as np
 
 logging.basicConfig(level=logging.INFO)
 
@@ -15,7 +16,6 @@ logging.basicConfig(level=logging.INFO)
 OKX_TICKERS_ENDPOINT = "https://www.okx.com/api/v5/market/tickers?instType=SPOT"
 OKX_CANDLE_ENDPOINT = "https://www.okx.com/api/v5/market/candles"
 
-# Allowed bar intervals on OKX, maximum 300 records at a time
 TIMEFRAME_MAPPING = {
     "1m": "1m",
     "5m": "5m",
@@ -30,8 +30,59 @@ TIMEFRAME_MAPPING = {
     "1w": "1W",
 }
 
-########################################
-# Functions to fetch data from OKX
+def calculate_technical_indicators(df):
+    # Calculate RSI
+    delta = df['close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+    rs = gain / loss
+    df['RSI'] = 100 - (100 / (1 + rs))
+    
+    # Calculate MACD
+    exp1 = df['close'].ewm(span=12, adjust=False).mean()
+    exp2 = df['close'].ewm(span=26, adjust=False).mean()
+    df['MACD'] = exp1 - exp2
+    df['Signal_Line'] = df['MACD'].ewm(span=9, adjust=False).mean()
+    
+    # Calculate Bollinger Bands
+    df['MA20'] = df['close'].rolling(window=20).mean()
+    df['BB_upper'] = df['MA20'] + 2 * df['close'].rolling(window=20).std()
+    df['BB_lower'] = df['MA20'] - 2 * df['close'].rolling(window=20).std()
+    
+    return df
+
+def create_technical_charts(df):
+    # Price and Bollinger Bands
+    fig1 = go.Figure()
+    fig1.add_trace(go.Candlestick(
+        x=df['timestamp'],
+        open=df['open'],
+        high=df['high'],
+        low=df['low'],
+        close=df['close'],
+        name='Price'
+    ))
+    fig1.add_trace(go.Scatter(x=df['timestamp'], y=df['BB_upper'], name='Upper BB', line=dict(color='gray', dash='dash')))
+    fig1.add_trace(go.Scatter(x=df['timestamp'], y=df['BB_lower'], name='Lower BB', line=dict(color='gray', dash='dash')))
+    fig1.update_layout(title='Price and Bollinger Bands', xaxis_title='Date', yaxis_title='Price')
+
+    # RSI
+    fig2 = go.Figure()
+    fig2.add_trace(go.Scatter(x=df['timestamp'], y=df['RSI'], name='RSI'))
+    fig2.add_hline(y=70, line_dash="dash", line_color="red")
+    fig2.add_hline(y=30, line_dash="dash", line_color="green")
+    fig2.update_layout(title='RSI Indicator', xaxis_title='Date', yaxis_title='RSI')
+
+    # MACD
+    fig3 = go.Figure()
+    fig3.add_trace(go.Scatter(x=df['timestamp'], y=df['MACD'], name='MACD'))
+    fig3.add_trace(go.Scatter(x=df['timestamp'], y=df['Signal_Line'], name='Signal Line'))
+    fig3.update_layout(title='MACD', xaxis_title='Date', yaxis_title='Value')
+
+    return fig1, fig2, fig3
+
+ ########################################
+# OKX Data Fetching Functions
 ########################################
 
 def fetch_okx_symbols():
@@ -46,43 +97,37 @@ def fetch_okx_symbols():
 
         if json_data.get("code") != "0":
             logging.error(f"Non-zero code returned: {json_data}")
-            return ["Error: Could not fetch OKX symbols"]
+            return ["BTC-USDT"]  # Default fallback
 
         data = json_data.get("data", [])
         symbols = [item["instId"] for item in data if item.get("instType") == "SPOT"]
         if not symbols:
-            logging.warning("No spot symbols found.")
-            return ["Error: No spot symbols found."]
+            return ["BTC-USDT"]
         
+        # Ensure BTC-USDT is first in the list
+        if "BTC-USDT" in symbols:
+            symbols.remove("BTC-USDT")
+            symbols.insert(0, "BTC-USDT")
+            
         logging.info(f"Fetched {len(symbols)} OKX spot symbols.")
-        return sorted(symbols)
+        return symbols
 
     except Exception as e:
         logging.error(f"Error fetching OKX symbols: {e}")
-        return [f"Error: {str(e)}"]
-
+        return ["BTC-USDT"]
 
 def fetch_okx_candles_chunk(symbol, timeframe, limit=300, after=None, before=None):
-    """
-    Fetch up to `limit` candles (max 300) for the given symbol/timeframe.
-    Optionally use `after` or `before` to page through older or newer data.
-    
-    OKX returns newest data first. The result here is also newest first.
-    We'll reorder or combine them later as needed.
-    """
     params = {
         "instId": symbol,
         "bar": timeframe,
         "limit": limit
     }
     if after is not None:
-        # fetch records older than 'after'
         params["after"] = str(after)
     if before is not None:
-        # fetch records newer than 'before'
         params["before"] = str(before)
 
-    logging.info(f"Fetching chunk: symbol={symbol}, bar={timeframe}, limit={limit}, after={after}, before={before}")
+    logging.info(f"Fetching chunk: symbol={symbol}, bar={timeframe}, limit={limit}")
     try:
         resp = requests.get(OKX_CANDLE_ENDPOINT, params=params, timeout=30)
         resp.raise_for_status()
@@ -97,11 +142,7 @@ def fetch_okx_candles_chunk(symbol, timeframe, limit=300, after=None, before=Non
         if not items:
             return pd.DataFrame(), ""
 
-        # items are newest first. We'll parse them in that order, then we can reverse later.
-        columns = [
-            "ts", "o", "h", "l", "c", "vol",
-            "volCcy", "volCcyQuote", "confirm"
-        ]
+        columns = ["ts", "o", "h", "l", "c", "vol", "volCcy", "volCcyQuote", "confirm"]
         df = pd.DataFrame(items, columns=columns)
         df.rename(columns={
             "ts": "timestamp",
@@ -121,20 +162,16 @@ def fetch_okx_candles_chunk(symbol, timeframe, limit=300, after=None, before=Non
         return pd.DataFrame(), err_msg
 
 
+
 def fetch_okx_candles(symbol, timeframe="1H", total=2000):
     """
-    Fetch ~`total` candles by chaining multiple requests of up to 300 each.
-    We'll get the newest data first, then request older data in loops, 
-    because 'after' param returns records older than the provided ts.
-
-    Returns df in chronological order (oldest -> newest).
+    Fetch historical candle data
     """
-    logging.info(f"Fetching ~{total} candles for {symbol} @ {timeframe} (in multiple chunks).")
+    logging.info(f"Fetching ~{total} candles for {symbol} @ {timeframe}")
 
-    # We'll do enough calls to get at least `total` data points, or break if no more data.
     calls_needed = math.ceil(total / 300.0)
     all_data = []
-    after_ts = None  # We'll track the earliest timestamp we see, then pass "after" to go older
+    after_ts = None
 
     for _ in range(calls_needed):
         df_chunk, err = fetch_okx_candles_chunk(
@@ -143,51 +180,38 @@ def fetch_okx_candles(symbol, timeframe="1H", total=2000):
         if err:
             return pd.DataFrame(), err
         if df_chunk.empty:
-            # No more data
             break
 
-        # df_chunk is newest first, so the last row is the earliest in that chunk.
         earliest_ts = df_chunk["timestamp"].iloc[-1]
-        # We'll keep chaining to older data by passing after = earliest_ts-1 (in ms).
-        # But we need that as a Unix milliseconds integer.
         after_ts = int(earliest_ts.timestamp() * 1000 - 1)
-
-        # Add this chunk to the big list
         all_data.append(df_chunk)
 
         if len(df_chunk) < 300:
-            # We didn't get a full chunk, means no more older data available
             break
 
-    # Concatenate everything
     if not all_data:
-        logging.info("No data returned overall.")
         return pd.DataFrame(), "No data returned."
 
     df_all = pd.concat(all_data, ignore_index=True)
-    # Each chunk is newest first, so the entire df is a bunch of blocks newest->oldest blocks.
-    # Let's invert the final large df to chronological
     df_all.sort_values(by="timestamp", inplace=True)
     df_all.reset_index(drop=True, inplace=True)
-    logging.info(f"Fetched a total of {len(df_all)} rows for {symbol}.")
+    
+    # Calculate technical indicators
+    df_all = calculate_technical_indicators(df_all)
+    
+    logging.info(f"Fetched {len(df_all)} rows for {symbol}.")
     return df_all, ""
 
-
 ########################################
-# Prophet pipeline
+# Prophet Pipeline
 ########################################
 
 def prepare_data_for_prophet(df):
-    """
-    Convert DataFrame to Prophet-compatible format: columns ds, y.
-    """
     if df.empty:
-        logging.warning("Empty DataFrame, cannot prepare data for Prophet.")
         return pd.DataFrame(columns=["ds", "y"])
     df_prophet = df.rename(columns={"timestamp": "ds", "close": "y"})
     return df_prophet[["ds", "y"]]
 
-
 def prophet_forecast(
     df_prophet,
     periods=10,
@@ -198,15 +222,8 @@ def prophet_forecast(
     seasonality_mode="additive",
     changepoint_prior_scale=0.05,
 ):
-    """
-    Train a Prophet model with various exposed settings:
-      - daily/weekly/yearly seasonality toggles
-      - seasonality_mode ("additive" or "multiplicative")
-      - changepoint_prior_scale (0.01 to ~10, controls overfitting)
-    """
     if df_prophet.empty:
-        logging.warning("No data for Prophet.")
-        return pd.DataFrame(), "No data to forecast."
+        return pd.DataFrame(), "No data for Prophet."
 
     try:
         model = Prophet(
@@ -225,6 +242,8 @@ def prophet_forecast(
         return pd.DataFrame(), f"Forecast error: {e}"
 
 
+
+
 def prophet_wrapper(
     df_prophet,
     forecast_steps,
@@ -235,9 +254,6 @@ def prophet_wrapper(
     seasonality_mode,
     changepoint_prior_scale,
 ):
-    """
-    Run the forecast with user-chosen settings, then keep future (new) rows only.
-    """
     if len(df_prophet) < 10:
         return pd.DataFrame(), "Not enough data for forecasting (need >=10 rows)."
 
@@ -254,21 +270,16 @@ def prophet_wrapper(
     if err:
         return pd.DataFrame(), err
 
-    # Future portion only: the new rows after the original data
     future_only = full_forecast.loc[len(df_prophet):, ["ds", "yhat", "yhat_lower", "yhat_upper"]]
     return future_only, ""
 
-
 ########################################
-# Plot helper
+# Plotting Functions
 ########################################
 
-def create_line_plot(forecast_df):
-    """
-    Make a Plotly line chart from forecast.
-    """
+def create_forecast_plot(forecast_df):
     if forecast_df.empty:
-        return go.Figure()  # empty figure
+        return go.Figure()
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -276,40 +287,45 @@ def create_line_plot(forecast_df):
         y=forecast_df["yhat"],
         mode="lines",
         name="Forecast",
-        line=dict(color="blue")
+        line=dict(color="blue", width=2)
     ))
 
-    # Lower bound
     fig.add_trace(go.Scatter(
         x=forecast_df["ds"],
         y=forecast_df["yhat_lower"],
         fill=None,
         mode="lines",
-        line=dict(width=0, color="lightblue"),
-        name="Lower"
+        line=dict(width=0),
+        showlegend=True,
+        name="Lower Bound"
     ))
 
-    # Upper bound
     fig.add_trace(go.Scatter(
         x=forecast_df["ds"],
         y=forecast_df["yhat_upper"],
         fill="tonexty",
         mode="lines",
-        line=dict(width=0, color="lightblue"),
-        name="Upper"
+        line=dict(width=0),
+        name="Upper Bound"
     ))
 
     fig.update_layout(
-        title="Forecasted Prices",
-        xaxis_title="Timestamp",
+        title="Price Forecast",
+        xaxis_title="Time",
         yaxis_title="Price",
-        hovermode="x"
+        hovermode="x unified",
+        template="plotly_white",
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        )
     )
     return fig
 
-
 ########################################
-# Main Gradio logic
+# Main Prediction Function
 ########################################
 
 def predict(
@@ -323,23 +339,12 @@ def predict(
     seasonality_mode,
     changepoint_prior_scale,
 ):
-    """
-    1) Fetch `total_candles` historical data (in multiple parts if needed)
-    2) Convert to Prophet style
-    3) Run forecast with user-specified Prophet settings
-    4) Return future portion
-    """
-    # Convert timeframe to OKX style
     okx_bar = TIMEFRAME_MAPPING.get(timeframe, "1H")
-
-    # This fetch can yield thousands of candles
     df_raw, err = fetch_okx_candles(symbol, timeframe=okx_bar, total=total_candles)
     if err:
-        return pd.DataFrame(), err
+        return pd.DataFrame(), pd.DataFrame(), err
 
     df_prophet = prepare_data_for_prophet(df_raw)
-
-    # Decide Prophet frequency
     freq = "h" if "h" in timeframe.lower() else "d"
 
     future_df, err2 = prophet_wrapper(
@@ -353,9 +358,10 @@ def predict(
         changepoint_prior_scale,
     )
     if err2:
-        return pd.DataFrame(), err2
+        return pd.DataFrame(), pd.DataFrame(), err2
+
+    return df_raw, future_df, ""
 
-    return future_df, ""
 
 
 def display_forecast(
@@ -369,12 +375,9 @@ def display_forecast(
     seasonality_mode,
     changepoint_prior_scale,
 ):
-    logging.info(
-        f"User requested: symbol={symbol}, timeframe={timeframe}, steps={forecast_steps}, "
-        f"total_candles={total_candles}, daily={daily_seasonality}, weekly={weekly_seasonality}, "
-        f"yearly={yearly_seasonality}, mode={seasonality_mode}, cps={changepoint_prior_scale}"
-    )
-    forecast_df, error = predict(
+    logging.info(f"Processing forecast request for {symbol}")
+    
+    df_raw, forecast_df, error = predict(
         symbol,
         timeframe,
         forecast_steps,
@@ -385,80 +388,95 @@ def display_forecast(
         seasonality_mode,
         changepoint_prior_scale,
     )
+    
     if error:
-        return None, f"Error: {error}"
-
-    fig = create_line_plot(forecast_df)
-    return fig, forecast_df
+        return None, None, None, None, f"Error: {error}"
 
+    forecast_plot = create_forecast_plot(forecast_df)
+    tech_plot, rsi_plot, macd_plot = create_technical_charts(df_raw)
+    
+    return forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df
 
 def main():
-    # Fetch OKX symbols
     symbols = fetch_okx_symbols()
-    if not symbols or "Error" in symbols[0]:
-        symbols = ["No symbols available"]
-
-    with gr.Blocks() as demo:
-        gr.Markdown("# Crypto Price Forecasting with Prophet")
-        gr.Markdown(
-            "This tool can gather thousands of historical data points from OKX's spot market "
-            "and make forecasts using Prophet. You can tweak Prophet's advanced settings or "
-            "increase the candle fetch size for potentially more accurate predictions.\n\n"
-            "Simply pick a symbol, timeframe, how many candles (max ~2000), and forecast steps."
-        )
-
-        # Input controls
-        symbol_dd = gr.Dropdown(
-            label="Symbol",
-            choices=symbols,
-            value=symbols[0] if symbols else None
-        )
-        timeframe_dd = gr.Dropdown(
-            label="Timeframe",
-            choices=["1m", "5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d", "1w"],
-            value="1h"
-        )
-        total_candles_slider = gr.Slider(
-            label="Total Candles to Fetch",
-            minimum=300,
-            maximum=3000,
-            value=2000,
-            step=100
-        )
-        forecast_steps_slider = gr.Slider(
-            label="Forecast Steps",
-            minimum=1,
-            maximum=100,
-            value=10
-        )
-
-        # Prophet advanced settings
-        daily_box = gr.Checkbox(label="Daily Seasonality", value=False)
-        weekly_box = gr.Checkbox(label="Weekly Seasonality", value=False)
-        yearly_box = gr.Checkbox(label="Yearly Seasonality", value=False)
-        seasonality_mode_dd = gr.Dropdown(
-            label="Seasonality Mode",
-            choices=["additive", "multiplicative"],
-            value="additive"
-        )
-        changepoint_scale_slider = gr.Slider(
-            label="Changepoint Prior Scale (0.01 ~ 1.0)",
-            minimum=0.01,
-            maximum=1.0,
-            step=0.01,
-            value=0.05
-        )
-
-        forecast_btn = gr.Button("Generate Forecast")
-
-        # Outputs
-        chart_output = gr.Plot(label="Forecast Chart")
-        df_output = gr.Dataframe(
-            label="Forecast (Future Only)",
-            headers=["ds", "yhat", "yhat_lower", "yhat_upper"]
-        )
+    
+    with gr.Blocks(theme=gr.themes.Base()) as demo:
+        with gr.Row():
+            gr.Markdown("# Cryptocurrency Price Forecasting System")
+            
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Box():
+                    gr.Markdown("### Market Selection")
+                    symbol_dd = gr.Dropdown(
+                        label="Trading Pair",
+                        choices=symbols,
+                        value="BTC-USDT"
+                    )
+                    timeframe_dd = gr.Dropdown(
+                        label="Timeframe",
+                        choices=list(TIMEFRAME_MAPPING.keys()),
+                        value="1h"
+                    )
+                    
+            with gr.Column(scale=1):
+                with gr.Box():
+                    gr.Markdown("### Forecast Parameters")
+                    forecast_steps_slider = gr.Slider(
+                        label="Forecast Steps",
+                        minimum=1,
+                        maximum=100,
+                        value=24,
+                        step=1
+                    )
+                    total_candles_slider = gr.Slider(
+                        label="Historical Candles",
+                        minimum=300,
+                        maximum=3000,
+                        value=2000,
+                        step=100
+                    )
+
+        with gr.Row():
+            with gr.Column():
+                with gr.Box():
+                    gr.Markdown("### Advanced Settings")
+                    with gr.Row():
+                        daily_box = gr.Checkbox(label="Daily Seasonality", value=True)
+                        weekly_box = gr.Checkbox(label="Weekly Seasonality", value=True)
+                        yearly_box = gr.Checkbox(label="Yearly Seasonality", value=False)
+                    seasonality_mode_dd = gr.Dropdown(
+                        label="Seasonality Mode",
+                        choices=["additive", "multiplicative"],
+                        value="additive"
+                    )
+                    changepoint_scale_slider = gr.Slider(
+                        label="Changepoint Prior Scale",
+                        minimum=0.01,
+                        maximum=1.0,
+                        step=0.01,
+                        value=0.05
+                    )
+
+        with gr.Row():
+            forecast_btn = gr.Button("Generate Forecast", variant="primary", size="lg")
+
+        with gr.Row():
+            forecast_plot = gr.Plot(label="Price Forecast")
+            
+        with gr.Row():
+            tech_plot = gr.Plot(label="Technical Analysis")
+            rsi_plot = gr.Plot(label="RSI Indicator")
+            
+        with gr.Row():
+            macd_plot = gr.Plot(label="MACD")
+            
+        with gr.Row():
+            forecast_df = gr.Dataframe(
+                label="Forecast Data",
+                headers=["Date", "Forecast", "Lower Bound", "Upper Bound"]
+            )
 
-        # Hook everything up
         forecast_btn.click(
             fn=display_forecast,
             inputs=[
@@ -472,17 +490,11 @@ def main():
                 seasonality_mode_dd,
                 changepoint_scale_slider,
             ],
-            outputs=[chart_output, df_output]
-        )
-
-        # You can choose any text variation you like here
-        gr.Markdown(
-            "For automated trading tools, consider Gunbot as your next [crypto trading bot](https://www.gunbot.com)."
+            outputs=[forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df]
         )
 
     return demo
 
-
 if __name__ == "__main__":
     app = main()
-    app.launch()
+    app.launch()