Update app.py

app.py

@@ -0,0 +1,815 @@
+import gradio as gr
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from datetime import datetime, timedelta
+from langchain_huggingface import HuggingFaceEndpoint
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import chromadb
+import requests
+from bs4 import BeautifulSoup
+import warnings
+from typing import Dict, List, Tuple
+import feedparser
+from sentence_transformers import SentenceTransformer
+import faiss
+import json
+import os
+
+warnings.filterwarnings('ignore')
+
+
+
+COMPANIES = {
+    'Apple (AAPL)': 'AAPL',
+    'Microsoft (MSFT)': 'MSFT',
+    'Amazon (AMZN)': 'AMZN',
+    'Google (GOOGL)': 'GOOGL',
+    'Meta (META)': 'META',
+    'Tesla (TSLA)': 'TSLA',
+    'NVIDIA (NVDA)': 'NVDA',
+    'JPMorgan Chase (JPM)': 'JPM',
+    'Johnson & Johnson (JNJ)': 'JNJ',
+    'Walmart (WMT)': 'WMT',
+    'Visa (V)': 'V',
+    'Mastercard (MA)': 'MA',
+    'Procter & Gamble (PG)': 'PG',
+    'UnitedHealth (UNH)': 'UNH',
+    'Home Depot (HD)': 'HD',
+    'Bank of America (BAC)': 'BAC',
+    'Coca-Cola (KO)': 'KO',
+    'Pfizer (PFE)': 'PFE',
+    'Disney (DIS)': 'DIS',
+    'Netflix (NFLX)': 'NFLX'
+}
+
+# Initialize models
+print("Initializing models...")
+api_token = os.getenv(TOKEN)
+llm = HuggingFaceEndpoint(
+    repo_id="mistralai/Mistral-7B-Instruct-v0.2",  
+    huggingfacehub_api_token=api_token,
+    temperature=0.7,
+    max_new_tokens=1000
+)
+vader = SentimentIntensityAnalyzer()
+finbert = pipeline("sentiment-analysis", 
+                  model="ProsusAI/finbert")
+print("Models initialized successfully!")
+class AgenticRAGFramework:
+    """Main framework coordinating all agents"""
+    def __init__(self):
+        self.technical_agent = TechnicalAnalysisAgent()
+        self.sentiment_agent = SentimentAnalysisAgent()
+        self.llama_agent = LLMAgent()
+        self.knowledge_base = chromadb.Client()
+        
+    def analyze(self, symbol: str, data: pd.DataFrame) -> Dict:
+        """Perform comprehensive analysis"""
+        technical_analysis = self.technical_agent.analyze(data)
+        sentiment_analysis = self.sentiment_agent.analyze(symbol)
+        llm_analysis = self.llama_agent.generate_analysis(
+            technical_analysis,
+            sentiment_analysis
+        )
+        
+        return {
+            'technical_analysis': technical_analysis,
+            'sentiment_analysis': sentiment_analysis,
+            'llm_analysis': llm_analysis
+        }
+
+
+class NewsSource:
+    """Base class for news sources"""
+    def get_news(self, company: str) -> List[Dict]:
+        raise NotImplementedError
+
+class FinvizNews(NewsSource):
+    """Fetch news from FinViz"""
+    def get_news(self, company: str) -> List[Dict]:
+        try:
+            ticker = company.split('(')[-1].replace(')', '')
+            url = f"https://finviz.com/quote.ashx?t={ticker}"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            
+            response = requests.get(url, headers=headers)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            news_table = soup.find('table', {'class': 'news-table'})
+            
+            if not news_table:
+                return []
+            
+            news_list = []
+            for row in news_table.find_all('tr')[:5]:
+                cols = row.find_all('td')
+                if len(cols) >= 2:
+                    date = cols[0].text.strip()
+                    title = cols[1].a.text.strip()
+                    link = cols[1].a['href']
+                    
+                    news_list.append({
+                        'title': title,
+                        'description': title,
+                        'date': date,
+                        'source': 'FinViz',
+                        'url': link
+                    })
+            
+            return news_list
+        except Exception as e:
+            print(f"FinViz Error: {str(e)}")
+            return []
+
+class MarketWatchNews(NewsSource):
+    """Fetch news from MarketWatch"""
+    def get_news(self, company: str) -> List[Dict]:
+        try:
+            ticker = company.split('(')[-1].replace(')', '')
+            url = f"https://www.marketwatch.com/investing/stock/{ticker}"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            
+            response = requests.get(url, headers=headers)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            news_elements = soup.find_all('div', {'class': 'article__content'})
+            
+            news_list = []
+            for element in news_elements[:5]:
+                title_elem = element.find('a', {'class': 'link'})
+                if title_elem:
+                    title = title_elem.text.strip()
+                    link = title_elem['href']
+                    date_elem = element.find('span', {'class': 'article__timestamp'})
+                    date = date_elem.text if date_elem else 'Recent'
+                    
+                    news_list.append({
+                        'title': title,
+                        'description': title,
+                        'date': date,
+                        'source': 'MarketWatch',
+                        'url': link
+                    })
+            
+            return news_list
+        except Exception as e:
+            print(f"MarketWatch Error: {str(e)}")
+            return []
+
+class YahooRSSNews(NewsSource):
+    """Fetch news from Yahoo Finance RSS feed"""
+    def get_news(self, company: str) -> List[Dict]:
+        try:
+            ticker = company.split('(')[-1].replace(')', '')
+            url = f"https://feeds.finance.yahoo.com/rss/2.0/headline?s={ticker}&region=US&lang=en-US"
+            
+            feed = feedparser.parse(url)
+            news_list = []
+            
+            for entry in feed.entries[:5]:
+                news_list.append({
+                    'title': entry.title,
+                    'description': entry.description,
+                    'date': entry.published,
+                    'source': 'Yahoo Finance',
+                    'url': entry.link
+                })
+            
+            return news_list
+        except Exception as e:
+            print(f"Yahoo RSS Error: {str(e)}")
+            return []
+
+class TechnicalAnalysisAgent:
+    """Agent for technical analysis"""
+    def __init__(self):
+        self.required_periods = {
+            'sma': [20, 50, 200],
+            'rsi': 14,
+            'volatility': 20,
+            'macd': [12, 26, 9]
+        }
+    
+    def analyze(self, data: pd.DataFrame) -> Dict:
+        df = data.copy()
+        close_col = ('Close', df.columns.get_level_values(1)[0])
+        
+        # Calculate metrics
+        df['Returns'] = df[close_col].pct_change()
+        
+        # SMAs
+        for period in self.required_periods['sma']:
+            df[f'SMA_{period}'] = df[close_col].rolling(window=period).mean()
+        
+        # RSI
+        delta = df[close_col].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_col].ewm(span=12, adjust=False).mean()
+        exp2 = df[close_col].ewm(span=26, adjust=False).mean()
+        df['MACD'] = exp1 - exp2
+        df['Signal_Line'] = df['MACD'].ewm(span=9, adjust=False).mean()
+        
+        # Bollinger Bands
+        df['BB_middle'] = df[close_col].rolling(window=20).mean()
+        rolling_std = df[close_col].rolling(window=20).std()
+        df['BB_upper'] = df['BB_middle'] + (2 * rolling_std)
+        df['BB_lower'] = df['BB_middle'] - (2 * rolling_std)
+        
+        return {
+            'processed_data': df,
+            'current_signals': self._generate_signals(df, close_col)
+        }
+    
+    def _generate_signals(self, df: pd.DataFrame, close_col) -> Dict:
+        if df.empty:
+            return {
+                'trend': 'Unknown',
+                'rsi_signal': 'Unknown',
+                'macd_signal': 'Unknown',
+                'bb_position': 'Unknown'
+            }
+        
+        current = df.iloc[-1]
+        
+        trend = 'Bullish' if float(current['SMA_20']) > float(current['SMA_50']) else 'Bearish'
+        
+        rsi_value = float(current['RSI'])
+        if rsi_value > 70:
+            rsi_signal = 'Overbought'
+        elif rsi_value < 30:
+            rsi_signal = 'Oversold'
+        else:
+            rsi_signal = 'Neutral'
+        
+        macd_signal = 'Buy' if float(current['MACD']) > float(current['Signal_Line']) else 'Sell'
+        
+        close_value = float(current[close_col])
+        bb_upper = float(current['BB_upper'])
+        bb_lower = float(current['BB_lower'])
+        
+        if close_value > bb_upper:
+            bb_position = 'Above Upper Band'
+        elif close_value < bb_lower:
+            bb_position = 'Below Lower Band'
+        else:
+            bb_position = 'Within Bands'
+        
+        return {
+            'trend': trend,
+            'rsi_signal': rsi_signal,
+            'macd_signal': macd_signal,
+            'bb_position': bb_position
+        }
+
+class SentimentAnalysisAgent:
+    """Agent for sentiment analysis"""
+    def __init__(self):
+        self.news_sources = [
+            FinvizNews(),
+            MarketWatchNews(),
+            YahooRSSNews()
+        ]
+    
+    def analyze(self, symbol: str) -> Dict:
+        all_news = []
+        for source in self.news_sources:
+            news_items = source.get_news(symbol)
+            all_news.extend(news_items)
+        
+        vader_scores = []
+        finbert_scores = []
+        
+        for article in all_news:
+            vader_scores.append(vader.polarity_scores(article['title']))
+            finbert_scores.append(
+                finbert(article['title'][:512])[0]
+            )
+        
+        return {
+            'articles': all_news,
+            'vader_scores': vader_scores,
+            'finbert_scores': finbert_scores,
+            'aggregated': self._aggregate_sentiment(vader_scores, finbert_scores)
+        }
+    
+    def _aggregate_sentiment(self, vader_scores: List[Dict], 
+                           finbert_scores: List[Dict]) -> Dict:
+        if not vader_scores or not finbert_scores:
+            return {
+                'sentiment': 'Neutral',
+                'confidence': 0,
+                'vader_sentiment': 0,
+                'finbert_sentiment': 0
+            }
+            
+        avg_vader = np.mean([score['compound'] for score in vader_scores])
+        avg_finbert = np.mean([
+            1 if score['label'] == 'positive' else -1 
+            for score in finbert_scores
+        ])
+        
+        combined_score = (avg_vader + avg_finbert) / 2
+        
+        return {
+            'sentiment': 'Bullish' if combined_score > 0.1 else 'Bearish' if combined_score < -0.1 else 'Neutral',
+            'confidence': abs(combined_score),
+            'vader_sentiment': avg_vader,
+            'finbert_sentiment': avg_finbert
+        }
+
+class LLMAgent:
+    """Agent for LLM-based analysis using HuggingFace API"""
+    def __init__(self):
+        self.llm = llm
+    
+    def generate_analysis(self, technical_data: Dict, sentiment_data: Dict) -> str:
+        prompt = self._create_prompt(technical_data, sentiment_data)
+        
+        response = self.llm.invoke(prompt)
+        return response
+    
+    def _create_prompt(self, technical_data: Dict, sentiment_data: Dict) -> str:
+        return f"""Based on technical and sentiment indicators:
+
+    Technical Signals:
+    - Trend: {technical_data['current_signals']['trend']}
+    - RSI: {technical_data['current_signals']['rsi_signal']}
+    - MACD: {technical_data['current_signals']['macd_signal']}
+    - BB Position: {technical_data['current_signals']['bb_position']}
+    - Sentiment: {sentiment_data['aggregated']['sentiment']} (Confidence: {sentiment_data['aggregated']['confidence']:.2f})
+
+    Provide:
+    1. Current Trend Analysis
+    2. Key Risk Factors
+    3. Trading Recommendations
+    4. Price Targets
+    5. Near-term Outlook (1-2 weeks)
+    
+    Note: return only required information and nothing unnecessary"""
+
+# class ChatbotRouter:
+#     """Routes chatbot queries to appropriate data sources and generates responses"""
+#     def __init__(self):
+#         self.llm = llm
+#         self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
+#         self.faiss_index = None
+#         self.company_data = {}
+#         self.news_sources = [
+#             FinvizNews(),
+#             MarketWatchNews(),
+#             YahooRSSNews()
+#         ]
+#         self.load_faiss_index()
+    
+#     def route_and_respond(self, query: str, company: str) -> str:
+#         query_type = self._classify_query(query.lower())
+#         route_message = f"\n[Taking {query_type.upper()} route]\n\n"
+        
+#         if query_type == "company_info":
+#             context = self._get_company_context(query, company)
+#         elif query_type == "news":
+#             context = self._get_news_context(company)
+#         elif query_type == "price":
+#             context = self._get_price_context(company)
+#         else:
+#             return route_message + "I'm not sure how to handle this query. Please ask about company information, news, or price data."
+
+#         prompt = self._create_prompt(query, context, query_type)
+#         response = self.llm.invoke(prompt)
+        
+#         return route_message + response
+
+class ChatbotRouter:
+    """Routes chatbot queries to appropriate data sources and generates responses"""
+    def __init__(self):
+        self.llm = llm
+        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
+        self.faiss_index = None
+        self.company_data = {}
+        self.news_sources = [
+            FinvizNews(),
+            MarketWatchNews(),
+            YahooRSSNews()
+        ]
+        self.load_faiss_index()
+    
+    def load_faiss_index(self):
+        try:
+            self.faiss_index = faiss.read_index("company_profiles.index")
+            for file in os.listdir('company_data'):
+                with open(f'company_data/{file}', 'r') as f:
+                    company_name = file.replace('.txt', '')
+                    self.company_data[company_name] = json.load(f)
+        except Exception as e:
+            print(f"Error loading FAISS index: {e}")
+
+    def route_and_respond(self, query: str, company: str) -> str:
+        query_type = self._classify_query(query.lower())
+        route_message = f"\n[Taking {query_type.upper()} route]\n\n"
+        
+        if query_type == "company_info":
+            context = self._get_company_context(query, company)
+        elif query_type == "news":
+            context = self._get_news_context(company)
+        elif query_type == "price":
+            context = self._get_price_context(company)
+        else:
+            return route_message + "I'm not sure how to handle this query. Please ask about company information, news, or price data."
+
+        prompt = self._create_prompt(query, context, query_type)
+        response = self.llm.invoke(prompt)
+        
+        return route_message + response
+
+    def _classify_query(self, query: str) -> str:
+        """Classify query type"""
+        if any(word in query for word in ["profile", "about", "information", "details", "what", "who", "describe"]):
+            return "company_info"
+        elif any(word in query for word in ["news", "latest", "recent", "announcement", "update"]):
+            return "news"
+        elif any(word in query for word in ["price", "stock", "value", "market", "trading", "cost"]):
+            return "price"
+        return "unknown"
+
+    def _get_company_context(self, query: str, company: str) -> str:
+        """Get relevant company information using FAISS"""
+        try:
+            query_vector = self.encoder.encode([query])
+            D, I = self.faiss_index.search(query_vector, 1)
+            
+            company_name = company.split(" (")[0]
+            company_info = self.company_data.get(company_name, {})
+            print(company_info)
+            return company_info
+            
+        except Exception as e:
+            return f"Error retrieving company information: {str(e)}"
+
+    def _get_news_context(self, company: str) -> str:
+        """Get news from multiple sources"""
+        all_news = []
+        
+        for source in self.news_sources:
+            news_items = source.get_news(company)
+            all_news.extend(news_items)
+        
+        seen_titles = set()
+        unique_news = []
+        for news in all_news:
+            if news['title'] not in seen_titles:
+                seen_titles.add(news['title'])
+                unique_news.append(news)
+        
+        if not unique_news:
+            return "No recent news found."
+        
+        news_context = "Recent news articles:\n\n"
+        for news in unique_news[:5]:
+            news_context += f"Source: {news['source']}\n"
+            news_context += f"Title: {news['title']}\n"
+            if news['description']:
+                news_context += f"Description: {news['description']}\n"
+            news_context += f"Date: {news['date']}\n\n"
+        
+        return news_context
+
+    def _get_price_context(self, company: str) -> str:
+        """Get current price information"""
+        try:
+            ticker = company.split('(')[-1].replace(')', '')
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            
+            return f"""Current Stock Information:
+Price: ${info.get('currentPrice', 'N/A')}
+Day Range: ${info.get('dayLow', 'N/A')} - ${info.get('dayHigh', 'N/A')}
+52 Week Range: ${info.get('fiftyTwoWeekLow', 'N/A')} - ${info.get('fiftyTwoWeekHigh', 'N/A')}
+Market Cap: ${info.get('marketCap', 'N/A'):,}
+Volume: {info.get('volume', 'N/A'):,}
+P/E Ratio: {info.get('trailingPE', 'N/A')}
+Dividend Yield: {info.get('dividendYield', 'N/A')}%"""
+            
+        except Exception as e:
+            return f"Error fetching price data: {str(e)}"
+
+    def _create_prompt(self, query: str, context: str, query_type: str) -> str:
+        """Create prompt for LLM"""
+        if query_type == "news":
+            return f"""Based on the following news articles, please provide a summary addressing the query.
+
+Context:
+{context}
+
+Query: {query}
+
+Please analyze the news and provide:
+1. Key points from the recent articles
+2. Any significant developments or trends
+3. Potential impact on the company
+4. Overall sentiment (positive/negative/neutral)
+
+Response should be clear, concise, and focused on the most relevant information."""
+        else:
+            return f"""Based on the following {query_type} context, please answer the question.
+
+Context:
+{context}
+
+Question: {query}
+
+Please provide a clear and concise answer based on the given context."""
+
+    def _generate_response(self, prompt: str) -> str:
+        """Generate response using LLM"""
+        inputs = self.llm_agent.tokenizer(prompt, return_tensors="pt").to(self.llm_agent.model.device)
+        outputs = self.llm_agent.model.generate(
+            inputs["input_ids"],
+            max_new_tokens=200,
+            temperature=0.7,
+            num_return_sequences=1
+        )
+        # Decode and remove the prompt part from the output
+        response = self.llm_agent.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response_only = response.replace(prompt, "").strip()
+        print(response)
+        return response_only
+
+def analyze_stock(company: str, lookback_days: int = 180) -> Tuple[str, go.Figure, go.Figure]:
+    """Main analysis function"""
+    try:
+        symbol = COMPANIES[company]
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=lookback_days)
+        
+        data = yf.download(symbol, start=start_date, end=end_date)
+        if len(data) == 0:
+            return "No data available.", None, None
+        
+        framework = AgenticRAGFramework()
+        analysis = framework.analyze(symbol, data)
+        
+        plots = create_plots(analysis)
+        
+        return analysis['llm_analysis'], plots[0], plots[1]
+        
+    except Exception as e:
+        return f"Error analyzing stock: {str(e)}", None, None
+
+def create_plots(analysis: Dict) -> List[go.Figure]:
+    """Create analysis plots"""
+    data = analysis['technical_analysis']['processed_data']
+    
+    # Price and Volume Plot
+    fig1 = make_subplots(
+        rows=2, cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.03,
+        subplot_titles=('Price Analysis', 'Volume'),
+        row_heights=[0.7, 0.3]
+    )
+
+    close_col = ('Close', data.columns.get_level_values(1)[0])
+    open_col = ('Open', data.columns.get_level_values(1)[0])
+    volume_col = ('Volume', data.columns.get_level_values(1)[0])
+
+    fig1.add_trace(
+        go.Scatter(x=data.index, y=data[close_col], name='Price',
+                  line=dict(color='blue', width=2)),
+        row=1, col=1
+    )
+    fig1.add_trace(
+        go.Scatter(x=data.index, y=data['SMA_20'], name='SMA20',
+                  line=dict(color='orange', width=1.5)),
+        row=1, col=1
+    )
+    fig1.add_trace(
+        go.Scatter(x=data.index, y=data['SMA_50'], name='SMA50',
+                  line=dict(color='red', width=1.5)),
+        row=1, col=1
+    )
+    
+    colors = ['red' if float(row[close_col]) < float(row[open_col]) else 'green' 
+              for idx, row in data.iterrows()]
+    
+    fig1.add_trace(
+        go.Bar(x=data.index, y=data[volume_col], marker_color=colors, name='Volume'),
+        row=2, col=1
+    )
+    
+    fig1.update_layout(
+        height=400,
+        showlegend=True,
+        xaxis_rangeslider_visible=False,
+        plot_bgcolor='white',
+        paper_bgcolor='white'
+    )
+    
+    # Technical Indicators Plot
+    fig2 = make_subplots(
+        rows=3, cols=1,
+        shared_xaxes=True,
+        subplot_titles=('RSI', 'MACD', 'Bollinger Bands'),
+        row_heights=[0.33, 0.33, 0.34],
+        vertical_spacing=0.03
+    )
+    
+    # RSI
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data['RSI'], name='RSI',
+                  line=dict(color='purple', width=1.5)),
+        row=1, col=1
+    )
+    fig2.add_hline(y=70, line_dash="dash", line_color="red", row=1, col=1)
+    fig2.add_hline(y=30, line_dash="dash", line_color="green", row=1, col=1)
+    
+    # MACD
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data['MACD'], name='MACD',
+                  line=dict(color='blue', width=1.5)),
+        row=2, col=1
+    )
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data['Signal_Line'], name='Signal',
+                  line=dict(color='orange', width=1.5)),
+        row=2, col=1
+    )
+    
+    # Bollinger Bands
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data[close_col], name='Price',
+                  line=dict(color='blue', width=2)),
+        row=3, col=1
+    )
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data['BB_upper'], name='Upper BB',
+                  line=dict(color='gray', dash='dash')),
+        row=3, col=1
+    )
+    fig2.add_trace(
+        go.Scatter(x=data.index, y=data['BB_lower'], name='Lower BB',
+                  line=dict(color='gray', dash='dash')),
+        row=3, col=1
+    )
+    
+    fig2.update_layout(
+        height=400,
+        showlegend=True,
+        plot_bgcolor='white',
+        paper_bgcolor='white'
+    )
+    
+    return [fig1, fig2]
+
+def chatbot_response(message: str, company: str, history: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
+    """Handle chatbot interactions"""
+    router = ChatbotRouter(LlamaAgent())
+    response = router.route_and_respond(message, company)
+    history = history + [(message, response)]
+    return history
+
+# def create_interface():
+#     """Create Gradio interface"""
+#     with gr.Blocks() as interface:
+#         gr.Markdown("# Stock Analysis with Multi-Source News")
+        
+#         with gr.Row():
+#             with gr.Column(scale=2):
+#                 company = gr.Dropdown(
+#                     choices=list(COMPANIES.keys()),
+#                     value=list(COMPANIES.keys())[0],
+#                     label="Company"
+#                 )
+#                 lookback = gr.Slider(
+#                     minimum=30,
+#                     maximum=365,
+#                     value=180,
+#                     step=1,
+#                     label="Analysis Period (days)"
+#                 )
+#                 analyze_btn = gr.Button("Analyze", variant="primary")
+            
+#         with gr.Row():
+#             with gr.Column(scale=1):
+#                 chatbot = gr.Chatbot(label="Stock Assistant", height=400)
+#                 with gr.Row():
+#                     msg = gr.Textbox(
+#                         label="Ask about company info, news, or prices",
+#                         scale=4
+#                     )
+#                     submit = gr.Button("Submit", scale=1)
+#                     clear = gr.Button("Clear", scale=1)
+            
+#             with gr.Column(scale=2):
+#                 analysis = gr.Textbox(
+#                     label="Technical Analysis Summary",
+#                     lines=10
+#                 )
+#                 chart1 = gr.Plot(label="Price and Volume Analysis")
+#                 chart2 = gr.Plot(label="Technical Indicators")
+        
+#         # Event handlers
+#         analyze_btn.click(
+#             fn=analyze_stock,
+#             inputs=[company, lookback],
+#             outputs=[analysis, chart1, chart2]
+#         )
+        
+#         submit.click(
+#             fn=chatbot_response,
+#             inputs=[msg, company, chatbot],
+#             outputs=chatbot
+#         )
+        
+#         msg.submit(
+#             fn=chatbot_response,
+#             inputs=[msg, company, chatbot],
+#             outputs=chatbot
+#         )
+        
+#         clear.click(lambda: None, None, chatbot, queue=False)
+        
+#     return interface
+
+def create_interface():
+    """Create Gradio interface"""
+    with gr.Blocks() as interface:
+        gr.Markdown("# Stock Analysis with Multi-Source News")
+        
+        # Top section with analysis components
+        with gr.Row():
+            # Left column - Controls and Summary
+            with gr.Column(scale=1):
+                company = gr.Dropdown(
+                    choices=list(COMPANIES.keys()),
+                    value=list(COMPANIES.keys())[0],
+                    label="Company"
+                )
+                lookback = gr.Slider(
+                    minimum=30,
+                    maximum=365,
+                    value=180,
+                    step=1,
+                    label="Analysis Period (days)"
+                )
+                analyze_btn = gr.Button("Analyze", variant="primary")
+                analysis = gr.Textbox(
+                    label="Technical Analysis Summary",
+                    lines=30
+                )
+            
+            # Right column - Charts
+            with gr.Column(scale=2):
+                chart1 = gr.Plot(label="Price and Volume Analysis")
+                chart2 = gr.Plot(label="Technical Indicators")
+        
+        gr.Markdown("---")  # Separator
+        
+        # Bottom section - Chatbot
+        with gr.Row():
+            chatbot = gr.Chatbot(label="Stock Assistant", height=400)
+        
+        with gr.Row():
+            msg = gr.Textbox(
+                label="Ask about company info, news, or prices",
+                scale=4
+            )
+            submit = gr.Button("Submit", scale=1)
+            clear = gr.Button("Clear", scale=1)
+        
+        # Event handlers
+        analyze_btn.click(
+            fn=analyze_stock,
+            inputs=[company, lookback],
+            outputs=[analysis, chart1, chart2]
+        )
+        
+        submit.click(
+            fn=chatbot_response,
+            inputs=[msg, company, chatbot],
+            outputs=chatbot
+        )
+        
+        msg.submit(
+            fn=chatbot_response,
+            inputs=[msg, company, chatbot],
+            outputs=chatbot
+        )
+        
+        clear.click(lambda: None, None, chatbot, queue=False)
+        
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(debug=True)