Upload folder using huggingface_hub

app.py

@@ -197,7 +197,7 @@ def create_portfolio_chart():
 
 def create_ipo_discovery_chart():
     """Create IPO discovery chart with investment decisions"""
-    ipos = fetch_from_vm('ipos?limit=30', [])
+    ipos = fetch_from_vm('ipos?limit=100', [])
     
     if not ipos:
         fig = go.Figure()

hf_space/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

hf_space/README.md

@@ -0,0 +1,34 @@
+---
+title: Trading_Dashboard
+app_file: app.py
+sdk: gradio
+sdk_version: 5.35.0
+---
+# Stock-Trader
+ Line of best fit stock trader test
+
+
+## ENV MANAGER:
+>To CREATE/UPDATE YAML (from PC to file) go to reg. terminal:
+>conda env export > env.yml
+>
+>To create env (from file to PC):
+>conda env create --file=env.yml
+>
+>To update ENV (FROM FILE TO PC) (run in conda terminal) (if i remove --prune it works in terminal?):
+>conda env update --file env.yml --prune
+
+
+
+
+### THIS WORKED TO FIX QT ISSUE:
+    from PyQt5.QtCore import QCoreApplication, Qt
+
+    # Clear any cached Qt plugins
+    QCoreApplication.setAttribute(Qt.AA_DisableHighDpiScaling, True)
+
+    app = QCoreApplication([])
+
+
+
+# This might not be needed since we are using conda... (TO ACTIVATE ENV: source venv/bin/activate)

hf_space/app.py

