Add Premium Trading Dashboard with enhanced Reddit search and sentiment analysis

README.md

@@ -1,14 +1,75 @@
 ---
-title: Portfolio
-emoji: 🐨
-colorFrom: red
-colorTo: pink
+title: Premium Trading Dashboard
+emoji: 📈
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.38.2
+sdk_version: 5.35.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: v2
+short_description: IPO Trading Dashboard with Sentiment Analysis
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚀 Premium Trading Dashboard
+
+A comprehensive real-time trading dashboard with automated IPO discovery, sentiment analysis, and backtesting capabilities.
+
+## ✨ Features
+
+### 📊 Portfolio Overview
+- Real-time account monitoring (portfolio value, buying power, cash)
+- Interactive portfolio performance charts
+- Day change tracking with visual indicators
+
+### 🔍 IPO Discoveries
+- Automated IPO detection and classification
+- Investment decision analytics
+- Recent discoveries with detailed breakdowns
+
+### 💰 Investment Performance
+- Complete P&L analysis for all IPO investments
+- **NEW: Integrated sentiment analysis backtesting**
+- Advanced trading statistics and metrics
+- Risk analysis and performance breakdowns
+
+### 🧠 Sentiment Analysis Engine
+
+The dashboard implements a sophisticated sentiment analysis system:
+
+- **Data Sources**: Reddit (including WallStreetBets), Google News
+- **Analysis Window**: 12 hours before each actual investment
+- **Sentiment Engines**: VADER + TextBlob with engagement weighting
+- **Target**: First-hour stock performance prediction
+- **Validation**: Compares predictions vs actual market performance
+
+### 💻 VM Terminal
+- Remote command execution on trading VM
+- Real-time log monitoring
+- File system navigation and analysis
+
+### 📋 System Logs
+- Parsed trading bot activity logs
+- Raw cron job outputs
+- Color-coded error tracking
+
+## 🔧 Technical Stack
+
+- **Frontend**: Gradio with custom CSS styling
+- **Backend**: Flask API integration with VM
+- **Trading API**: Alpaca Markets (Paper Trading)
+- **Data Sources**: Reddit API, Google News RSS, Yahoo Finance
+- **Sentiment Analysis**: VADER, TextBlob
+- **Charts**: Plotly for interactive visualizations
+
+## 🚀 Recent Updates
+
+- ✅ Added IPO Sentiment Analysis Backtesting
+- ✅ WallStreetBets integration for Reddit sentiment
+- ✅ Historical performance validation
+- ✅ Multi-source sentiment aggregation
+- ✅ Enhanced logging and error handling
+
+**Built with ❤️ for automated IPO trading and sentiment analysis**
+
+*Fresh deployment with enhanced Reddit search and comprehensive logging*

requirements.txt

@@ -0,0 +1,12 @@
+# 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
+textblob>=0.17.1
+vaderSentiment>=3.3.2
+yfinance>=0.2.18

vm_data_server.py

@@ -0,0 +1,332 @@
+#!/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': ''})
+
+@app.route('/api/execute', methods=['POST'])
+def execute_command():
+    """Execute a command on the VM"""
+    try:
+        data = request.get_json()
+        command = data.get('command', '').strip()
+        
+        if not command:
+            return jsonify({'error': 'No command provided', 'output': '', 'exit_code': 1})
+        
+        # Security: only allow safe commands
+        dangerous_commands = ['rm', 'sudo', 'passwd', 'shutdown', 'reboot', 'mkfs', 'fdisk', 'dd']
+        if any(cmd in command.lower() for cmd in dangerous_commands):
+            return jsonify({
+                'error': 'Command not allowed for security reasons',
+                'output': f"⛔ Command '{command}' contains restricted operations",
+                'exit_code': 1
+            })
+        
+        # Execute command with timeout
+        import subprocess
+        import os
+        
+        # Use current working directory (where the server was started)
+        cwd = os.getcwd()
+        
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=30,  # 30 second timeout
+            cwd=cwd  # Run in current directory
+        )
+        
+        return jsonify({
+            'output': result.stdout + result.stderr,
+            'exit_code': result.returncode,
+            'command': command
+        })
+        
+    except subprocess.TimeoutExpired:
+        return jsonify({
+            'error': 'Command timed out',
+            'output': '⏰ Command execution timed out (30s limit)',
+            'exit_code': 124
+        })
+    except Exception as e:
+        return jsonify({
+            'error': str(e),
+            'output': f'❌ Error executing command: {str(e)}',
+            'exit_code': 1
+        })
+
+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("   • Remote command execution")
+    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
+    )