Upload folder using huggingface_hub

README.md

@@ -1,81 +1,50 @@
 ---
-title: Paper Summarizer
-emoji: 📄
-colorFrom: blue
-colorTo: indigo
+title: Trading Signal Dashboard
+emoji: 📈
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 4.44.0
+sdk_version: 5.9.1
 python_version: "3.10"
 app_file: app.py
 pinned: false
 license: mit
-short_description: Summarize academic research papers with AI
+short_description: Technical analysis dashboard with trading signals
 ---
 
-# Paper Summarizer
+# Trading Signal Dashboard
 
-An AI-powered tool that transforms lengthy academic research papers into structured, digestible summaries. Built with Facebook's BART-Large-CNN model and deployed as a Gradio web application on HuggingFace Spaces.
+An interactive technical analysis dashboard that fetches real-time stock data and generates trading signals using classical technical indicators.
 
 ## Features
 
-- **PDF Upload** -- Drop a research paper PDF and get an instant structured summary.
-- **Text Input** -- Paste raw paper text directly if you prefer.
-- **Structured Output** -- Every summary includes:
-  - Extracted paper title
-  - Concise abstract-length summary
-  - Key findings from the results/conclusion sections
-  - Methodology overview
-  - Word-count statistics with compression ratio
-- **Long Document Support** -- Papers of any length are automatically chunked and summarized in multiple passes, then combined into a coherent final summary.
-- **Clean PDF Processing** -- Handles hyphenated line breaks, control characters, and other common PDF artifacts.
+- **Real-time data** via Yahoo Finance for any publicly traded ticker
+- **Technical indicators**: SMA (20/50), EMA (12/26), RSI (14), MACD, Bollinger Bands
+- **Signal generation**: Buy/sell signals from indicator crossovers (SMA, MACD, RSI)
+- **Interactive Plotly charts**: Price with overlays, RSI, MACD, and Volume subplots
+- **Signal summary table** with recent buy/sell signals and reasoning
+- **Backtesting engine**: Compare signal-based strategy returns against buy-and-hold
+- **Multiple timeframes**: 1 Month, 3 Months, 6 Months, 1 Year, 2 Years
 
 ## How It Works
 
-1. **Text Extraction** -- PDFs are parsed with PyMuPDF (fitz) to extract selectable text from every page.
-2. **Cleaning** -- Raw text is normalized: stray control characters are removed, hyphenated line breaks are rejoined, and excessive whitespace is collapsed.
-3. **Chunking** -- The cleaned text is split into chunks of approximately 700 words, respecting paragraph and sentence boundaries so context is preserved.
-4. **Summarization** -- Each chunk is passed through `facebook/bart-large-cnn` for abstractive summarization. If there are multiple chunks, the individual summaries are combined and summarized again for coherence.
-5. **Section Extraction** -- Regex heuristics identify Results, Methodology, and Conclusion sections for targeted summarization of key findings and methods.
+1. Enter a stock ticker (e.g., AAPL, GOOGL, MSFT, TSLA)
+2. Select a lookback timeframe
+3. The dashboard fetches historical price data, computes technical indicators, and identifies trading signals
+4. Review charts, signals, and backtest results across three organized tabs
 
-## Model
+## Indicators & Signals
 