@@ -0,0 +1,598 @@
+#!/usr/bin/env python3
+"""
+Premium Trading Dashboard - Full Featured
+Beautiful Vercel-style dashboard with VM data integration
+"""
+
+import os
+import pandas as pd
+import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta, timezone
+import logging
+import requests
+from alpaca.trading.client import TradingClient
+from alpaca.trading.requests import GetOrdersRequest, GetPortfolioHistoryRequest
+from alpaca.trading.enums import OrderStatus
+from alpaca.data.timeframe import TimeFrame
+from alpaca.data.historical import StockHistoricalDataClient
+
+# Get API keys and VM URL from environment variables
+API_KEY = os.getenv('ALPACA_API_KEY', 'PK2FD9B2S86LHR7ZBHG1')
+SECRET_KEY = os.getenv('ALPACA_SECRET_KEY', 'QPmGPDgbPArvHv6cldBXc7uWddapYcIAnBhtkuBW')
+VM_API_URL = os.getenv('VM_API_URL', 'http://34.56.193.18:8090')  # Set this in Hugging Face
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize Alpaca clients
+trading_client = TradingClient(api_key=API_KEY, secret_key=SECRET_KEY)
+data_client = StockHistoricalDataClient(API_KEY, SECRET_KEY)
+
+# Modern color scheme
+COLORS = {
+    'primary': '#0070f3',
+    'success': '#00d647',
+    'error': '#ff0080',
+    'warning': '#f5a623',
+    'neutral': '#8b949e',
+    'background': '#fafafa',
+    'surface': '#ffffff',
+    'text': '#000000',
+    'text_secondary': '#666666',
+    'border': '#eaeaea'
+}
+
+def fetch_from_vm(endpoint, default_value=None):
+    """Fetch data from VM API server"""
+    try:
+        response = requests.get(f"{VM_API_URL}/api/{endpoint}", timeout=10)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            logger.warning(f"VM API {endpoint} returned {response.status_code}")
+            return default_value
+    except Exception as e:
+        logger.error(f"Error fetching from VM {endpoint}: {e}")
+        return default_value
+
+def get_account_info():
+    """Get current account information from Alpaca"""
+    try:
+        account = trading_client.get_account()
+        return {
+            'portfolio_value': float(account.portfolio_value),
+            'buying_power': float(account.buying_power),
+            'cash': float(account.cash),
+            'equity': float(account.equity),
+            'day_change': float(getattr(account, 'unrealized_pl', 0)) if hasattr(account, 'unrealized_pl') else 0,
+            'day_change_percent': float(getattr(account, 'unrealized_plpc', 0)) * 100 if hasattr(account, 'unrealized_plpc') else 0,
+            'last_equity': float(account.last_equity) if account.last_equity else 0
+        }
+    except Exception as e:
+        logger.error(f"Error fetching account info: {e}")
+        return {
+            'portfolio_value': 0, 'buying_power': 0, 'cash': 0, 'equity': 0,
+            'day_change': 0, 'day_change_percent': 0, 'last_equity': 0
+        }
+
+def get_portfolio_history():
+    """Get portfolio value history from Alpaca"""
+    try:
+        portfolio_history_request = GetPortfolioHistoryRequest(
+            period="1M",
+            timeframe="1D",
+            extended_hours=False
+        )
+        
+        portfolio_history = trading_client.get_portfolio_history(portfolio_history_request)
+        
+        timestamps = [datetime.fromtimestamp(ts, tz=timezone.utc) for ts in portfolio_history.timestamp]
+        equity_values = portfolio_history.equity
+        
+        df = pd.DataFrame({
+            'timestamp': timestamps,
+            'equity': equity_values
+        })
+        
+        return df.dropna()
+    except Exception as e:
+        logger.error(f"Error fetching portfolio history: {e}")
+        return pd.DataFrame()
+
+def get_current_positions():
+    """Get current positions"""
+    try:
+        positions = trading_client.get_all_positions()
+        position_data = []
+        
+        for position in positions:
+            position_data.append({
+                'symbol': position.symbol,
+                'qty': float(position.qty),
+                'market_value': float(position.market_value),
+                'cost_basis': float(position.cost_basis),
+                'unrealized_pl': float(position.unrealized_pl),
+                'unrealized_plpc': float(position.unrealized_plpc) * 100,
+                'current_price': float(position.current_price) if position.current_price else 0
+            })
+        
+        return position_data
+    except Exception as e:
+        logger.error(f"Error fetching positions: {e}")
+        return []
+
+def create_portfolio_chart():
+    """Create beautiful portfolio value chart"""
+    portfolio_df = get_portfolio_history()
+    
+    if portfolio_df.empty:
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No portfolio history available",
+            x=0.5, y=0.5,
+            xref="paper", yref="paper",
+            showarrow=False,
+            font=dict(size=16, color=COLORS['text_secondary'])
+        )
+    else:
+        fig = go.Figure()
+        
+        fig.add_trace(go.Scatter(
+            x=portfolio_df['timestamp'],
+            y=portfolio_df['equity'],
+            mode='lines',
+            name='Portfolio Value',
+            line=dict(color=COLORS['primary'], width=3),
+            fill='tonexty',
+            fillcolor=f"rgba(0, 112, 243, 0.1)",
+            hovertemplate='<b>%{y:$,.2f}</b><br>%{x}<extra></extra>'
+        ))
+        
+        if len(portfolio_df) > 0:
+            current_value = portfolio_df['equity'].iloc[-1]
+            fig.add_annotation(
+                x=portfolio_df['timestamp'].iloc[-1],
+                y=current_value,
+                text=f"${current_value:,.2f}",
+                showarrow=True,
+                arrowhead=2,
+                arrowcolor=COLORS['primary'],
+                bgcolor="white",
+                bordercolor=COLORS['primary'],
+                borderwidth=2,
+                font=dict(size=12, color=COLORS['text'])
+            )
+    
+    fig.update_layout(
+        title=dict(
+            text="Portfolio Value (Last 30 Days)",
+            font=dict(size=24, color=COLORS['text'], family="Inter"),
+            x=0.02
+        ),
+        xaxis=dict(
+            title="Date",
+            showgrid=True,
+            gridcolor=COLORS['border'],
+            color=COLORS['text_secondary']
+        ),
+        yaxis=dict(
+            title="Portfolio Value ($)",
+            showgrid=True,
+            gridcolor=COLORS['border'],
+            color=COLORS['text_secondary'],
+            tickformat='$,.0f'
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        height=400,
+        margin=dict(l=60, r=40, t=60, b=60),
+        hovermode='x unified',
+        showlegend=False
+    )
+    
+    return fig
+
+def create_ipo_discovery_chart():
+    """Create IPO discovery chart with investment decisions"""
+    ipos = fetch_from_vm('ipos?limit=30', [])
+    
+    if not ipos:
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No IPO data available from VM",
+            x=0.5, y=0.5,
+            xref="paper", yref="paper",
+            showarrow=False,
+            font=dict(size=16, color=COLORS['text_secondary'])
+        )
+    else:
+        # Count by status
+        status_counts = {}
+        for ipo in ipos:
+            status = ipo.get('investment_status', 'UNKNOWN')
+            status_counts[status] = status_counts.get(status, 0) + 1
+        
+        # Create pie chart
+        labels = list(status_counts.keys())
+        values = list(status_counts.values())
+        
+        # Map status to colors
+        color_map = {
+            'INVESTED': COLORS['success'],
+            'ELIGIBLE_NOT_INVESTED': COLORS['warning'], 
+            'WRONG_TYPE': COLORS['neutral'],
+            'UNKNOWN': COLORS['error']
+        }
+        colors = [color_map.get(label, COLORS['neutral']) for label in labels]
+        
+        fig = go.Figure(data=[go.Pie(
+            labels=labels,
+            values=values,
+            hole=0.4,
+            marker=dict(colors=colors),
+            textinfo='label+percent',
+            textposition='outside'
+        )])
+    
+    fig.update_layout(
+        title=dict(
+            text="IPO Investment Decisions",
+            font=dict(size=24, color=COLORS['text'], family="Inter"),
+            x=0.5
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        height=400,
+        margin=dict(l=60, r=60, t=60, b=60),
+        showlegend=True
+    )
+    
+    return fig
+
+def refresh_account_overview():
+    """Refresh account overview display"""
+    account = get_account_info()
+    
+    portfolio_value = f"${account['portfolio_value']:,.2f}"
+    buying_power = f"${account['buying_power']:,.2f}"
+    cash = f"${account['cash']:,.2f}"
+    
+    day_change_value = account['day_change']
+    day_change_percent = account['day_change_percent']
+    if day_change_value > 0:
+        day_change = f"↗️ +${day_change_value:,.2f} (+{day_change_percent:.2f}%)"
+    elif day_change_value < 0:
+        day_change = f"↘️ ${day_change_value:,.2f} ({day_change_percent:.2f}%)"
+    else:
+        day_change = f"➡️ ${day_change_value:,.2f} ({day_change_percent:.2f}%)"
+    
+    equity = f"${account['equity']:,.2f}"
+    
+    return portfolio_value, buying_power, cash, day_change, equity
+
+def refresh_positions_table():
+    """Refresh current positions table"""
+    positions = get_current_positions()
+    if not positions:
+        return pd.DataFrame(columns=['Symbol', 'Quantity', 'Market Value', 'Unrealized P&L', 'Unrealized %'])
+    
+    df_data = []
+    for pos in positions:
+        pnl_indicator = "🟢" if pos['unrealized_pl'] > 0 else "🔴" if pos['unrealized_pl'] < 0 else "⚪"
+        df_data.append({
+            'Symbol': f"{pnl_indicator} {pos['symbol']}",
+            'Quantity': f"{pos['qty']:.0f}",
+            'Market Value': f"${pos['market_value']:,.2f}",
+            'Unrealized P&L': f"${pos['unrealized_pl']:,.2f}",
+            'Unrealized %': f"{pos['unrealized_plpc']:.2f}%"
+        })
+    
+    return pd.DataFrame(df_data)
+
+def refresh_ipo_discoveries_table():
+    """Refresh IPO discoveries table with investment decisions"""
+    ipos = fetch_from_vm('ipos?limit=100', [])
+    
+    if not ipos:
+        return pd.DataFrame(columns=['Status', 'Symbol', 'Security Type', 'Price', 'Detected At'])
+    
+    df_data = []
+    for ipo in ipos:
+        status_emoji = ipo.get('status_emoji', '⚪')
+        status = ipo.get('investment_status', 'UNKNOWN')
+        
+        # Clean up status for display
+        display_status = {
+            'INVESTED': '🟢 INVESTED',
+            'ELIGIBLE_NOT_INVESTED': '🟡 ELIGIBLE', 
+            'WRONG_TYPE': '⚪ WRONG TYPE',
+            'UNKNOWN': '🔴 UNKNOWN'
+        }.get(status, '⚪ UNKNOWN')
+        
+        df_data.append({
+            'Status': display_status,
+            'Symbol': ipo.get('symbol', 'N/A'),
+            'Security Type': ipo.get('security_type', 'N/A'),
+            'Price': f"${ipo.get('trading_price', 0)}" if ipo.get('trading_price') != 'N/A' else 'N/A',
+            'Detected At': ipo.get('detected_at', 'N/A')
+        })
+    
+    return pd.DataFrame(df_data)
+
+def refresh_vm_stats():
+    """Refresh VM statistics"""
+    stats = fetch_from_vm('stats', {})
+    
+    if not stats:
+        return "0", "0", "0", "0%", "No data"
+    
+    return (
+        str(stats.get('total_ipos_detected', 0)),
+        str(stats.get('ipos_invested', 0)),
+        str(stats.get('cs_stocks_detected', 0)),
+        f"{stats.get('investment_rate', 0):.1f}%",
+        stats.get('last_updated', 'N/A')
+    )
+
+def refresh_system_logs():
+    """Refresh system logs from VM"""
+    logs = fetch_from_vm('logs', [])
+    
+    if not logs:
+        return "No logs available from VM"
+    
+    # Format logs for display
+    formatted_logs = []
+    for log in logs:
+        emoji = log.get('emoji', '⚪')
+        timestamp = log.get('timestamp', 'N/A')
+        message = log.get('message', '')
+        formatted_logs.append(f"{emoji} {timestamp} | {message}")
+    
+    return '\n'.join(formatted_logs)
+
+def refresh_raw_logs():
+    """Refresh raw logs from VM"""
+    raw_data = fetch_from_vm('logs/raw?lines=1000', {})
+    
+    if not raw_data:
+        return "No raw logs available from VM"
+    
+    content = raw_data.get('content', 'No content')
+    total_lines = raw_data.get('total_lines', 0)
+    showing_lines = raw_data.get('showing_lines', 0)
+    
+    header = f"=== RAW CRON LOGS ===\nShowing last {showing_lines} of {total_lines} total lines\n\n"
+    return header + content
+
+# Custom CSS for gorgeous design
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
+    background: #fafafa !important;
+}
+
+.main-header {
+    background: linear-gradient(135deg, #0070f3 0%, #0051a5 100%);
+    color: white;
+    padding: 2rem;
+    border-radius: 16px;
+    margin-bottom: 2rem;
+    box-shadow: 0 10px 40px rgba(0, 112, 243, 0.3);
+}
+
+.metric-card {
+    background: white;
+    border: 1px solid #eaeaea;
+    border-radius: 12px;
+    padding: 1.5rem;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.04);
+    transition: all 0.3s ease;
+}
+
+.metric-card:hover {
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
+    transform: translateY(-4px);
+}
+
+.gr-button {
+    background: linear-gradient(135deg, #0070f3 0%, #0051a5 100%) !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 12px !important;
+    font-weight: 600 !important;
+    padding: 1rem 2rem !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 16px rgba(0, 112, 243, 0.3) !important;
+}
+
+.gr-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 32px rgba(0, 112, 243, 0.4) !important;
+}
+
+.gr-textbox, .gr-dataframe {
+    border: 1px solid #eaeaea !important;
+    border-radius: 12px !important;
+    background: white !important;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04) !important;
+}
+
+.plotly-graph-div {
+    border-radius: 16px !important;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.08) !important;
+    background: white !important;
+}
+
+.status-invested { color: #00d647 !important; font-weight: 600 !important; }
+.status-eligible { color: #f5a623 !important; font-weight: 600 !important; }
+.status-wrong { color: #8b949e !important; }
+.status-unknown { color: #ff0080 !important; }
+"""
+
+def create_dashboard():
+    with gr.Blocks(
+        title="🚀 Premium Trading Dashboard", 
+        theme=gr.themes.Soft(primary_hue="blue"),
+        css=custom_css
+    ) as demo:
+        
+        # Header
+        gr.HTML("""
+            <div class="main-header">
+                <h1 style="margin: 0; font-size: 3rem; font-weight: 800; text-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    🚀 Premium Trading Dashboard
+                </h1>
+                <p style="margin: 1rem 0 0 0; font-size: 1.3rem; opacity: 0.95;">
+                    Real-time portfolio monitoring with IPO discovery analytics
+                </p>
+            </div>
+        """)
+        
+        with gr.Tabs():
+            # Portfolio Overview Tab
+            with gr.Tab("📊 Portfolio Overview"):
+                gr.Markdown("## 💼 Account Summary")
+                with gr.Row():
+                    portfolio_value = gr.Textbox(label="💰 Portfolio Value", interactive=False, elem_classes=["metric-card"])
+                    buying_power = gr.Textbox(label="💳 Buying Power", interactive=False, elem_classes=["metric-card"])
+                    cash = gr.Textbox(label="💵 Cash", interactive=False, elem_classes=["metric-card"])
+                    day_change = gr.Textbox(label="📈 Day Change", interactive=False, elem_classes=["metric-card"])
+                    equity = gr.Textbox(label="🏦 Total Equity", interactive=False, elem_classes=["metric-card"])
+                
+                gr.Markdown("## 📈 Portfolio Performance")
+                portfolio_chart = gr.Plot(label="Portfolio Value Over Time")
+                
+                refresh_overview_btn = gr.Button("🔄 Refresh Portfolio Data", variant="primary", size="lg")
+            
+            # IPO Discoveries Tab  
+            with gr.Tab("🔍 IPO Discoveries"):
+                gr.Markdown("## 📊 IPO Discovery Analytics")
+                
+                with gr.Row():
+                    total_ipos = gr.Textbox(label="🎯 Total IPOs Detected", interactive=False, elem_classes=["metric-card"])
+                    ipos_invested = gr.Textbox(label="💰 IPOs Invested", interactive=False, elem_classes=["metric-card"])
+                    cs_stocks = gr.Textbox(label="📈 CS Stocks Found", interactive=False, elem_classes=["metric-card"])
+                    investment_rate = gr.Textbox(label="🎲 Investment Rate", interactive=False, elem_classes=["metric-card"])
+                    last_updated = gr.Textbox(label="🕒 Last Updated", interactive=False, elem_classes=["metric-card"])
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ipo_chart = gr.Plot(label="Investment Decision Breakdown")
+                    
+                    with gr.Column(scale=2):
+                        gr.Markdown("## 🆕 Recent IPO Discoveries")
+                        ipo_table = gr.Dataframe(
+                            label="IPO Discoveries with Investment Decisions",
+                            elem_classes=["gr-dataframe"]
+                        )
+                
+                refresh_ipo_btn = gr.Button("🔄 Refresh IPO Data", variant="primary", size="lg")
+            
+            # Current Positions Tab
+            with gr.Tab("🏦 Current Positions"):
+                gr.Markdown("## 📊 Open Positions")
+                positions_table = gr.Dataframe(label="Current Holdings", elem_classes=["gr-dataframe"])
+                refresh_positions_btn = gr.Button("🔄 Refresh Positions", variant="primary", size="lg")
+            
+            # System Logs Tab
+            with gr.Tab("📋 System Logs"):
+                gr.Markdown("## 🖥️ Trading Bot Activity")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 🎯 Parsed Logs (Color Coded)")
+                        system_logs = gr.Textbox(
+                            label="Recent System Activity",
+                            lines=20,
+                            max_lines=20,
+                            interactive=False,
+                            elem_classes=["gr-textbox"]
+                        )
+                    
+                    with gr.Column():
+                        gr.Markdown("### 📄 Raw Cron Logs")
+                        raw_logs = gr.Textbox(
+                            label="Raw Log Output",
+                            lines=20,
+                            max_lines=20,
+                            interactive=False,
+                            elem_classes=["gr-textbox"]
+                        )
+                
+                refresh_logs_btn = gr.Button("🔄 Refresh All Logs", variant="primary", size="lg")
+        
+        # Footer
+        gr.HTML("""
+            <div style="text-align: center; padding: 2rem; color: #666; border-top: 1px solid #eaeaea; margin-top: 3rem; background: white; border-radius: 16px;">
+                <p style="font-size: 1.1rem;"><strong>🤖 Automated Trading Dashboard</strong></p>
+                <p style="font-size: 0.95rem;">Real-time data from Alpaca Markets + VM Analytics | Built with ❤️</p>
+            </div>
+        """)
+        
+        # Event Handlers
+        
+        # Portfolio tab
+        refresh_overview_btn.click(
+            fn=refresh_account_overview,
+            outputs=[portfolio_value, buying_power, cash, day_change, equity]
+        )
+        refresh_overview_btn.click(
+            fn=create_portfolio_chart,
+            outputs=[portfolio_chart]
+        )
+        
+        # IPO tab
+        refresh_ipo_btn.click(
+            fn=refresh_vm_stats,
+            outputs=[total_ipos, ipos_invested, cs_stocks, investment_rate, last_updated]
+        )
+        refresh_ipo_btn.click(
+            fn=create_ipo_discovery_chart,
+            outputs=[ipo_chart]
+        )
+        refresh_ipo_btn.click(
+            fn=refresh_ipo_discoveries_table,
+            outputs=[ipo_table]
+        )
+        
+        # Positions tab
+        refresh_positions_btn.click(
+            fn=refresh_positions_table,
+            outputs=[positions_table]
+        )
+        
+        # Logs tab
+        refresh_logs_btn.click(
+            fn=refresh_system_logs,
+            outputs=[system_logs]
+        )
+        refresh_logs_btn.click(
+            fn=refresh_raw_logs,
+            outputs=[raw_logs]
+        )
+        
+        # Initial data load
+        demo.load(
+            fn=refresh_account_overview,
+            outputs=[portfolio_value, buying_power, cash, day_change, equity]
+        )
+        demo.load(fn=create_portfolio_chart, outputs=[portfolio_chart])
+        demo.load(fn=refresh_positions_table, outputs=[positions_table])
+        demo.load(
+            fn=refresh_vm_stats,
+            outputs=[total_ipos, ipos_invested, cs_stocks, investment_rate, last_updated]
+        )
+        demo.load(fn=create_ipo_discovery_chart, outputs=[ipo_chart])
+        demo.load(fn=refresh_ipo_discoveries_table, outputs=[ipo_table])
+    
+    return demo
+
+# Create and launch
+demo = create_dashboard()
+
+if __name__ == "__main__":
+    demo.launch()

hf_space/requirements.txt

@@ -0,0 +1,9 @@
+# Trading Dashboard Requirements - Full Featured
+gradio>=5.0.0
+plotly>=6.0.0
+pandas>=2.0.0
+numpy>=1.20.0
+alpaca-py>=0.8.0
+requests>=2.28.0
+flask>=2.0.0
+flask-cors>=4.0.0

hf_space/vm_data_server.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+VM Data Server
+Exposes local trading bot data via API for dashboard consumption
+Runs on the VM alongside your trading bot
+"""
+
+import os
+import json
+import pandas as pd
+from datetime import datetime, timedelta
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+import logging
+
+app = Flask(__name__)
+CORS(app)  # Allow dashboard to connect from anywhere
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# File paths
+PORTFOLIO_FILE = 'portfolio.txt'
+NEW_TICKERS_LOG_FILE = 'new_tickers_log.csv'
+SCRIPT_LOG_FILE = 'script.log'
+BUY_QUEUE_FILE = 'buy_queue.json'
+CURRENT_TICKERS_FILE = 'current_tickers.txt'
+
+def load_portfolio_data():
+    """Load portfolio CSV data"""
+    try:
+        if os.path.exists(PORTFOLIO_FILE):
+            df = pd.read_csv(PORTFOLIO_FILE)
+            return df.to_dict('records')
+        return []
+    except Exception as e:
+        logger.error(f"Error loading portfolio: {e}")
+        return []
+
+def load_new_tickers_with_decisions():
+    """Load IPO discoveries with investment decisions"""
+    try:
+        if not os.path.exists(NEW_TICKERS_LOG_FILE):
+            return []
+        
+        df = pd.read_csv(NEW_TICKERS_LOG_FILE)
+        portfolio_data = load_portfolio_data()
+        
+        # Get symbols we actually invested in
+        invested_symbols = set()
+        for trade in portfolio_data:
+            invested_symbols.add(trade.get('symbol', ''))
+        
+        # Add investment decision to each IPO
+        enriched_ipos = []
+        for _, row in df.iterrows():
+            symbol = row.get('Symbol', '')
+            security_type = row.get('Security_Type', '')
+            
+            # Determine investment status
+            if symbol in invested_symbols:
+                investment_status = 'INVESTED'
+                status_color = 'success'
+                status_emoji = '🟢'
+            elif security_type == 'CS':
+                investment_status = 'ELIGIBLE_NOT_INVESTED'
+                status_color = 'warning'
+                status_emoji = '🟡'
+            elif security_type in ['SP', 'WARRANT', 'UNIT']:
+                investment_status = 'WRONG_TYPE'
+                status_color = 'neutral'
+                status_emoji = '⚪'
+            else:
+                investment_status = 'UNKNOWN'
+                status_color = 'error'
+                status_emoji = '🔴'
+            
+            enriched_ipos.append({
+                'symbol': symbol,
+                'security_type': security_type,
+                'trading_price': row.get('Trading_Price', 'N/A'),
+                'detected_at': row.get('Detected_At', 'N/A'),
+                'investment_status': investment_status,
+                'status_color': status_color,
+                'status_emoji': status_emoji
+            })
+        
+        # Sort by detection date (newest first)
+        enriched_ipos.sort(key=lambda x: x['detected_at'], reverse=True)
+        
+        return enriched_ipos
+    except Exception as e:
+        logger.error(f"Error loading IPO data: {e}")
+        return []
+
+def load_script_logs(lines=100):
+    """Load recent script logs"""
+    try:
+        if not os.path.exists(SCRIPT_LOG_FILE):
+            return []
+        
+        with open(SCRIPT_LOG_FILE, 'r') as f:
+            all_lines = f.readlines()
+        
+        # Get recent lines
+        recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+        
+        # Parse log lines
+        logs = []
+        for line in recent_lines:
+            line = line.strip()
+            if line:
+                # Try to parse timestamp and level
+                parts = line.split(' - ', 2)
+                if len(parts) >= 3:
+                    timestamp = parts[0]
+                    level = parts[1]
+                    message = parts[2]
+                    
+                    # Determine log type for color coding
+                    if 'ERROR' in level:
+                        log_type = 'error'
+                        emoji = '🔴'
+                    elif 'WARNING' in level or 'WARN' in level:
+                        log_type = 'warning'
+                        emoji = '🟡'
+                    elif 'Buy order placed' in message or 'Sold' in message:
+                        log_type = 'trade'
+                        emoji = '💰'
+                    elif 'Found' in message and 'new ticker' in message:
+                        log_type = 'discovery'
+                        emoji = '🔍'
+                    elif 'INFO' in level:
+                        log_type = 'info'
+                        emoji = '🔵'
+                    else:
+                        log_type = 'default'
+                        emoji = '⚪'
+                    
+                    logs.append({
+                        'timestamp': timestamp,
+                        'level': level,
+                        'message': message,
+                        'log_type': log_type,
+                        'emoji': emoji,
+                        'full_line': line
+                    })
+                else:
+                    # Fallback for unparseable lines
+                    logs.append({
+                        'timestamp': 'N/A',
+                        'level': 'RAW',
+                        'message': line,
+                        'log_type': 'default',
+                        'emoji': '⚪',
+                        'full_line': line
+                    })
+        
+        return logs
+    except Exception as e:
+        logger.error(f"Error loading logs: {e}")
+        return []
+
+def load_buy_queue():
+    """Load current buy queue"""
+    try:
+        if os.path.exists(BUY_QUEUE_FILE):
+            with open(BUY_QUEUE_FILE, 'r') as f:
+                return json.load(f)
+        return []
+    except Exception as e:
+        logger.error(f"Error loading buy queue: {e}")
+        return []
+
+def get_system_stats():
+    """Get system statistics"""
+    try:
+        portfolio_data = load_portfolio_data()
+        ipo_data = load_new_tickers_with_decisions()
+        
+        # Calculate stats
+        total_ipos_detected = len(ipo_data)
+        ipos_invested = len([ipo for ipo in ipo_data if ipo['investment_status'] == 'INVESTED'])
+        current_positions = len(portfolio_data)
+        
+        # Get detection stats by type
+        cs_stocks = len([ipo for ipo in ipo_data if ipo['security_type'] == 'CS'])
+        other_types = total_ipos_detected - cs_stocks
+        
+        return {
+            'total_ipos_detected': total_ipos_detected,
+            'ipos_invested': ipos_invested,
+            'current_positions': current_positions,
+            'cs_stocks_detected': cs_stocks,
+            'other_types_detected': other_types,
+            'investment_rate': round((ipos_invested / cs_stocks * 100) if cs_stocks > 0 else 0, 1),
+            'last_updated': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        }
+    except Exception as e:
+        logger.error(f"Error calculating stats: {e}")
+        return {}
+
+# API Endpoints
+
+@app.route('/health')
+def health_check():
+    """Health check endpoint"""
+    return jsonify({'status': 'healthy', 'timestamp': datetime.now().isoformat()})
+
+@app.route('/api/portfolio')
+def get_portfolio():
+    """Get portfolio data"""
+    return jsonify(load_portfolio_data())
+
+@app.route('/api/ipos')
+def get_ipos():
+    """Get IPO discoveries with investment decisions"""
+    limit = request.args.get('limit', 50, type=int)
+    ipos = load_new_tickers_with_decisions()
+    return jsonify(ipos[:limit])
+
+@app.route('/api/logs')
+def get_logs():
+    """Get script logs"""
+    lines = request.args.get('lines', 100, type=int)
+    logs = load_script_logs(lines)
+    return jsonify(logs)
+
+@app.route('/api/buy_queue')
+def get_buy_queue():
+    """Get current buy queue"""
+    return jsonify(load_buy_queue())
+
+@app.route('/api/stats')
+def get_stats():
+    """Get system statistics"""
+    return jsonify(get_system_stats())
+
+@app.route('/api/logs/raw')
+def get_raw_logs():
+    """Get raw log file content"""
+    lines = request.args.get('lines', 200, type=int)
+    try:
+        if not os.path.exists(SCRIPT_LOG_FILE):
+            return jsonify({'content': 'No log file found'})
+        
+        with open(SCRIPT_LOG_FILE, 'r') as f:
+            all_lines = f.readlines()
+        
+        recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+        content = ''.join(recent_lines)
+        
+        return jsonify({
+            'content': content,
+            'total_lines': len(all_lines),
+            'showing_lines': len(recent_lines)
+        })
+    except Exception as e:
+        return jsonify({'error': str(e), 'content': ''})
+
+if __name__ == '__main__':
+    print("🚀 Starting VM Data Server...")
+    print("📡 This exposes your trading bot data via API")
+    print("🌐 Dashboard can now access:")
+    print("   • IPO discoveries with investment decisions")
+    print("   • Raw cron logs with color coding") 
+    print("   • Portfolio data from VM files")
+    print("   • Buy queue and system stats")
+    print("-" * 50)
+    
+    # Run on all interfaces so dashboard can connect
+    app.run(
+        host='0.0.0.0',  # Allow external connections
+        port=8090,       # Different from dashboard port
+        debug=False
+    )