Create app.py

app.py

@@ -0,0 +1,638 @@
+import gradio as gr
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pixeltable as pxt
+from pixeltable.functions import openai
+import json
+import os
+import getpass
+from typing import Dict, Any
+
+# Set up OpenAI API key
+if 'OPENAI_API_KEY' not in os.environ:
+    os.environ['OPENAI_API_KEY'] = getpass.getpass('Enter your OpenAI API key: ')
+
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,
+            np.int16, np.int32, np.int64, np.uint8,
+            np.uint16, np.uint32, np.uint64)):
+            return int(obj)
+        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+            return float(obj)
+        elif isinstance(obj, (np.ndarray,)):
+            return obj.tolist()
+        return json.JSONEncoder.default(self, obj)
+
+def safe_json_serialize(obj):
+    return json.dumps(obj, cls=NumpyEncoder)
+
+def calculate_basic_indicators(data: pd.DataFrame) -> pd.DataFrame:
+    df = data.copy()
+    
+    # Moving averages
+    df['MA20'] = df['Close'].rolling(window=20).mean()
+    df['MA50'] = df['Close'].rolling(window=50).mean()
+    df['MA200'] = df['Close'].rolling(window=200).mean()
+    
+    # RSI
+    delta = df['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+    rs = gain / loss
+    df['RSI'] = 100 - (100 / (1 + rs))
+    
+    # MACD
+    exp1 = df['Close'].ewm(span=12, adjust=False).mean()
+    exp2 = df['Close'].ewm(span=26, adjust=False).mean()
+    df['MACD'] = exp1 - exp2
+    df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
+    
+    return df.ffill().bfill()
+
+# Also update the system prompt in generate_analysis_prompt to ensure structured output:
+@pxt.udf
+def generate_analysis_prompt(data: str, analysis_type: str) -> list[dict]:
+    """Generate a structured prompt for AI analysis"""
+    system_prompt = '''You are a financial analyst providing market analysis. Structure your response using EXACTLY the following format and sections:
+
+SUMMARY
+Provide a clear 2-3 sentence executive summary of your analysis.
+
+TECHNICAL ANALYSIS
+• Moving Averages: Analyze trends using MA20, MA50, and MA200
+• RSI Analysis: Current RSI level and implications
+• MACD Analysis: MACD trends and signals
+• Volume Analysis: Notable volume patterns and implications
+
+MARKET CONTEXT
+• List 2-3 key market factors affecting the stock
+• Include relevant sector/industry context
+• Note any significant recent developments
+
+RISKS
+• Risk 1: [Specific risk and brief explanation]
+• Risk 2: [Specific risk and brief explanation]
+• Risk 3: [Specific risk and brief explanation]
+
+OPPORTUNITIES
+• Opportunity 1: [Specific opportunity and brief explanation]
+• Opportunity 2: [Specific opportunity and brief explanation]
+• Opportunity 3: [Specific opportunity and brief explanation]
+
+RECOMMENDATION
+Provide a clear, actionable investment recommendation based on the analysis above.'''
+
+    return [
+        {'role': 'system', 'content': system_prompt},
+        {'role': 'user', 'content': f'Analyze this market data for {analysis_type} analysis:\n{data}'}
+    ]
+
+def parse_analysis_response(response: str) -> Dict[str, str]:
+    """Parse the structured AI response into sections with support for markdown formatting"""
+    sections = {
+        'SUMMARY': None,
+        'TECHNICAL ANALYSIS': None,
+        'MARKET CONTEXT': None,
+        'RISKS': None,
+        'OPPORTUNITIES': None,
+        'RECOMMENDATION': None
+    }
+    
+    current_section = None
+    buffer = []
+    
+    if not response or not response.strip():
+        return {k: "Analysis not available" for k in sections.keys()}
+    
+    for line in response.split('\n'):
+        line = line.strip()
+        
+        # Check if this line is a section header (now handling markdown formatting)
+        matched_section = None
+        for section in sections.keys():
+            # Remove asterisks and check for exact match
+            cleaned_line = line.replace('*', '').strip()
+            if cleaned_line == section:
+                matched_section = section
+                break
+        
+        if matched_section:
+            # Save previous section if exists
+            if current_section and buffer:
+                sections[current_section] = '\n'.join(buffer).strip()
+            current_section = matched_section
+            buffer = []
+        elif current_section and line:
+            # Clean up markdown formatting in content
+            cleaned_content = line.replace('*', '').strip()
+            if cleaned_content:  # Only add non-empty lines
+                buffer.append(cleaned_content)
+    
+    # Save the last section
+    if current_section and buffer:
+        sections[current_section] = '\n'.join(buffer).strip()
+    
+    # Clean up sections and provide meaningful defaults
+    section_messages = {
+        'SUMMARY': 'Market analysis summary not available',
+        'TECHNICAL ANALYSIS': 'Technical analysis not available',
+        'MARKET CONTEXT': 'Market context information not available',
+        'RISKS': 'Risk assessment not available',
+        'OPPORTUNITIES': 'Opportunity analysis not available',
+        'RECOMMENDATION': 'Investment recommendation not available'
+    }
+    
+    # Only use default messages if section is truly empty
+    for key in sections:
+        if sections[key] is None or not sections[key].strip():
+            sections[key] = section_messages[key]
+    
+    return sections
+
+def create_visualization(data: pd.DataFrame, technical_depth: str) -> go.Figure:
+    fig = make_subplots(
+        rows=3 if technical_depth == 'advanced' else 2,
+        cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.05,
+        subplot_titles=('Price & Moving Averages', 'Volume', 'RSI' if technical_depth == 'advanced' else None)
+    )
+
+    # Price candlesticks with improved styling
+    fig.add_trace(
+        go.Candlestick(
+            x=data.index,
+            open=data['Open'],
+            high=data['High'],
+            low=data['Low'],
+            close=data['Close'],
+            name='Price',
+            increasing_line_color='#26A69A',
+            decreasing_line_color='#EF5350'
+        ),
+        row=1, col=1
+    )
+
+    # Moving averages with distinct colors
+    colors = {'MA20': '#1E88E5', 'MA50': '#FFC107', 'MA200': '#7B1FA2'}
+    for ma, color in colors.items():
+        fig.add_trace(
+            go.Scatter(
+                x=data.index,
+                y=data[ma],
+                name=ma,
+                line=dict(color=color, width=1.5)
+            ),
+            row=1, col=1
+        )
+
+    # Volume with color based on price change
+    colors = ['#26A69A' if close >= open_price else '#EF5350' 
+         for close, open_price in zip(data['Close'].values, data['Open'].values)]
+    fig.add_trace(
+        go.Bar(
+            x=data.index,
+            y=data['Volume'],
+            name='Volume',
+            marker_color=colors
+        ),
+        row=2, col=1
+    )
+
+    if technical_depth == 'advanced':
+        fig.add_trace(
+            go.Scatter(
+                x=data.index,
+                y=data['RSI'],
+                name='RSI',
+                line=dict(color='#7C4DFF', width=1.5)
+            ),
+            row=3, col=1
+        )
+        
+        # Add RSI reference lines
+        fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
+        fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1)
+
+    fig.update_layout(
+        height=800,
+        template='plotly_white',
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
+    )
+    
+    # Update y-axes labels
+    fig.update_yaxes(title_text="Price", row=1, col=1)
+    fig.update_yaxes(title_text="Volume", row=2, col=1)
+    if technical_depth == 'advanced':
+        fig.update_yaxes(title_text="RSI", row=3, col=1)
+
+    return fig
+
+def process_outputs(ticker_symbol, analysis_type, time_horizon, risk_tolerance,
+                   investment_style, technical_depth, include_market_context=True,
+                   max_positions=3):
+    try:
+        # Initialize Pixeltable
+        pxt.drop_dir('financial_analysis', force=True)
+        pxt.create_dir('financial_analysis')
+
+        data_table = pxt.create_table(
+            'financial_analysis.stock_data',
+            {
+                'ticker': pxt.StringType(),
+                'data': pxt.StringType(),
+                'timestamp': pxt.TimestampType()
+            }
+        )
+
+        # Fetch and process data
+        stock = yf.Ticker(ticker_symbol.strip().upper())
+        market_data = stock.history(period='1y')
+        if market_data.empty:
+            raise ValueError("No data found for the specified ticker symbol.")
+
+        technical_data = calculate_basic_indicators(market_data)
+        market_data_json = technical_data.to_json(date_format='iso')
+
+        # Store data and generate analysis
+        data_table.insert([{
+            'ticker': ticker_symbol.upper(),
+            'data': market_data_json,
+            'timestamp': datetime.now()
+        }])
+
+        data_table['prompt'] = generate_analysis_prompt(data_table.data, analysis_type)
+        data_table['analysis'] = openai.chat_completions(
+            messages=data_table.prompt,
+            model='gpt-4o-mini-2024-07-18',
+            temperature=0.7,
+            max_tokens=1000
+        )
+
+        # Process the analysis with better error handling
+        try:
+            analysis_text = data_table.select(
+                analysis=data_table.analysis.choices[0].message.content
+            ).tail(1)['analysis'][0]
+            parsed_analysis = parse_analysis_response(analysis_text)
+        except Exception as analysis_error:
+            print(f"Analysis error: {str(analysis_error)}")
+            parsed_analysis = parse_analysis_response("")  # This will return default messages
+
+        # Prepare company info with proper JSON formatting
+        company_info_data = {
+            'Name': str(stock.info.get('longName', 'N/A')),
+            'Sector': str(stock.info.get('sector', 'N/A')),
+            'Industry': str(stock.info.get('industry', 'N/A')),
+            'Exchange': str(stock.info.get('exchange', 'N/A'))
+        }
+
+        raw_llm_output = ""
+        try:
+            raw_llm_output = data_table.select(
+                analysis=data_table.analysis.choices[0].message.content
+            ).tail(1)['analysis'][0]
+            parsed_analysis = parse_analysis_response(raw_llm_output)
+        except Exception as analysis_error:
+            print(f"Analysis error: {str(analysis_error)}")
+            parsed_analysis = parse_analysis_response("")
+            raw_llm_output = f"Error processing analysis: {str(analysis_error)}"
+
+        # Prepare market stats with proper number formatting
+        try:
+            current_price = float(technical_data['Close'].iloc[-1])
+            previous_price = float(technical_data['Close'].iloc[-2])
+            daily_change = float((current_price / previous_price - 1) * 100)
+            volume = int(technical_data['Volume'].iloc[-1])
+            rsi = float(technical_data['RSI'].iloc[-1])
+        except (IndexError, KeyError, TypeError):
+            current_price = daily_change = volume = rsi = 0
+
+        market_stats_data = {
+            'Current Price': f"${current_price:.2f}",
+            'Daily Change': f"{daily_change:.2f}%",
+            'Volume': f"{volume:,}",
+            'RSI': f"{rsi:.2f}"
+        }
+
+        # Add timestamp to technical data
+        technical_data_with_time = technical_data.reset_index()
+        technical_data_with_time['Date'] = technical_data_with_time['Date'].dt.strftime('%Y-%m-%d %H:%M:%S')
+
+        # Create visualization
+        plot = create_visualization(technical_data, technical_depth)
+
+        return (
+            json.dumps(company_info_data),
+            json.dumps(market_stats_data),
+            plot,
+            parsed_analysis['SUMMARY'],
+            parsed_analysis['TECHNICAL ANALYSIS'],
+            parsed_analysis['MARKET CONTEXT'],
+            parsed_analysis['RISKS'],
+            parsed_analysis['OPPORTUNITIES'],
+            parsed_analysis['RECOMMENDATION'],
+            technical_data_with_time,
+            raw_llm_output  # Add raw output to return values
+        )
+
+    except Exception as e:
+        error_msg = f"Error processing data: {str(e)}"
+        empty_json = json.dumps({})
+        no_data_msg = "Analysis not available due to data processing error"
+        empty_df = pd.DataFrame()
+        
+        return (
+            empty_json,
+            empty_json,
+            None,
+            no_data_msg,
+            no_data_msg,
+            no_data_msg,
+            no_data_msg,
+            no_data_msg,
+            no_data_msg,
+            empty_df,
+            f"Error occurred: {str(e)}"  # Add error message to raw output
+        )
+
+def create_interface() -> gr.Blocks:
+    """Create the production-ready Gradio interface"""
+    with gr.Blocks(theme=gr.themes.Base()) as demo:
+        # Header      
+        gr.Markdown(
+            """
+            # 📈 AI Financial Analysis Platform
+            AI-powered market analysis and technical indicators. The creators and operators of this tool are not responsible for any financial losses or decisions made based on this analysis.
+            """
+        )
+
+        # Information Accordions
+        with gr.Row():
+            with gr.Column():
+                with gr.Accordion("🎯 What does it do?", open=False):
+                    gr.Markdown("""
+                    This platform provides comprehensive financial analysis tools:
+                    
+                    1. 📊 **Technical Analysis**: Advanced indicators, e.g. RSI, and MACD
+                    2. 🤖 **AI-Powered Insights**: Intelligent market analysis/recommendations
+                    3. 📈 **Interactive Charts**: Visual representation of movements/indicators
+                    4. 💡 **Investment Context**: Market conditions and sector analysis
+                    5. ⚡ **Real-time Data**: Up-to-date information through Yahoo Finance
+                    6. 🎯 **Personalized Analysis**: Tailored to your style/risk tolerance
+                    """)
+            
+            with gr.Column():
+                with gr.Accordion("🛠️ How does it work?", open=False):
+                    gr.Markdown("""
+                    The platform leverages several advanced technologies:
+                    
+                    1. 📦 **Data Processing**: Pixeltable manages and orchestrate data
+                    2. 🔍 **Technical Indicators**: Custom algorithms calculate market metrics
+                    3. 🤖 **AI Analysis**: Advanced language models provide market insights
+                    4. 📊 **Visualization**: Interactive charts using Plotly
+                    5. 🔄 **Real-time Updates**: Direct connection to market data feeds
+                    6. 💾 **Data Persistence**: Reliable storage and retrieval of insights
+                    """)
+
+        # Disclaimer
+        gr.HTML(
+            """
+            <div style="background-color: #FFF4E5; border: 1px solid #FFE0B2; color: #663C00; border-radius: 8px; padding: 15px; margin: 15px 0;">
+                <strong>⚠️ Disclaimer:</strong>
+                <p style="margin: 8px 0;">
+                    This tool provides financial analysis for informational purposes only and should not be considered as financial advice. 
+                    Before making any investment decisions, please:
+                </p>
+                <ul style="margin: 8px 0;">
+                    <li>Consult with qualified financial advisors</li>
+                    <li>Conduct your own research</li>
+                    <li>Consider your personal financial situation</li>
+                    <li>Be aware that past performance does not guarantee future results</li>
+                    <li>Understand that all investments carry risk</li>
+                </ul>
+            </div>
+            """
+        )
+
+        with gr.Row():
+            # Left sidebar for inputs (reduced width)
+            with gr.Column(scale=1):
+                with gr.Row():
+                    gr.Markdown("### 📊 Analysis Parameters")
+                with gr.Row():
+                    ticker_input = gr.Textbox(
+                        label="Stock Ticker",
+                        placeholder="e.g., AAPL",
+                        max_lines=1
+                    )
+                    analysis_type = gr.Radio(
+                        choices=['comprehensive', 'quantitative', 'technical'],
+                        label="Analysis Type",
+                        value='comprehensive'
+                    )
+                    technical_depth = gr.Radio(
+                        choices=['basic', 'advanced'],
+                        label="Technical Depth",
+                        value='advanced'
+                    )
+                
+                with gr.Row():
+                    gr.Markdown("### 🎯 Investment Profile")
+                with gr.Row():
+                    time_horizon = gr.Radio(
+                        choices=['short', 'medium', 'long'],
+                        label="Time Horizon",
+                        value='medium'
+                    )
+                    risk_tolerance = gr.Radio(
+                        choices=['conservative', 'moderate', 'aggressive'],
+                        label="Risk Tolerance",
+                        value='moderate'
+                    )
+                    investment_style = gr.Dropdown(
+                        choices=['value', 'growth', 'momentum', 'balanced', 'income'],
+                        label="Investment Style",
+                        value='balanced'
+                    )
+
+                analyze_btn = gr.Button("📊 Analyze Stock", variant="primary")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                with gr.Tabs() as tabs:
+                    with gr.TabItem("📊 Analysis Dashboard"):
+                        # Top row with company info and market stats
+                        with gr.Row(equal_height=True):
+                            with gr.Column(scale=1):
+                                company_info = gr.JSON(
+                                    label="Company Information",
+                                    height=150
+                                )
+                            with gr.Column(scale=1):
+                                market_stats = gr.JSON(
+                                    label="Market Statistics",
+                                    height=150
+                                )
+                        
+                    with gr.TabItem("📑 Historical Data"):
+                        technical_data = gr.DataFrame(
+                            headers=["Date", "Open", "High", "Low", "Close", 
+                                   "Volume", "MA20", "MA50", "MA200", "RSI", 
+                                   "MACD", "MACD_Signal"],
+                        )
+                    
+                    with gr.TabItem("🔍 Debug View"):
+                        raw_output = gr.Textbox(
+                            label="Raw LLM Output",
+                            lines=10,
+                            max_lines=20,
+                            show_label=True,
+                            interactive=False
+                        )
+                        gr.Markdown("""
+                        ### Debug Information
+                        This tab shows the raw output from the language model before parsing.
+                        Use this to diagnose any issues with the analysis display.
+                        """)
+         # Technical analysis chart
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Row():
+                    gr.Markdown("### 📈 Technical Analysis Chart")
+                
+                with gr.Row():
+                    plot_output = gr.Plot()
+
+        # AI Analysis section with better layout
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Row():
+                    gr.Markdown("### 🤖 AI Analysis")
+                    
+                # Summary at the top
+                with gr.Row():
+                    summary = gr.Textbox(
+                        label="Executive Summary",
+                        lines=3,
+                        max_lines=5,
+                        show_label=True
+                    )
+                    
+                # Main analysis sections
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        tech_analysis = gr.Textbox(
+                            label="Technical Analysis",
+                            lines=8,
+                            max_lines=10,
+                            show_label=True
+                        )
+                        market_context = gr.Textbox(
+                            label="Market Context",
+                            lines=4,
+                            max_lines=6,
+                            show_label=True
+                        )
+                    
+                    with gr.Column(scale=1):
+                        risks = gr.Textbox(
+                            label="Key Risks",
+                            lines=5,
+                            max_lines=7,
+                            show_label=True
+                        )
+                        opportunities = gr.Textbox(
+                            label="Key Opportunities",
+                            lines=5,
+                            max_lines=7,
+                            show_label=True
+                        )
+                
+                # Recommendation at the bottom
+                with gr.Row():
+                    recommendation = gr.Textbox(
+                        label="Investment Recommendation",
+                        lines=3,
+                        max_lines=5,
+                        show_label=True
+                    )
+        
+        # Examples section at the bottom
+        gr.Examples(
+            examples=[
+                ["AAPL", "comprehensive", "medium", "moderate", "balanced", "advanced"],
+                ["MSFT", "technical", "short", "aggressive", "momentum", "basic"],
+                ["GOOGL", "quantitative", "long", "conservative", "value", "advanced"]
+            ],
+            inputs=[
+                ticker_input, analysis_type, time_horizon, risk_tolerance,
+                investment_style, technical_depth
+            ]
+        )
+
+        # Footer
+        gr.HTML(
+            """
+            <div style="margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #e5e7eb;">
+                <div style="display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 1rem;">
+                    <div style="flex: 1;">
+                        <h4 style="margin: 0; color: #374151;">🚀 Built with Pixeltable</h4>
+                        <p style="margin: 0.5rem 0; color: #6b7280;">
+                            Open Source AI Data infrastructure for building intelligent applications.
+                        </p>
+                    </div>
+                    <div style="flex: 1;">
+                        <h4 style="margin: 0; color: #374151;">🔗 Resources</h4>
+                        <div style="display: flex; gap: 1.5rem; margin-top: 0.5rem;">
+                            <a href="https://github.com/pixeltable/pixeltable" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                💻 GitHub
+                            </a>
+                            <a href="https://docs.pixeltable.com" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                📚 Documentation
+                            </a>
+                            <a href="https://huggingface.co/Pixeltable" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                🤗 Hugging Face
+                            </a>
+                        </div>
+                    </div>
+                </div>
+                <p style="margin: 1rem 0 0; text-align: center; color: #9CA3AF; font-size: 0.875rem;">
+                    © 2024 AI Financial Analysis Platform powered by Pixeltable. 
+                    This work is licensed under the Apache License 2.0.
+                </p>
+            </div>
+            """
+        )
+
+        analyze_btn.click(
+            process_outputs,
+            inputs=[
+                ticker_input, analysis_type, time_horizon, risk_tolerance,
+                investment_style, technical_depth
+            ],
+            outputs=[
+                company_info, market_stats, plot_output,
+                summary, tech_analysis, market_context,
+                risks, opportunities, recommendation,
+                technical_data, raw_output  # Add raw_output to outputs
+            ]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()