-This Space uses [`facebook/bart-large-cnn`](https://huggingface.co/facebook/bart-large-cnn), a BART model fine-tuned on the CNN/DailyMail summarization dataset. It runs on the free CPU tier and can process most papers in under a minute.
+| Indicator | Signal Logic |
+|-----------|-------------|
+| SMA Crossover | Buy when SMA-20 crosses above SMA-50; Sell when SMA-20 crosses below SMA-50 |
+| MACD Crossover | Buy when MACD line crosses above Signal line; Sell on downward cross |
+| RSI Extremes | Buy when RSI crosses above 30 (oversold); Sell when RSI crosses below 70 (overbought) |
 
-## Limitations
+## Disclaimer
 
-- **Scanned PDFs** are not supported -- the PDF must contain selectable text (not images of text).
-- **Summarization quality** depends on the structure and clarity of the input text.
-- **Processing time** may be longer for very large papers due to CPU-only inference.
-
-## Tech Stack
-
-| Component | Library |
-|---|---|
-| Web framework | Gradio 4.44 |
-| Summarization model | HuggingFace Transformers (BART-Large-CNN) |
-| PDF parsing | PyMuPDF (fitz) |
-| Inference backend | PyTorch (CPU) |
-
-## Local Development
-
-```bash
-# Clone the repository
-git clone https://huggingface.co/spaces/gr8monk3ys/paper-summarizer
-cd paper-summarizer
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the application
-python app.py
-```
-
-The app will be available at `http://localhost:7860`.
-
-## License
-
-MIT
+**This application is for educational and informational purposes only. It does NOT constitute financial advice, investment recommendations, or solicitation to buy or sell any securities.** Past performance and backtesting results do not guarantee future returns. Always consult a qualified financial advisor before making investment decisions. The creator assumes no liability for any financial losses incurred from using this tool.
 
 ## Author
 
-Built by [Lorenzo Scaturchio](https://huggingface.co/gr8monk3ys).
+Built by [Lorenzo Scaturchio (gr8monk3ys)](https://huggingface.co/gr8monk3ys)

app.py

@@ -1,535 +1,909 @@
 """
-Paper Summarizer - A Gradio-based web application for summarizing academic research papers.
-Version: 2.0.0 (Gradio 5.x compatible)
+Trading Signal Dashboard
+========================
+A Gradio-based technical analysis dashboard that fetches real stock data,
+computes indicators, generates buy/sell signals, and backtests strategies.
 
-This application uses Facebook's BART-Large-CNN model to generate structured summaries
-of academic papers. It supports both PDF uploads and pasted text input, handles long
-documents through intelligent chunking, and produces summaries with extracted titles,
-key findings, methodology notes, and concise abstracts.
+Version: 2.0.0 (Gradio 5.x compatible)
 
 Author: Lorenzo Scaturchio (gr8monk3ys)
 License: MIT
+
+DISCLAIMER: This tool is for educational purposes only and does NOT
+constitute financial advice. Use at your own risk.
 """
 
-import os
-import re
-import logging
+import datetime
 from typing import Optional
 
-import fitz  # PyMuPDF
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-)
-logger = logging.getLogger(__name__)
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import ta
+import yfinance as yf
+from plotly.subplots import make_subplots
 
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
-MODEL_NAME = "facebook/bart-large-cnn"
-# BART-Large-CNN accepts up to 1024 tokens (~750 words). We chunk by words to
-# stay safely within that window while leaving room for special tokens.
-CHUNK_WORD_LIMIT = 700
-SUMMARY_MIN_LENGTH = 40
-SUMMARY_MAX_LENGTH = 180
-COMBINE_SUMMARY_MAX_LENGTH = 300
+
+DEFAULT_TICKERS = ["AAPL", "GOOGL", "MSFT", "TSLA"]
+
+TIMEFRAME_MAP = {
+    "1 Month": 30,
+    "3 Months": 90,
+    "6 Months": 180,
+    "1 Year": 365,
+    "2 Years": 730,
+}
+
+COLORS = {
+    "bg": "#0e1117",
+    "card": "#1a1d29",
+    "text": "#e0e0e0",
+    "green": "#00d4aa",
+    "red": "#ff6b6b",
+    "blue": "#4dabf7",
+    "purple": "#b197fc",
+    "orange": "#ffa94d",
+    "yellow": "#ffe066",
+    "grid": "#2a2d3a",
+    "band_fill": "rgba(77, 171, 247, 0.08)",
+}
+
+DISCLAIMER_TEXT = (
+    "**Disclaimer:** This dashboard is for educational and informational "
+    "purposes only. It does NOT constitute financial advice. Past performance "
+    "does not guarantee future results. Always do your own research and consult "
+    "a qualified financial advisor before making investment decisions."
+)
 
 # ---------------------------------------------------------------------------
-# Use HuggingFace Inference API (no local model loading - saves memory)
+# Data Fetching
 # ---------------------------------------------------------------------------
-logger.info("Initializing HuggingFace Inference Client for: %s", MODEL_NAME)
-client = InferenceClient(model=MODEL_NAME)
-logger.info("Inference client ready.")
 
 
-# ===========================================================================
-# Text extraction helpers
-# ===========================================================================
-
-def extract_text_from_pdf(pdf_path: str) -> str:
-    """Extract all text content from a PDF file using PyMuPDF.
+def fetch_stock_data(
+    ticker: str, timeframe: str
+) -> tuple[Optional[pd.DataFrame], Optional[str]]:
+    """Fetch historical stock data from Yahoo Finance.
 
     Args:
-        pdf_path: Path to the uploaded PDF file.
+        ticker: Stock ticker symbol (e.g. 'AAPL').
+        timeframe: Human-readable timeframe key from TIMEFRAME_MAP.
 
     Returns:
-        The concatenated text of every page, separated by newlines.
-
-    Raises:
-        ValueError: If the PDF contains no extractable text.
+        Tuple of (DataFrame with OHLCV data, error message or None).
     """
+    days = TIMEFRAME_MAP.get(timeframe, 365)
+    end_date = datetime.date.today()
+    start_date = end_date - datetime.timedelta(days=days)
+
     try:
-        doc = fitz.open(pdf_path)
-    except Exception as exc:
-        raise ValueError(
-            f"Could not open the PDF file. It may be corrupted or password-protected. "
-            f"Details: {exc}"
-        ) from exc
-
-    pages: list[str] = []
-    for page_num, page in enumerate(doc):
-        text = page.get_text("text")
-        if text.strip():
-            pages.append(text)
-        logger.debug("Page %d: extracted %d characters", page_num + 1, len(text))
-
-    doc.close()
-
-    if not pages:
-        raise ValueError(
-            "The PDF appears to contain no extractable text. "
-            "It may be a scanned document or consist only of images."
+        data = yf.download(
+            ticker,
+            start=start_date.isoformat(),
+            end=end_date.isoformat(),
+            progress=False,
+            auto_adjust=True,
         )
+        if data.empty:
+            return None, f"No data found for ticker '{ticker}'. Verify the symbol."
 
-    return "\n".join(pages)
+        # Flatten MultiIndex columns if present (yfinance >= 0.2.31 quirk)
+        if isinstance(data.columns, pd.MultiIndex):
+            data.columns = data.columns.get_level_values(0)
 
+        # Ensure expected columns exist
+        required = {"Open", "High", "Low", "Close", "Volume"}
+        if not required.issubset(set(data.columns)):
+            return None, f"Incomplete data columns for '{ticker}'."
 
-def clean_text(text: str) -> str:
-    """Normalize whitespace and remove common PDF artefacts.
+        data = data.copy()
+        data.index = pd.to_datetime(data.index)
+        return data, None
 
-    Handles excessive newlines, hyphenated line-breaks, and stray control
-    characters that often appear in academic PDFs.
-    """
-    # Remove form-feed and other control characters (keep newlines & tabs)
-    text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", text)
-    # Re-join hyphenated line breaks (e.g. "summa-\nrization" -> "summarization")
-    text = re.sub(r"(\w)-\n(\w)", r"\1\2", text)
-    # Collapse multiple blank lines into one
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    # Collapse multiple spaces
-    text = re.sub(r"[ \t]{2,}", " ", text)
-    return text.strip()
-
-
-# ===========================================================================
-# Title extraction heuristic
-# ===========================================================================
-
-def extract_title(text: str) -> str:
-    """Attempt to extract the paper title from the first few lines.
-
-    Academic papers typically place the title in the first 1-5 lines before the
-    author block.  We use a simple heuristic: the longest line among the first
-    few non-empty lines that is not all-caps (which would be a header like
-    "ABSTRACT") and does not look like an author list.
-    """
-    lines = [ln.strip() for ln in text.split("\n") if ln.strip()][:12]
-
-    candidates: list[str] = []
-    for line in lines:
-        # Skip very short lines (page numbers, dates, etc.)
-        if len(line) < 10:
-            continue
-        # Skip lines that are likely author names / affiliations (contain '@')
-        if "@" in line:
-            continue
-        # Skip lines that are section headers (all uppercase, short)
-        if line.isupper() and len(line) < 60:
-            continue
-        # Skip lines that look like emails or URLs
-        if re.search(r"https?://|www\.", line):
-            continue
-        candidates.append(line)
-
-    if not candidates:
-        return "Untitled Paper"
-
-    # Return the first substantial candidate (titles usually come first)
-    return candidates[0]
-
-
-# ===========================================================================
-# Chunking and summarization
-# ===========================================================================
-
-def chunk_text(text: str, max_words: int = CHUNK_WORD_LIMIT) -> list[str]:
-    """Split text into chunks of approximately *max_words* words.
-
-    Splitting is done on paragraph boundaries where possible so that chunks
-    remain coherent.  If a single paragraph exceeds the limit it is split on
-    sentence boundaries instead.
+    except Exception as exc:
+        return None, f"Error fetching data for '{ticker}': {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Technical Indicators
+# ---------------------------------------------------------------------------
+
+
+def compute_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    """Compute all technical indicators on an OHLCV DataFrame.
+
+    Adds the following columns:
+        SMA_20, SMA_50, EMA_12, EMA_26, RSI,
+        MACD, MACD_Signal, MACD_Hist,
+        BB_Upper, BB_Middle, BB_Lower
     """
-    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
-    chunks: list[str] = []
-    current_chunk: list[str] = []
-    current_word_count = 0
-
-    for para in paragraphs:
-        para_words = len(para.split())
-
-        # If adding this paragraph would exceed the limit, finalize the chunk.
-        if current_word_count + para_words > max_words and current_chunk:
-            chunks.append("\n\n".join(current_chunk))
-            current_chunk = []
-            current_word_count = 0
-
-        # Handle paragraphs that are themselves larger than the limit.
-        if para_words > max_words:
-            sentences = re.split(r"(?<=[.!?])\s+", para)
-            for sentence in sentences:
-                s_words = len(sentence.split())
-                if current_word_count + s_words > max_words and current_chunk:
-                    chunks.append("\n\n".join(current_chunk))
-                    current_chunk = []
-                    current_word_count = 0
-                current_chunk.append(sentence)
-                current_word_count += s_words
-        else:
-            current_chunk.append(para)
-            current_word_count += para_words
-
-    if current_chunk:
-        chunks.append("\n\n".join(current_chunk))
-
-    return chunks
-
-
-def summarize_text(text: str) -> str:
-    """Summarize a single chunk of text using the BART model via Inference API.
-
-    Dynamically adjusts min/max summary length based on input length to avoid
-    the common transformers warning about min_length exceeding input length.
+    close = df["Close"].astype(float)
+    high = df["High"].astype(float)
+    low = df["Low"].astype(float)
+
+    # Simple Moving Averages
+    df["SMA_20"] = ta.trend.sma_indicator(close, window=20)
+    df["SMA_50"] = ta.trend.sma_indicator(close, window=50)
+
+    # Exponential Moving Averages
+    df["EMA_12"] = ta.trend.ema_indicator(close, window=12)
+    df["EMA_26"] = ta.trend.ema_indicator(close, window=26)
+
+    # Relative Strength Index
+    df["RSI"] = ta.momentum.rsi(close, window=14)
+
+    # MACD
+    macd_obj = ta.trend.MACD(close, window_slow=26, window_fast=12, window_sign=9)
+    df["MACD"] = macd_obj.macd()
+    df["MACD_Signal"] = macd_obj.macd_signal()
+    df["MACD_Hist"] = macd_obj.macd_diff()
+
+    # Bollinger Bands
+    bb_obj = ta.volatility.BollingerBands(close, window=20, window_dev=2)
+    df["BB_Upper"] = bb_obj.bollinger_hband()
+    df["BB_Middle"] = bb_obj.bollinger_mavg()
+    df["BB_Lower"] = bb_obj.bollinger_lband()
+
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Signal Generation
+# ---------------------------------------------------------------------------
+
+
+def generate_signals(df: pd.DataFrame) -> pd.DataFrame:
+    """Generate composite buy/sell signals from indicator crossovers.
+
+    Adds columns: Signal, Signal_Reason.
+    Signal values: 1 (buy), -1 (sell), 0 (hold).
     """
-    word_count = len(text.split())
-    # For very short inputs, just return the text as-is.
-    if word_count < 50:
-        return text
+    n = len(df)
+    signals = np.zeros(n, dtype=int)
+    reasons = [""] * n
+
+    sma20 = df["SMA_20"].values
+    sma50 = df["SMA_50"].values
+    macd = df["MACD"].values
+    macd_sig = df["MACD_Signal"].values
+    rsi = df["RSI"].values
+
+    for i in range(1, n):
+        buy_reasons: list[str] = []
+        sell_reasons: list[str] = []
+
+        # --- SMA crossover --------------------------------------------------
+        if _crosses_above(sma20, sma50, i):
+            buy_reasons.append("SMA 20/50 golden cross")
+        elif _crosses_below(sma20, sma50, i):
+            sell_reasons.append("SMA 20/50 death cross")
+
+        # --- MACD crossover --------------------------------------------------
+        if _crosses_above(macd, macd_sig, i):
+            buy_reasons.append("MACD bullish crossover")
+        elif _crosses_below(macd, macd_sig, i):
+            sell_reasons.append("MACD bearish crossover")
+
+        # --- RSI extremes ----------------------------------------------------
+        if not np.isnan(rsi[i]) and not np.isnan(rsi[i - 1]):
+            if rsi[i - 1] <= 30 < rsi[i]:
+                buy_reasons.append("RSI exits oversold (<30)")
+            elif rsi[i - 1] >= 70 > rsi[i]:
+                sell_reasons.append("RSI exits overbought (>70)")
+
+        # --- Composite decision (majority vote) ------------------------------
+        if len(buy_reasons) > len(sell_reasons) and len(buy_reasons) >= 1:
+            signals[i] = 1
+            reasons[i] = "; ".join(buy_reasons)
+        elif len(sell_reasons) > len(buy_reasons) and len(sell_reasons) >= 1:
+            signals[i] = -1
+            reasons[i] = "; ".join(sell_reasons)
+
+    df["Signal"] = signals
+    df["Signal_Reason"] = reasons
+    return df
+
+
+def _crosses_above(fast: np.ndarray, slow: np.ndarray, i: int) -> bool:
+    """Return True if *fast* crosses above *slow* at index *i*."""
+    if np.isnan(fast[i]) or np.isnan(slow[i]) or np.isnan(fast[i - 1]) or np.isnan(slow[i - 1]):
+        return False
+    return fast[i - 1] <= slow[i - 1] and fast[i] > slow[i]
+
+
+def _crosses_below(fast: np.ndarray, slow: np.ndarray, i: int) -> bool:
+    """Return True if *fast* crosses below *slow* at index *i*."""
+    if np.isnan(fast[i]) or np.isnan(slow[i]) or np.isnan(fast[i - 1]) or np.isnan(slow[i - 1]):
+        return False
+    return fast[i - 1] >= slow[i - 1] and fast[i] < slow[i]
 
-    max_len = min(SUMMARY_MAX_LENGTH, max(50, word_count // 2))
-    min_len = min(SUMMARY_MIN_LENGTH, max_len - 10)
 
-    try:
-        result = client.summarization(
-            text,
-            parameters={
-                "max_length": max_len,
-                "min_length": min_len,
-                "do_sample": False,
-            },
+# ---------------------------------------------------------------------------
+# Signal Summary Table
+# ---------------------------------------------------------------------------
+
+
+def build_signal_table(df: pd.DataFrame) -> pd.DataFrame:
+    """Return a tidy DataFrame of only the rows where a signal fired."""
+    mask = df["Signal"] != 0
+    if mask.sum() == 0:
+        return pd.DataFrame(
+            columns=["Date", "Close", "Type", "Reason"]
         )
-        return result.summary_text
-    except Exception as e:
-        logger.warning("Summarization failed: %s", e)
-        # Fallback: return truncated text
-        return " ".join(text.split()[:100]) + "..."
 
+    out = df.loc[mask, ["Close", "Signal", "Signal_Reason"]].copy()
+    out.index.name = "Date"
+    out = out.reset_index()
+    out["Date"] = out["Date"].dt.strftime("%Y-%m-%d")
+    out["Close"] = out["Close"].round(2)
+    out["Type"] = out["Signal"].map({1: "BUY", -1: "SELL"})
+    out["Reason"] = out["Signal_Reason"]
+    return out[["Date", "Close", "Type", "Reason"]]
 
-def generate_full_summary(text: str) -> str:
-    """Produce a final summary for arbitrarily long documents.
 
-    Strategy:
-    1. Split the document into manageable chunks.
-    2. Summarize each chunk individually.
-    3. If multiple chunk summaries exist, combine them and run a second-pass
-       summarization to produce a coherent final summary.
+# ---------------------------------------------------------------------------
+# Backtesting Engine
+# ---------------------------------------------------------------------------
+
+
+def run_backtest(df: pd.DataFrame) -> dict:
+    """Run a simple signal-following backtest and compare to buy-and-hold.
+
+    Strategy rules:
+        - Start in cash.
+        - On a BUY signal, go fully invested (buy at close).
+        - On a SELL signal, exit to cash (sell at close).
+        - At the end, liquidate any open position.
+
+    Returns a dict with summary statistics.
     """
-    chunks = chunk_text(text)
-    logger.info("Document split into %d chunk(s) for summarization.", len(chunks))
+    close = df["Close"].values.astype(float)
+    signals = df["Signal"].values
+
+    # Buy-and-hold
+    bh_return = (close[-1] / close[0] - 1) * 100 if close[0] != 0 else 0.0
+
+    # Signal strategy
+    cash = 10_000.0
+    shares = 0.0
+    initial_capital = cash
+    in_position = False
+    trades = 0
+    winning_trades = 0
+    entry_price = 0.0
+
+    equity_curve = np.full(len(close), np.nan)
+
+    for i in range(len(close)):
+        if signals[i] == 1 and not in_position and cash > 0:
+            shares = cash / close[i]
+            entry_price = close[i]
+            cash = 0.0
+            in_position = True
+            trades += 1
+        elif signals[i] == -1 and in_position:
+            cash = shares * close[i]
+            if close[i] > entry_price:
+                winning_trades += 1
+            shares = 0.0
+            in_position = False
+
+        equity_curve[i] = cash + shares * close[i]
+
+    # Liquidate at end if still in position
+    if in_position:
+        cash = shares * close[-1]
+        if close[-1] > entry_price:
+            winning_trades += 1
+        shares = 0.0
+        equity_curve[-1] = cash
+
+    final_value = cash + shares * close[-1]
+    strategy_return = (final_value / initial_capital - 1) * 100
+    win_rate = (winning_trades / trades * 100) if trades > 0 else 0.0
+
+    # Equity curve for charting (forward-fill NaN gaps)
+    eq_series = pd.Series(equity_curve)
+    eq_series = eq_series.ffill().bfill()
+
+    return {
+        "initial_capital": initial_capital,
+        "final_value": round(final_value, 2),
+        "strategy_return_pct": round(strategy_return, 2),
+        "buy_hold_return_pct": round(bh_return, 2),
+        "total_trades": trades,
+        "winning_trades": winning_trades,
+        "win_rate_pct": round(win_rate, 1),
+        "equity_curve": eq_series.values,
+    }
 
-    chunk_summaries = [summarize_text(chunk) for chunk in chunks]
 
-    if len(chunk_summaries) == 1:
-        return chunk_summaries[0]
+# ---------------------------------------------------------------------------
+# Chart Building
+# ---------------------------------------------------------------------------
 
-    # Second pass: combine chunk summaries and re-summarize for coherence.
-    combined = " ".join(chunk_summaries)
-    combined_words = len(combined.split())
+_PLOTLY_LAYOUT_DEFAULTS = dict(
+    template="plotly_dark",
+    paper_bgcolor=COLORS["bg"],
+    plot_bgcolor=COLORS["bg"],
+    font=dict(color=COLORS["text"], family="Inter, sans-serif"),
+    hovermode="x unified",
+    legend=dict(
+        orientation="h",
+        yanchor="bottom",
+        y=1.02,
+        xanchor="right",
+        x=1,
+        font=dict(size=11),
+    ),
+    margin=dict(l=60, r=30, t=60, b=40),
+)
 
-    if combined_words < 50:
-        return combined
 
-    max_len = min(COMBINE_SUMMARY_MAX_LENGTH, max(60, combined_words // 2))
-    min_len = min(SUMMARY_MIN_LENGTH, max_len - 10)
+def build_main_chart(df: pd.DataFrame, ticker: str) -> go.Figure:
+    """Build the multi-subplot price / RSI / MACD / Volume chart."""
 
-    try:
-        result = client.summarization(
-            combined,
-            parameters={
-                "max_length": max_len,
-                "min_length": min_len,
-                "do_sample": False,
-            },
+    fig = make_subplots(
+        rows=4,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.03,
+        row_heights=[0.45, 0.18, 0.18, 0.19],
+        subplot_titles=("", "", "", ""),
+    )
+
+    dates = df.index
+
+    # --- Row 1: Candlestick + overlays + Bollinger Bands --------------------
+    fig.add_trace(
+        go.Candlestick(
+            x=dates,
+            open=df["Open"],
+            high=df["High"],
+            low=df["Low"],
+            close=df["Close"],
+            increasing_line_color=COLORS["green"],
+            decreasing_line_color=COLORS["red"],
+            name="Price",
+        ),
+        row=1,
+        col=1,
+    )
+
+    # Bollinger Bands (shaded region)
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["BB_Upper"],
+            line=dict(width=0),
+            showlegend=False,
+            hoverinfo="skip",
+        ),
+        row=1,
+        col=1,
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["BB_Lower"],
+            fill="tonexty",
+            fillcolor=COLORS["band_fill"],
+            line=dict(width=0),
+            name="Bollinger Bands",
+        ),
+        row=1,
+        col=1,
+    )
+
+    # SMA / EMA lines
+    for col_name, color, dash in [
+        ("SMA_20", COLORS["blue"], "solid"),
+        ("SMA_50", COLORS["purple"], "solid"),
+        ("EMA_12", COLORS["orange"], "dot"),
+        ("EMA_26", COLORS["yellow"], "dot"),
+    ]:
+        fig.add_trace(
+            go.Scatter(
+                x=dates,
+                y=df[col_name],
+                mode="lines",
+                line=dict(color=color, width=1.2, dash=dash),
+                name=col_name,
+            ),
+            row=1,
+            col=1,
+        )
+
+    # Buy / Sell markers
+    buys = df[df["Signal"] == 1]
+    sells = df[df["Signal"] == -1]
+
+    if not buys.empty:
+        fig.add_trace(
+            go.Scatter(
+                x=buys.index,
+                y=buys["Close"],
+                mode="markers",
+                marker=dict(
+                    symbol="triangle-up",
+                    size=12,
+                    color=COLORS["green"],
+                    line=dict(color="white", width=1),
+                ),
+                name="Buy Signal",
+                text=buys["Signal_Reason"],
+                hovertemplate="%{text}<extra>BUY</extra>",
+            ),
+            row=1,
+            col=1,
+        )
+
+    if not sells.empty:
+        fig.add_trace(
+            go.Scatter(
+                x=sells.index,
+                y=sells["Close"],
+                mode="markers",
+                marker=dict(
+                    symbol="triangle-down",
+                    size=12,
+                    color=COLORS["red"],
+                    line=dict(color="white", width=1),
+                ),
+                name="Sell Signal",
+                text=sells["Signal_Reason"],
+                hovertemplate="%{text}<extra>SELL</extra>",
+            ),
+            row=1,
+            col=1,
         )
-        return result.summary_text
-    except Exception as e:
-        logger.warning("Combined summarization failed: %s", e)
-        return combined
 
+    # --- Row 2: RSI ---------------------------------------------------------
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["RSI"],
+            mode="lines",
+            line=dict(color=COLORS["purple"], width=1.3),
+            name="RSI (14)",
+        ),
+        row=2,
+        col=1,
+    )
+    # Overbought / oversold lines
+    for level, clr in [(70, COLORS["red"]), (30, COLORS["green"])]:
+        fig.add_hline(
+            y=level,
+            line_dash="dash",
+            line_color=clr,
+            opacity=0.5,
+            row=2,
+            col=1,
+        )
+    # Shade the 30-70 zone
+    fig.add_hrect(
+        y0=30,
+        y1=70,
+        fillcolor="rgba(255,255,255,0.03)",
+        line_width=0,
+        row=2,
+        col=1,
+    )
 
-# ===========================================================================
-# Section extraction helpers
-# ===========================================================================
+    # --- Row 3: MACD --------------------------------------------------------
+    macd_colors = [
+        COLORS["green"] if v >= 0 else COLORS["red"]
+        for v in df["MACD_Hist"].fillna(0)
+    ]
+    fig.add_trace(
+        go.Bar(
+            x=dates,
+            y=df["MACD_Hist"],
+            marker_color=macd_colors,
+            name="MACD Hist",
+            showlegend=False,
+        ),
+        row=3,
+        col=1,
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["MACD"],
+            mode="lines",
+            line=dict(color=COLORS["blue"], width=1.2),
+            name="MACD",
+        ),
+        row=3,
+        col=1,
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["MACD_Signal"],
+            mode="lines",
+            line=dict(color=COLORS["orange"], width=1.2),
+            name="Signal Line",
+        ),
+        row=3,
+        col=1,
+    )
 
-def extract_section(text: str, heading_pattern: str, fallback: str = "") -> str:
-    """Extract content under a section heading matched by *heading_pattern*.
+    # --- Row 4: Volume ------------------------------------------------------
+    vol_colors = [
+        COLORS["green"] if c >= o else COLORS["red"]
+        for c, o in zip(df["Close"], df["Open"])
+    ]
+    fig.add_trace(
+        go.Bar(
+            x=dates,
+            y=df["Volume"],
+            marker_color=vol_colors,
+            name="Volume",
+            showlegend=False,
+        ),
+        row=4,
+        col=1,
+    )
 
-    Uses a regex to find the heading and captures everything until the next
-    heading of equal or higher level.
-    """
-    pattern = re.compile(
-        rf"(?:^|\n)\s*(?:\d+[\.\)]?\s*)?{heading_pattern}\s*\n(.*?)(?=\n\s*(?:\d+[\.\)]?\s*)?[A-Z][A-Za-z ]+\s*\n|\Z)",
-        re.DOTALL | re.IGNORECASE,
+    # --- Layout -------------------------------------------------------------
+    fig.update_layout(
+        **_PLOTLY_LAYOUT_DEFAULTS,
+        title=dict(
+            text=f"{ticker} -- Technical Analysis Dashboard",
+            font=dict(size=20),
+            x=0.5,
+        ),
+        height=900,
+        xaxis_rangeslider_visible=False,
     )
-    match = pattern.search(text)
-    if match:
-        content = match.group(1).strip()
-        if len(content) > 30:
-            return content
-    return fallback
-
-
-def extract_key_findings(text: str) -> str:
-    """Try to extract key findings from Results / Conclusion sections, or
-    fall back to summarizing the last portion of the paper."""
-    for heading in [
-        r"(?:key\s+)?findings",
-        r"results?\s*(?:and\s+discussion)?",
-        r"conclusions?\s*(?:and\s+future\s+work)?",
-        r"discussion",
-    ]:
-        content = extract_section(text, heading)
-        if content:
-            return summarize_text(content[:3000])
-    # Fallback: summarize the last quarter of the document.
-    words = text.split()
-    tail = " ".join(words[-(len(words) // 4):])
-    if len(tail.split()) > 50:
-        return summarize_text(tail[:3000])
-    return "Key findings could not be automatically extracted."
-
-
-def extract_methodology(text: str) -> str:
-    """Try to extract methodology information from the paper."""
-    for heading in [
-        r"method(?:ology|s)?",
-        r"approach",
-        r"experimental\s+setup",
-        r"materials?\s+and\s+methods",
-        r"(?:proposed\s+)?(?:framework|system|model|architecture)",
-    ]:
-        content = extract_section(text, heading)
-        if content:
-            return summarize_text(content[:3000])
-    return "Methodology section could not be automatically extracted."
 
+    # Y-axis labels
+    fig.update_yaxes(title_text="Price ($)", row=1, col=1, gridcolor=COLORS["grid"])
+    fig.update_yaxes(title_text="RSI", row=2, col=1, gridcolor=COLORS["grid"], range=[0, 100])
+    fig.update_yaxes(title_text="MACD", row=3, col=1, gridcolor=COLORS["grid"])
+    fig.update_yaxes(title_text="Volume", row=4, col=1, gridcolor=COLORS["grid"])
 
-# ===========================================================================
-# Main processing function
-# ===========================================================================
+    for i in range(1, 5):
+        fig.update_xaxes(gridcolor=COLORS["grid"], row=i, col=1)
 
-def process_paper(
-    pdf_file: Optional[str],
-    pasted_text: Optional[str],
-) -> str:
-    """Process a research paper and return a structured summary.
+    return fig
 
-    Accepts either a PDF file path (from Gradio upload) or raw pasted text.
-    Returns a Markdown-formatted structured summary.
-    """
-    # ------------------------------------------------------------------
-    # 1. Obtain raw text
-    # ------------------------------------------------------------------
-    if pdf_file is not None:
-        logger.info("Processing uploaded PDF: %s", pdf_file)
-        try:
-            raw_text = extract_text_from_pdf(pdf_file)
-        except ValueError as exc:
-            return f"**Error:** {exc}"
-    elif pasted_text and pasted_text.strip():
-        raw_text = pasted_text.strip()
-    else:
-        return (
-            "**Error:** Please upload a PDF file or paste the paper text. "
-            "Both inputs are currently empty."
+
+def build_backtest_chart(
+    df: pd.DataFrame, backtest: dict, ticker: str
+) -> go.Figure:
+    """Build the equity-curve comparison chart for the backtest tab."""
+
+    close = df["Close"].values.astype(float)
+    dates = df.index
+
+    # Normalize buy-and-hold to same starting capital
+    bh_equity = (close / close[0]) * backtest["initial_capital"]
+
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=backtest["equity_curve"],
+            mode="lines",
+            name="Signal Strategy",
+            line=dict(color=COLORS["green"], width=2),
+            fill="tozeroy",
+            fillcolor="rgba(0, 212, 170, 0.07)",
         )
+    )
 
-    text = clean_text(raw_text)
-    original_word_count = len(text.split())
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=bh_equity,
+            mode="lines",
+            name="Buy & Hold",
+            line=dict(color=COLORS["blue"], width=2, dash="dot"),
+        )
+    )
 
-    if original_word_count < 30:
-        return (
-            "**Error:** The extracted text is too short to summarize. "
-            "Please provide a longer document or check that the PDF contains selectable text."
+    # Buy / sell markers on equity curve
+    buys = df[df["Signal"] == 1]
+    sells = df[df["Signal"] == -1]
+
+    if not buys.empty:
+        buy_indices = [df.index.get_loc(d) for d in buys.index]
+        fig.add_trace(
+            go.Scatter(
+                x=buys.index,
+                y=[backtest["equity_curve"][i] for i in buy_indices],
+                mode="markers",
+                marker=dict(symbol="triangle-up", size=10, color=COLORS["green"]),
+                name="Buy",
+                showlegend=False,
+            )
         )
 
-    logger.info("Cleaned text: %d words.", original_word_count)
+    if not sells.empty:
+        sell_indices = [df.index.get_loc(d) for d in sells.index]
+        fig.add_trace(
+            go.Scatter(
+                x=sells.index,
+                y=[backtest["equity_curve"][i] for i in sell_indices],
+                mode="markers",
+                marker=dict(symbol="triangle-down", size=10, color=COLORS["red"]),
+                name="Sell",
+                showlegend=False,
+            )
+        )
 
-    # ------------------------------------------------------------------
-    # 2. Extract structured components
-    # ------------------------------------------------------------------
-    title = extract_title(text)
-    concise_summary = generate_full_summary(text)
-    key_findings = extract_key_findings(text)
-    methodology = extract_methodology(text)
+    fig.update_layout(
+        **_PLOTLY_LAYOUT_DEFAULTS,
+        title=dict(
+            text=f"{ticker} -- Strategy vs Buy & Hold (${backtest['initial_capital']:,.0f} start)",
+            font=dict(size=18),
+            x=0.5,
+        ),
+        yaxis_title="Portfolio Value ($)",
+        xaxis_title="Date",
+        height=500,
+    )
 
-    summary_word_count = len(concise_summary.split())
+    fig.update_yaxes(gridcolor=COLORS["grid"])
+    fig.update_xaxes(gridcolor=COLORS["grid"])
 
-    # ------------------------------------------------------------------
-    # 3. Format the output
-    # ------------------------------------------------------------------
-    output = f"""## {title}
+    return fig
 
----
 
-### Concise Summary
-{concise_summary}
+# ---------------------------------------------------------------------------
+# Backtest Summary Markdown
+# ---------------------------------------------------------------------------
 
----
 
-### Key Findings
-{key_findings}
+def format_backtest_summary(bt: dict, ticker: str) -> str:
+    """Return a Markdown summary of backtest results."""
+    strat_color = "green" if bt["strategy_return_pct"] >= 0 else "red"
+    bh_color = "green" if bt["buy_hold_return_pct"] >= 0 else "red"
+    outperform = bt["strategy_return_pct"] - bt["buy_hold_return_pct"]
+    op_color = "green" if outperform >= 0 else "red"
 
----
+    return f"""
+### Backtest Results for {ticker}
 
-### Methodology
-{methodology}
+| Metric | Value |
+|--------|-------|
+| Initial Capital | ${bt['initial_capital']:,.2f} |
+| Final Portfolio Value | ${bt['final_value']:,.2f} |
+| **Strategy Return** | **{bt['strategy_return_pct']:+.2f}%** |
+| **Buy & Hold Return** | **{bt['buy_hold_return_pct']:+.2f}%** |
+| **Outperformance** | **{outperform:+.2f}%** |
+| Total Trades | {bt['total_trades']} |
+| Winning Trades | {bt['winning_trades']} |
+| Win Rate | {bt['win_rate_pct']:.1f}% |
 
 ---
 
-### Statistics
-| Metric | Value |
-|---|---|
-| Original length | {original_word_count:,} words |
-| Summary length | {summary_word_count:,} words |
-| Compression ratio | {original_word_count / max(summary_word_count, 1):.1f}x |
+*Starting capital: $10,000. Strategy goes fully invested on BUY signals and exits to cash on SELL signals. No transaction costs or slippage modeled.*
 """
-    return output
 
 
-# ===========================================================================
-# Example inputs for the Gradio demo
-# ===========================================================================
+# ---------------------------------------------------------------------------
+# Main Analysis Pipeline
+# ---------------------------------------------------------------------------
 
-EXAMPLE_TEXT = """Attention Is All You Need
 
-Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin
+def analyze(ticker: str, timeframe: str):
+    """Run the full analysis pipeline and return outputs for all three tabs.
 
-Abstract
-The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task, improving over the existing best results, including ensembles, by over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training costs of the best models from the literature. We show that the Transformer generalizes well to other tasks by applying it successfully to English constituency parsing both with large and limited training data.
+    Returns:
+        main_chart: Plotly figure for the Charts tab.
+        signal_table: DataFrame for the Signals tab.
+        backtest_chart: Plotly figure for the Backtest tab.
+        backtest_summary: Markdown string for the Backtest tab.
+        status: Status message string.
+    """
+    ticker = ticker.strip().upper()
+    if not ticker:
+        empty_fig = go.Figure()
+        empty_fig.update_layout(**_PLOTLY_LAYOUT_DEFAULTS, height=400)
+        return (
+            empty_fig,
+            pd.DataFrame(columns=["Date", "Close", "Type", "Reason"]),
+            empty_fig,
+            "Please enter a valid ticker symbol.",
+            "Enter a ticker to begin.",
+        )
 
-Introduction
-Recurrent neural networks, long short-term memory and gated recurrent neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and transduction problems such as language modeling and machine translation. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures. Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden states ht, as a function of the previous hidden state ht-1 and the input for position t. This inherently sequential nature precludes parallelization within training examples, which becomes critical at longer sequence lengths, as memory constraints limit batching across examples.
+    # Fetch data
+    df, error = fetch_stock_data(ticker, timeframe)
+    if error:
+        empty_fig = go.Figure()
+        empty_fig.update_layout(**_PLOTLY_LAYOUT_DEFAULTS, height=400)
+        return (
+            empty_fig,
+            pd.DataFrame(columns=["Date", "Close", "Type", "Reason"]),
+            empty_fig,
+            f"**Error:** {error}",
+            f"Error: {error}",
+        )
 
-Methods
-The Transformer follows an encoder-decoder structure using stacked self-attention and point-wise, fully connected layers for both the encoder and decoder. The encoder maps an input sequence of symbol representations to a sequence of continuous representations. Given z, the decoder then generates an output sequence of symbols one element at a time. At each step the model is auto-regressive, consuming the previously generated symbols as additional input when generating the next. The Transformer uses multi-head attention to allow the model to jointly attend to information from different representation subspaces at different positions.
+    # Compute indicators and signals
+    df = compute_indicators(df)
+    df = generate_signals(df)
+
+    # Build outputs
+    main_chart = build_main_chart(df, ticker)
+    signal_table = build_signal_table(df)
+    bt = run_backtest(df)
+    backtest_chart = build_backtest_chart(df, bt, ticker)
+    backtest_summary = format_backtest_summary(bt, ticker)
+
+    n_buys = int((df["Signal"] == 1).sum())
+    n_sells = int((df["Signal"] == -1).sum())
+    latest_close = df["Close"].iloc[-1]
+    latest_rsi = df["RSI"].iloc[-1]
+
+    status = (
+        f"**{ticker}** | Last Close: ${latest_close:.2f} | "
+        f"RSI: {latest_rsi:.1f} | "
+        f"Signals: {n_buys} buys, {n_sells} sells ({timeframe})"
+    )
 
-Results
-On the WMT 2014 English-to-German translation task, the big transformer model outperforms the best previously reported models including ensembles by more than 2.0 BLEU, establishing a new state-of-the-art BLEU score of 28.4. On the WMT 2014 English-to-French translation task, our big model achieves a BLEU score of 41.0, outperforming all of the previously published single models, at less than 1/4 the training cost of the previous state-of-the-art model. The Transformer can be trained significantly faster than architectures based on recurrent or convolutional layers.
+    return main_chart, signal_table, backtest_chart, backtest_summary, status
 
-Conclusions
-In this work, we presented the Transformer, the first sequence transduction model based entirely on attention, replacing the recurrent layers most commonly used in encoder-decoder architectures with multi-headed self-attention. The Transformer can be trained significantly faster than architectures based on recurrent or convolutional layers. We achieved new state of the art on both WMT 2014 English-to-German and WMT 2014 English-to-French translation tasks. We plan to extend the Transformer to problems involving input and output modalities other than text and to investigate local, restricted attention mechanisms to efficiently handle large inputs and outputs such as images, audio and video."""
 
+# ---------------------------------------------------------------------------
+# Gradio Interface
+# ---------------------------------------------------------------------------
 
-# ===========================================================================
-# Gradio interface
-# ===========================================================================
 
-def build_interface() -> gr.Blocks:
-    """Construct and return the Gradio Blocks interface."""
+def create_app() -> gr.Blocks:
+    """Build and return the Gradio Blocks application."""
+
+    css = """
+    .disclaimer {
+        background-color: #2a1a1a;
+        border-left: 4px solid #ff6b6b;
+        padding: 12px 16px;
+        border-radius: 4px;
+        margin-bottom: 16px;
+        font-size: 0.85em;
+    }
+    .status-bar {
+        background-color: #1a1d29;
+        padding: 10px 16px;
+        border-radius: 6px;
+        border: 1px solid #2a2d3a;
+        font-size: 0.95em;
+    }
+    footer { display: none !important; }
+    """
 
     with gr.Blocks(
-        title="Paper Summarizer",
-        theme=gr.themes.Soft(
-            primary_hue="indigo",
-            secondary_hue="blue",
+        title="Trading Signal Dashboard",
+        theme=gr.themes.Base(
+            primary_hue=gr.themes.colors.purple,
+            secondary_hue=gr.themes.colors.pink,
+            neutral_hue=gr.themes.colors.gray,
+            font=gr.themes.GoogleFont("Inter"),
         ),
-        css="""
-            .header-text { text-align: center; margin-bottom: 0.5em; }
-            .subheader  { text-align: center; color: #6b7280; margin-top: 0; }
-            footer { display: none !important; }
-        """,
-    ) as demo:
-        # --- Header ---
+        css=css,
+    ) as app:
+        # Header
         gr.Markdown(
-            """
-            <h1 class="header-text">Paper Summarizer</h1>
-            <p class="subheader">
-                Summarize academic research papers into structured, digestible insights.<br>
-                Upload a PDF or paste the full text below.
-            </p>
-            """,
+            "# Trading Signal Dashboard\n"
+            "Real-time technical analysis with automated signal generation & backtesting"
         )
+        gr.Markdown(DISCLAIMER_TEXT, elem_classes=["disclaimer"])
 
+        # Controls
         with gr.Row():
-            # --- Input column ---
-            with gr.Column(scale=1):
-                gr.Markdown("### Input")
-                pdf_input = gr.File(
-                    label="Upload PDF",
-                    file_types=[".pdf"],
-                    type="filepath",
-                )
-                text_input = gr.Textbox(
-                    label="Or paste paper text",
-                    placeholder="Paste the full text of a research paper here...",
-                    lines=12,
-                    max_lines=30,
+            ticker_input = gr.Dropdown(
+                choices=DEFAULT_TICKERS,
+                value="AAPL",
+                label="Stock Ticker",
+                allow_custom_value=True,
+                info="Select a preset or type any valid ticker symbol",
+                scale=2,
+            )
+            timeframe_input = gr.Dropdown(
+                choices=list(TIMEFRAME_MAP.keys()),
+                value="6 Months",
+                label="Timeframe",
+                scale=1,
+            )
+            analyze_btn = gr.Button(
+                "Analyze",
+                variant="primary",
+                scale=1,
+            )
+
+        # Status bar
+        status_output = gr.Markdown(
+            "Enter a ticker and click **Analyze** to begin.",
+            elem_classes=["status-bar"],
+        )
+
+        # Tabbed outputs
+        with gr.Tabs():
+            with gr.TabItem("Charts", id="charts"):
+                chart_output = gr.Plot(label="Technical Analysis Chart")
+
+            with gr.TabItem("Signals", id="signals"):
+                gr.Markdown("### Recent Trading Signals")
+                gr.Markdown(
+                    "Signals are generated from SMA crossovers, MACD crossovers, "
+                    "and RSI overbought/oversold exits."
                 )
-                submit_btn = gr.Button("Summarize", variant="primary", size="lg")
-
-            # --- Output column ---
-            with gr.Column(scale=1):
-                gr.Markdown("### Structured Summary")
-                output = gr.Markdown(
-                    value="*Your summary will appear here after processing.*",
-                    label="Summary",
+                signal_table_output = gr.Dataframe(
+                    headers=["Date", "Close", "Type", "Reason"],
+                    label="Signal Log",
+                    wrap=True,
                 )
 
-        # --- Examples ---
-        gr.Markdown("---")
-        gr.Markdown("### Try an Example")
-        gr.Examples(
-            examples=[[None, EXAMPLE_TEXT]],
-            inputs=[pdf_input, text_input],
-            outputs=output,
-            fn=process_paper,
-            cache_examples=False,
-            label="Click to load example paper text",
+            with gr.TabItem("Backtest Results", id="backtest"):
+                gr.Markdown("### Strategy Backtest")
+                gr.Markdown(
+                    "Simulates following the generated signals with a $10,000 starting "
+                    "portfolio and compares against a simple buy-and-hold strategy."
+                )
+                backtest_summary_output = gr.Markdown()
+                backtest_chart_output = gr.Plot(label="Equity Curve")
+
+        # Wire up the button
+        analyze_btn.click(
+            fn=analyze,
+            inputs=[ticker_input, timeframe_input],
+            outputs=[
+                chart_output,
+                signal_table_output,
+                backtest_chart_output,
+                backtest_summary_output,
+                status_output,
+            ],
         )
 
-        # --- About ---
-        with gr.Accordion("About this Space", open=False):
-            gr.Markdown(
-                """
-                **Paper Summarizer** uses
-                [`facebook/bart-large-cnn`](https://huggingface.co/facebook/bart-large-cnn)
-                to generate abstractive summaries of academic papers.
-
-                **Features**
-                - PDF upload with automatic text extraction (PyMuPDF)
-                - Intelligent chunking for papers of any length
-                - Structured output: title, key findings, methodology, and concise summary
-                - Word-count statistics and compression ratio
-
-                **Limitations**
-                - Scanned PDFs (image-only) are not supported; the PDF must contain selectable text.
-                - Summarization quality depends on the input text quality and structure.
-                - Running on free CPU tier; very long papers may take a minute to process.
-
-                Built by [Lorenzo Scaturchio](https://huggingface.co/gr8monk3ys).
-                """
-            )
+        # Also trigger on dropdown change for quick exploration
+        ticker_input.change(
+            fn=analyze,
+            inputs=[ticker_input, timeframe_input],
+            outputs=[
+                chart_output,
+                signal_table_output,
+                backtest_chart_output,
+                backtest_summary_output,
+                status_output,
+            ],
+        )
+        timeframe_input.change(
+            fn=analyze,
+            inputs=[ticker_input, timeframe_input],
+            outputs=[
+                chart_output,
+                signal_table_output,
+                backtest_chart_output,
+                backtest_summary_output,
+                status_output,
+            ],
+        )
 
-        # --- Event binding ---
-        submit_btn.click(
-            fn=process_paper,
-            inputs=[pdf_input, text_input],
-            outputs=output,
+        # Footer
+        gr.Markdown(
+            "---\n"
+            "Built by [Lorenzo Scaturchio](https://huggingface.co/gr8monk3ys) | "
+            "Data from Yahoo Finance | "
+            "Not financial advice"
         )
 
-    return demo
+    return app
 
 
-# ===========================================================================
-# Entry point
-# ===========================================================================
+# ---------------------------------------------------------------------------
+# Entry Point
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-    app = build_interface()
+    app = create_app()
     app.launch()

requirements.txt

@@ -1,3 +1,6 @@
-gradio==4.44.0
-huggingface_hub==0.22.2
-PyMuPDF>=1.24.0
+gradio==5.9.1
+yfinance>=0.2.31
+plotly>=5.18.0
+pandas>=2.0.0
+numpy>=1.24.0
+ta>=0.11.0