initial code

app.py

@@ -0,0 +1,659 @@
+import gradio as gr
+import sys
+import os
+import traceback
+from crew import PredictingStock
+import json
+import re
+import tempfile
+import subprocess
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+from typing import Dict, Any
+from datetime import datetime, timedelta
+
+class StockDataProcessor:
+    """Handles stock data processing and visualization"""
+    
+    def __init__(self):
+        self.data = None
+        self.df = None
+    
+    def load_json_data(self, json_file_path: str) -> bool:
+        """Load stock data from JSON file"""
+        try:
+            with open(json_file_path, 'r') as f:
+                content = f.read()
+            
+            # Handle double-encoded JSON if necessary
+            try:
+                self.data = json.loads(content)
+                if isinstance(self.data, str):
+                    self.data = json.loads(self.data)
+            except:
+                self.data = json.loads(content)
+            
+            # Convert to DataFrame
+            self.df = pd.DataFrame.from_dict(self.data, orient='index')
+            self.df.index = pd.to_datetime(self.df.index)
+            self.df = self.df.sort_index()
+            
+            # Rename columns for easier access
+            self.df.columns = ['open', 'high', 'low', 'close', 'volume', 'dividends', 'stock_splits']
+            
+            # Calculate technical indicators
+            self._calculate_technical_indicators()
+            
+            return True
+        except Exception as e:
+            return False
+    
+    def _calculate_technical_indicators(self):
+        """Calculate technical indicators"""
+        # Daily returns
+        self.df['daily_return'] = self.df['close'].pct_change()
+        
+        # Moving averages
+        self.df['ma_20'] = self.df['close'].rolling(window=20).mean()
+        self.df['ma_50'] = self.df['close'].rolling(window=50).mean()
+        
+        # RSI
+        self.df['rsi'] = self._calculate_rsi(self.df['close'])
+        
+        # Bollinger Bands
+        self.df['bb_middle'] = self.df['ma_20']
+        bb_std = self.df['close'].rolling(window=20).std()
+        self.df['bb_upper'] = self.df['bb_middle'] + (bb_std * 2)
+        self.df['bb_lower'] = self.df['bb_middle'] - (bb_std * 2)
+        
+        # Volume moving average
+        self.df['volume_ma'] = self.df['volume'].rolling(window=20).mean()
+    
+    def _calculate_rsi(self, prices, window=14):
+        """Calculate RSI indicator"""
+        delta = prices.diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
+        rs = gain / loss
+        return 100 - (100 / (1 + rs))
+    
+    def create_interactive_chart(self, ticker: str):
+        """Create interactive Plotly chart with only stock price and technical analysis"""
+        if self.df is None or self.df.empty:
+            return None
+        
+        # Create a single subplot for the stock price with technical analysis
+        fig = make_subplots(
+            rows=1, cols=1,
+            shared_xaxes=True,
+            subplot_titles=(f'{ticker} - Stock Price with Technical Analysis',)
+        )
+        
+        # Price chart with technical indicators
+        fig.add_trace(
+            go.Scatter(x=self.df.index, y=self.df['close'], 
+                       name='Close Price', line=dict(color='#2E86C1', width=2)),
+            row=1, col=1
+        )
+        
+        fig.add_trace(
+            go.Scatter(x=self.df.index, y=self.df['ma_20'], 
+                       name='20-day MA', line=dict(color='orange', width=1)),
+            row=1, col=1
+        )
+        
+        fig.add_trace(
+            go.Scatter(x=self.df.index, y=self.df['ma_50'], 
+                       name='50-day MA', line=dict(color='red', width=1)),
+            row=1, col=1
+        )
+        
+        # Bollinger Bands
+        fig.add_trace(
+            go.Scatter(x=self.df.index, y=self.df['bb_upper'], 
+                       line=dict(color='gray', width=1, dash='dash'),
+                       name='BB Upper', showlegend=False),
+            row=1, col=1
+        )
+        
+        fig.add_trace(
+            go.Scatter(x=self.df.index, y=self.df['bb_lower'], 
+                       line=dict(color='gray', width=1, dash='dash'),
+                       fill='tonexty', fillcolor='rgba(128,128,128,0.1)',
+                       name='Bollinger Bands'),
+            row=1, col=1
+        )
+        
+        # Update layout
+        fig.update_layout(
+            height=600,
+            title_text=f"Stock Price with Technical Analysis for {ticker}",
+            showlegend=True,
+            xaxis_rangeslider_visible=True
+        )
+        
+        # Update y-axes labels
+        fig.update_yaxes(title_text="Price ($)", row=1, col=1)
+        fig.update_xaxes(title_text="Date", row=1, col=1)
+        
+        return fig
+    
+    def create_default_chart(self):
+        """Create a default placeholder chart"""
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=[0, 1, 2, 3, 4],
+            y=[100, 110, 105, 115, 120],
+            mode='lines+markers',
+            name='Sample Stock Data',
+            line=dict(color='#2E86C1', width=2)
+        ))
+        
+        fig.update_layout(
+            title="📈 Example Stock Chart Preview (Note: This is not the actual graph.)",
+            xaxis_title="Time Period",
+            yaxis_title="Price ($)",
+            height=400,
+            template="plotly_white"
+        )
+        
+        return fig
+    
+    def get_statistics(self, ticker: str) -> str:
+        """Generate key statistics"""
+        if self.df is None or self.df.empty:
+            return "No data available"
+        
+        try:
+            current_price = self.df['close'].iloc[-1]
+            start_price = self.df['close'].iloc[0]
+            
+            stats = f"""
+📊 **Key Statistics for {ticker}**
+
+**Price Performance:**
+• Current Price: ${current_price:.2f}
+
+**Trading Activity:**
+• Data Period: {self.df.index[0].strftime('%Y-%m-%d')} to {self.df.index[-1].strftime('%Y-%m-%d')}
+• Total Trading Days: {len(self.df)}
+            """
+            
+            return stats.strip()
+            
+        except Exception as e:
+            return f"Error calculating statistics: {e}"
+    
+    def get_default_statistics(self):
+        """Get default statistics for initial display"""
+        return """
+📊 **Stock Statistics Preview**
+
+Welcome to AI Stock Analysis! 
+
+**What you'll get:**
+• Real-time stock price data
+• Technical analysis indicators
+• AI-powered investment recommendations
+• Risk assessment and insights
+
+📈 **Enter a stock ticker below to begin analysis**
+        """
+
+class SecureAPIHandler:
+    """Handles API keys securely without permanent storage"""
+    
+    def __init__(self):
+        self.session_keys = {}
+        # Use Hugging Face Secrets for Finnhub API key
+        self.finnhub_available = bool(os.getenv("FINNHUB_API_KEY"))
+    
+    def validate_anthropic_key(self, key_value: str) -> tuple[bool, str]:
+        """Validate Anthropic API key format"""
+        if not key_value or not key_value.strip():
+            return False, "Anthropic API key is required"
+        
+        key_value = key_value.strip()
+        
+        if not key_value.startswith("sk-ant-"):
+            return False, "Anthropic API key should start with 'sk-ant-'"
+        if len(key_value) < 20:
+            return False, "Anthropic API key appears too short"
+        
+        return True, "Valid"
+    
+    def check_finnhub_env(self) -> tuple[bool, str]:
+        """Check if Finnhub key is properly set in environment"""
+        finnhub_key = os.getenv("FINNHUB_API_KEY")
+        if not finnhub_key:
+            return False, "Finnhub API key not found in environment variables"
+        if len(finnhub_key.strip()) < 10:
+            return False, "Finnhub API key appears invalid"
+        return True, "Finnhub API key loaded from environment"
+    
+    def set_anthropic_key(self, anthropic_key: str) -> tuple[bool, str]:
+        """Securely set Anthropic API key for the session"""
+        try:
+            is_valid, message = self.validate_anthropic_key(anthropic_key)
+            if not is_valid:
+                return False, f"Validation Error: {message}"
+            
+            finnhub_valid, finnhub_message = self.check_finnhub_env()
+            if not finnhub_valid:
+                return False, f"Environment Error: {finnhub_message}"
+            
+            os.environ["ANTHROPIC_API_KEY"] = anthropic_key.strip()
+            self.session_keys["ANTHROPIC_API_KEY"] = "***" + anthropic_key[-4:]
+            self.session_keys["FINNHUB_API_KEY"] = "***" + os.getenv("FINNHUB_API_KEY")[-4:]
+            
+            return True, "API keys validated and configured successfully"
+            
+        except Exception as e:
+            return False, f"Error configuring API keys: {str(e)}"
+    
+    def clear_session_keys(self):
+        """Clear Anthropic API key from environment"""
+        if "ANTHROPIC_API_KEY" in os.environ:
+            del os.environ["ANTHROPIC_API_KEY"]
+        self.session_keys.clear()
+
+# Global instances
+api_handler = SecureAPIHandler()
+stock_processor = StockDataProcessor()
+
+def run_chart_generation(company_ticker: str) -> tuple[bool, str]:
+    """Run chart.py to generate JSON data"""
+    try:
+        # Run chart.py script
+        result = subprocess.run([sys.executable, 'chart.py', company_ticker], 
+                                capture_output=True, text=True, timeout=60)
+        
+        if result.returncode == 0:
+            return True, "Chart data generated successfully"
+        else:
+            return False, f"Chart generation failed: {result.stderr}"
+    
+    except subprocess.TimeoutExpired:
+        return False, "Chart generation timed out"
+    except Exception as e:
+        return False, f"Error running chart.py: {str(e)}"
+
+def load_stock_data_and_chart(ticker_symbol: str = "AAPL", progress=gr.Progress()):
+    """First function: Load stock data and create chart/stats"""
+    try:
+        if progress:
+            progress(0.1, desc="Generating stock data...")
+        
+        ticker = ticker_symbol.strip().upper()
+        
+        # Step 1: Run chart.py to generate JSON data
+        chart_success, chart_message = run_chart_generation(ticker)
+        if not chart_success:
+            return f"❌ Chart Generation Error: {chart_message}", stock_processor.get_default_statistics(), stock_processor.create_default_chart()
+        
+        if progress:
+            progress(0.5, desc="Loading and processing stock data...")
+        
+        # Step 2: Load the generated JSON data
+        json_file_path = f"{ticker}_financial_data.json"
+        if not os.path.exists(json_file_path):
+            return f"❌ Error: JSON file {json_file_path} not found", stock_processor.get_default_statistics(), stock_processor.create_default_chart()
+        
+        # Load stock data for visualization
+        if not stock_processor.load_json_data(json_file_path):
+            return "❌ Please enter company ticker", stock_processor.get_default_statistics(), stock_processor.create_default_chart()
+        
+        if progress:
+            progress(1.0, desc="Creating visualization...")
+        
+        # Step 3: Create visualization and stats
+        chart_fig = stock_processor.create_interactive_chart(ticker)
+        stats = stock_processor.get_statistics(ticker)
+        
+        success_msg = f"✅ Successfully loaded data for {ticker}"
+        
+        return success_msg, stats, chart_fig
+
+    except Exception as e:
+        error_msg = f"❌ Error loading stock data: {str(e)}"
+        return error_msg, stock_processor.get_default_statistics(), stock_processor.create_default_chart()
+
+def load_company_data(ticker: str):
+    """Load data for a specific company from navigation bar"""
+    # Load the stock data
+    status, stats, chart = load_stock_data_and_chart(ticker)
+    # Return the ticker value and the loaded data
+    return ticker, status, stats, chart
+
+def run_ai_analysis(company_ticker: str, max_amount: str, anthropic_key: str, progress=gr.Progress()):
+    """Second function: Run AI crew analysis only"""
+    try:
+        progress(0.05, desc="Validating inputs...")
+        
+        # Validate inputs
+        if not company_ticker or not company_ticker.strip():
+            return "❌ Error: Please enter a company ticker symbol"
+        
+        if not max_amount or not max_amount.strip():
+            return "❌ Error: Please enter a maximum investment amount"
+
+        try:
+            float(max_amount)
+        except ValueError:
+            return "❌ Error: Maximum investment amount must be a valid number"
+
+        if not anthropic_key or not anthropic_key.strip():
+            return "❌ Error: Anthropic API key is required"
+        
+        ticker = company_ticker.strip().upper()
+        
+        progress(0.2, desc="Configuring API keys...")
+        
+        # Set API keys securely
+        success, message = api_handler.set_anthropic_key(anthropic_key)
+        if not success:
+            return f"❌ {message}"
+        
+        progress(0.3, desc="Preparing AI analysis...")
+        
+        # Prepare inputs for CrewAI
+        inputs = {
+            "company_name": ticker,
+            "max_amount": max_amount
+        }
+        
+        progress(0.4, desc="Initializing AI agents...")
+        
+        # Run CrewAI analysis
+        crew_instance = PredictingStock()
+        
+        progress(0.6, desc="AI agents are running now... This may take 2-5 minutes")
+        
+        result = crew_instance.crew().kickoff(inputs=inputs)
+        
+        progress(1.0, desc="Analysis complete!")
+        
+        # Format results
+        analysis_result = f"""
+🎯 COMPREHENSIVE STOCK ANALYSIS FOR: {ticker}
+{'='*60}
+
+{result.raw}
+
+""".strip()
+
+        return analysis_result
+
+    except Exception as e:
+        error_msg = f"""
+❌ ERROR DURING AI ANALYSIS:
+
+{str(e)}
+
+TROUBLESHOOTING TIPS:
+1. Verify your Anthropic API key is correct
+2. Check that FINNHUB_API_KEY is set in Hugging Face Secrets
+3. Check your internet connection  
+4. Ensure the ticker symbol is valid
+5. Try again in a few moments
+
+Full error details:
+{traceback.format_exc()}
+        """.strip()
+        return error_msg
+
+def create_secure_interface():
+    """Create the enhanced Gradio interface with rearranged layout"""
+    css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .header {
+        text-align: center;
+        padding: 20px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border-radius: 10px;
+        margin-bottom: 30px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    .nav-bar {
+        background: linear-gradient(135deg, #ffecd2 0%, #fcb69f 100%);
+        padding: 15px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+        text-align: center;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    }
+    .nav-button {
+        margin: 5px !important;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        border: none !important;
+        color: white !important;
+        font-weight: bold !important;
+        border-radius: 8px !important;
+        padding: 10px 20px !important;
+        transition: all 0.3s ease !important;
+    }
+    .nav-button:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2) !important;
+    }
+    .stats-box {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        color: white;
+        padding: 15px;
+        border-radius: 10px;
+        margin: 10px 0;
+    }
+    .secure-input {
+        border: 2px solid #28a745 !important;
+    }
+    .section-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 10px;
+        border-radius: 8px;
+        margin: 15px 0 10px 0;
+        text-align: center;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="AI Stock Prediction with Visualization") as interface:
+        # Header
+        gr.HTML("""
+        <div class="header">
+            <h1>🚀 AI Stock Prediction & Visualization System</h1>
+            <p>Complete stock analysis with interactive charts and AI-powered insights</p>
+        </div>
+        """)
+        
+        # NAVIGATION BAR
+        gr.HTML('<div class="nav-bar"><h3>🏢 Quick Access - Popular Companies</h3></div>')
+        
+        with gr.Row():
+            apple_btn = gr.Button("🍎 Apple (AAPL)", elem_classes=["nav-button"], scale=1)
+            google_btn = gr.Button("🔍 Google (GOOGL)", elem_classes=["nav-button"], scale=1)
+            microsoft_btn = gr.Button("💻 Microsoft (MSFT)", elem_classes=["nav-button"], scale=1)
+            tesla_btn = gr.Button("⚡ Tesla (TSLA)", elem_classes=["nav-button"], scale=1)
+            amazon_btn = gr.Button("📦 Amazon (AMZN)", elem_classes=["nav-button"], scale=1)
+        
+        # CUSTOM COMPANY SECTION
+        gr.HTML('<div class="nav-bar"><h4>✨ Add Any Company</h4></div>')
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                custom_ticker_input = gr.Textbox(
+                    label="Enter Any Stock Ticker",
+                    placeholder="e.g., NVDA, META, NFLX, etc.",
+                    value="",
+                    info="Type any valid stock ticker symbol",
+                    elem_classes=["secure-input"]
+                )
+            with gr.Column(scale=1):
+                custom_load_btn = gr.Button(
+                    "🚀 Load Custom Stock",
+                    elem_classes=["nav-button"],
+                    variant="primary",
+                    size="lg"
+                )
+        
+        # TOP SECTION: Statistics and Chart (Displayed from start)
+        gr.HTML('<div class="section-header"><h2>📊 Live Statistics & Interactive Chart</h2></div>')
+        
+        # Load default stock data (AAPL) on startup
+        default_message, default_stats, default_chart = load_stock_data_and_chart("AAPL")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Statistics box (shown from start with real stock data)
+                stats_output = gr.Markdown(
+                    value=default_stats,
+                    elem_classes=["stats-box"]
+                )
+            
+            with gr.Column(scale=2):
+                # Interactive chart (shown from start with real stock data)
+                chart_output = gr.Plot(
+                    value=default_chart,
+                    label="Stock Price Chart",
+                    show_label=True
+                )
+        
+        # Status message for stock data loading
+        stock_status = gr.Markdown(value=default_message)
+        
+        # MIDDLE SECTION: Input Configuration
+        gr.HTML('<div class="section-header"><h2>⚙️ Analysis Configuration</h2></div>')
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                company_ticker = gr.Textbox(
+                    label="Company Ticker Symbol",
+                    placeholder="Here the selected company ticker will be shown",
+                    value="",
+                    info="Stock ticker symbol to analyze",
+                    elem_classes=["secure-input"],
+                    interactive=False
+                )
+            
+            with gr.Column(scale=1):
+                max_amount = gr.Textbox(
+                    label="Maximum Investment Amount (USD)",
+                    placeholder="e.g., 1000, 5000.50",
+                    value="",
+                    info="The maximum amount you are willing to invest",
+                    elem_classes=["secure-input"]
+                )
+            
+            with gr.Column(scale=1):
+                anthropic_key = gr.Textbox(
+                    label="Anthropic API Key (Claude)",
+                    placeholder="sk-ant-api03-...",
+                    type="password",
+                    info="Get from console.anthropic.com - Required for AI analysis",
+                    elem_classes=["secure-input"]
+                )
+        
+        with gr.Row():
+            with gr.Column():
+                load_data_btn = gr.Button(
+                    "📊 Load Stock Data",
+                    variant="secondary",
+                    size="lg",
+                    scale=1
+                )
+            with gr.Column():
+                analyze_btn = gr.Button(
+                    "🤖 Run AI Analysis",
+                    variant="primary",
+                    size="lg",
+                    scale=2
+                )
+        
+        # BOTTOM SECTION: AI Analysis Results
+        gr.HTML('<div class="section-header"><h2>🤖 AI Agent Analysis & Recommendations</h2></div>')
+        
+        result_output = gr.TextArea(
+            label="AI Analysis Report",
+            lines=25,
+            max_lines=35,
+            interactive=False,
+            show_copy_button=True,
+            placeholder="🤖 AI analysis results and investment recommendations will appear here after running the analysis...\n\nThe AI agents will provide:\n• Comprehensive stock analysis\n• Risk assessment\n• Investment recommendations\n• Market insights\n• Technical analysis summary"
+        )
+        
+        # Event handlers
+        
+        # Navigation bar buttons
+        apple_btn.click(
+            fn=lambda: load_company_data("AAPL"),
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        google_btn.click(
+            fn=lambda: load_company_data("GOOGL"),
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        microsoft_btn.click(
+            fn=lambda: load_company_data("MSFT"),
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        tesla_btn.click(
+            fn=lambda: load_company_data("TSLA"),
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        amazon_btn.click(
+            fn=lambda: load_company_data("AMZN"),
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        # Custom ticker loading functionality
+        custom_load_btn.click(
+            fn=lambda ticker: load_company_data(ticker),
+            inputs=[custom_ticker_input],
+            outputs=[company_ticker, stock_status, stats_output, chart_output]
+        )
+        
+        # Load stock data when load button is clicked
+        load_data_btn.click(
+            fn=load_stock_data_and_chart,
+            inputs=[company_ticker],
+            outputs=[stock_status, stats_output, chart_output]
+        )
+        
+        # Run AI analysis when button is clicked
+        analyze_btn.click(
+            fn=run_ai_analysis,
+            inputs=[company_ticker, max_amount, anthropic_key],
+            outputs=[result_output] 
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #dee2e6;">
+            <p>🔐 <strong>Secure AI Stock Analysis with Interactive Visualization</strong></p>
+            <p style="font-size: 12px; color: #6c757d;">
+                Features: Real-time data • Technical indicators • AI analysis • Interactive charts
+            </p>
+        </div>
+        """)
+    
+    return interface
+
+# Launch the application
+if __name__ == "__main__":
+    interface = create_secure_interface()
+    # Modified for Hugging Face Spaces deployment
+    interface.launch(
+        share=False,
+        debug=False,
+        show_error=True
+    )

chart.py

@@ -0,0 +1,208 @@
+import yfinance as yf
+from datetime import datetime, timedelta
+import json
+import sys
+import os
+import time
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+def setup_session_with_retries():
+    """Setup a requests session with retry logic for better reliability"""
+    session = requests.Session()
+    
+    retry_strategy = Retry(
+        total=3,
+        backoff_factor=1,
+        status_forcelist=[429, 500, 502, 503, 504],
+    )
+    
+    adapter = HTTPAdapter(max_retries=retry_strategy)
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    
+    return session
+
+def retrieve_financial_data(company_name: str) -> str:
+    """
+    It returns the last 6 months of daily stock Open, High, Low, Close, Volume, Dividends, Stock Splits for the specified company.
+
+    Args:
+    company_name: str -> the ticker symbol of the company (e.g., 'AAPL', 'GOOGL')
+    
+    Returns:
+    str: JSON string containing the financial data or error message
+    """
+    try:
+        # Validate ticker symbol
+        if not company_name or not company_name.strip():
+            return "Error: Empty ticker symbol provided"
+        
+        company_name = company_name.strip().upper()
+        
+        # Calculate dates for last 6 months
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=180)  # Approximately 6 months
+        
+        # Setup session with retries for better reliability
+        session = setup_session_with_retries()
+        
+        # Get the data with custom session
+        ticker = yf.Ticker(company_name, session=session)
+        
+        # Add a small delay to be respectful to the API
+        time.sleep(0.1)
+        
+        # Fetch historical data
+        hist = ticker.history(
+            start=start_date.strftime("%Y-%m-%d"), 
+            end=end_date.strftime("%Y-%m-%d"),
+            auto_adjust=True,
+            prepost=True,
+            threads=True
+        )
+        
+        if hist.empty:
+            return f"Error: No data found for ticker symbol: {company_name}. Please verify the ticker symbol is correct."
+        
+        # Validate that we have sufficient data
+        if len(hist) < 10:
+            return f"Error: Insufficient data found for {company_name}. Only {len(hist)} days of data available."
+        
+        # Clean the data - remove any NaN values and ensure proper formatting
+        hist = hist.dropna()
+        
+        if hist.empty:
+            return f"Error: No valid data remaining for {company_name} after cleaning."
+        
+        # Convert to JSON and return
+        json_data = hist.to_json(date_format='iso', orient='index')
+        
+        # Validate JSON was created successfully
+        try:
+            json.loads(json_data)  # Test if it's valid JSON
+        except json.JSONDecodeError:
+            return f"Error: Failed to convert data to JSON format for {company_name}"
+        
+        return json_data
+        
+    except requests.exceptions.RequestException as e:
+        return f"Error: Network issue while retrieving data for {company_name}: {str(e)}"
+    except yf.exceptions.YFinanceException as e:
+        return f"Error: Yahoo Finance API issue for {company_name}: {str(e)}"
+    except Exception as e:
+        return f"Error: Unexpected error retrieving data for {company_name}: {str(e)}"
+
+def save_financial_data(company_name: str, data: str) -> bool:
+    """
+    Save financial data to a JSON file with error handling
+    
+    Args:
+    company_name: str -> the ticker symbol
+    data: str -> JSON string to save
+    
+    Returns:
+    bool: True if successful, False otherwise
+    """
+    try:
+        filename = f"{company_name}_financial_data.json"
+        
+        # Check if data is an error message
+        if data.startswith("Error:"):
+            print(f"❌ Data retrieval failed: {data}")
+            return False
+        
+        # Validate JSON before saving
+        try:
+            json.loads(data)
+        except json.JSONDecodeError:
+            print(f"❌ Invalid JSON data for {company_name}")
+            return False
+        
+        # Ensure directory exists (important for cloud environments)
+        os.makedirs(os.path.dirname(filename) if os.path.dirname(filename) else '.', exist_ok=True)
+        
+        # Save to file
+        with open(filename, "w", encoding='utf-8') as file:
+            json.dump(data, file, ensure_ascii=False, indent=2)
+        
+        # Verify file was created and has content
+        if os.path.exists(filename) and os.path.getsize(filename) > 0:
+            print(f"✅ Successfully saved data for {company_name} to {filename}")
+            return True
+        else:
+            print(f"❌ Failed to save data for {company_name} - file not created or empty")
+            return False
+            
+    except PermissionError:
+        print(f"❌ Permission denied: Cannot write to file for {company_name}")
+        return False
+    except OSError as e:
+        print(f"❌ OS Error saving data for {company_name}: {str(e)}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error saving data for {company_name}: {str(e)}")
+        return False
+
+def validate_ticker_symbol(symbol: str) -> tuple[bool, str]:
+    """
+    Basic validation of ticker symbol format
+    
+    Args:
+    symbol: str -> ticker symbol to validate
+    
+    Returns:
+    tuple: (is_valid, message)
+    """
+    if not symbol or not symbol.strip():
+        return False, "Ticker symbol cannot be empty"
+    
+    symbol = symbol.strip().upper()
+    
+    # Basic format validation
+    if len(symbol) < 1 or len(symbol) > 10:
+        return False, "Ticker symbol must be 1-10 characters long"
+    
+    if not symbol.isalnum():
+        return False, "Ticker symbol must contain only letters and numbers"
+    
+    return True, "Valid ticker symbol"
+
+if __name__ == "__main__":
+    try:
+        # Check command line arguments
+        if len(sys.argv) != 2:
+            print("❌ Usage: python chart.py <TICKER_SYMBOL>")
+            print("Example: python chart.py AAPL")
+            sys.exit(1)
+        
+        symbol = sys.argv[1].strip().upper()
+        
+        # Validate ticker symbol
+        is_valid, validation_message = validate_ticker_symbol(symbol)
+        if not is_valid:
+            print(f"❌ Invalid ticker symbol: {validation_message}")
+            sys.exit(1)
+        
+        print(f"📊 Retrieving financial data for {symbol}...")
+        
+        # Retrieve financial data
+        financial_data = retrieve_financial_data(symbol)
+        
+        # Save the data
+        success = save_financial_data(symbol, financial_data)
+        
+        if success:
+            print(f"🎯 Operation completed successfully for {symbol}")
+            sys.exit(0)
+        else:
+            print(f"❌ Failed to complete operation for {symbol}")
+            sys.exit(1)
+            
+    except KeyboardInterrupt:
+        print("\n❌ Operation cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+        sys.exit(1)

config/agents.yaml

@@ -0,0 +1,53 @@
+# config/agents.yaml
+stock_information_specialist:
+  role: >
+    Stock Information Specialist
+  goal: >
+    To provide accurate and timely stock information using the tool by gathering comprehensive historical stock Open, High, Low, Close, Volume, Dividends, Stock Splits for a specified company.
+  backstory: >
+    You are a meticulous financial data analyst with an unparalleled ability to extract,
+    process, and interpret historical stock market information. Your expertise lies
+    in identifying trends, patterns, and anomalies within vast datasets of stock prices,
+    volume, and financial statements. You are crucial for providing the foundational
+    numerical context for predicting future stock movements.
+
+company_profile_specialist:
+  role: >
+    Company Profile Analyst
+  goal: >
+    To gather and analyze key company information including market capitalization, 
+    industry classification, exchange listing, geographic location, and corporate 
+    fundamentals to assess the company's market position and characteristics.
+  backstory: >
+    You are an experienced company research analyst with deep expertise in analyzing 
+    corporate fundamentals and market positioning. Your strength lies in interpreting 
+    company profiles, market capitalizations, industry classifications, and geographic 
+    factors that influence stock performance. You excel at understanding how company 
+    size, listing exchange, industry sector, and regional factors impact investment potential.
+
+news_analyst:
+  role: >
+    News and Sentiment Analyst
+  goal: >
+    To gather, analyze, and interpret the latest news, market sentiment, and external 
+    factors that could impact the stock's short-term and long-term performance.
+  backstory: >
+    You are a seasoned market news analyst with an exceptional ability to quickly 
+    process and interpret financial news, earnings reports, regulatory changes, and 
+    market sentiment. Your expertise lies in identifying how external events and 
+    market psychology influence stock prices, providing crucial insights into timing 
+    and market dynamics.
+
+investment_advisor:
+  role: >
+    Senior Investment Advisor
+  goal: >
+    To synthesize all available information from technical analysis, fundamental 
+    analysis, and market sentiment to make a well-informed investment recommendation along with how many to invest from {max_amount} 
+    with clear reasoning and risk assessment.
+  backstory: >
+    You are a seasoned investment advisor with over 15 years of experience in making 
+    investment decisions. Your expertise lies in combining technical analysis, 
+    fundamental analysis, and market sentiment to provide comprehensive investment 
+    recommendations. You have a proven track record of successful stock picks and 
+    risk management, always considering both potential returns and downside risks.

config/tasks.yaml

@@ -0,0 +1,69 @@
+generate_stock_information:
+  description: >
+    You are a 'Stock Information Specialist' and fetch the last 6 months of daily
+    stock prices using the retrieve_financial_data tool for the company {company_name}. 
+    Analyze the data for Open, High, Low, Close, Volume, Dividends, Stock Splits.
+    Ensure the data is clean and ready for analysis. Provide insights on trends,
+    volatility, and any notable patterns in the stock performance.
+  expected_output: >
+    A comprehensive analysis of the stock data including:
+    1. Raw historical data for the last 6 months
+    2. Key statistics (average price, volatility, volume trends)
+    3. Notable patterns or anomalies in the data
+    4. Technical indicators and trends
+    5. Summary of stock performance trends
+
+analyze_company_profile:
+  description: >
+    You are a 'Company Profile Analyst' and use the get_company_profile tool to gather 
+    key company information for {company_name}. Analyze the company's market 
+    capitalization, industry classification, exchange listing, geographic headquarters, 
+    shares outstanding, IPO history, and other corporate fundamentals. Focus on how 
+    these factors influence the company's market position and investment attractiveness.
+  expected_output: >
+    A detailed company profile analysis including:
+    1. Company overview (name, ticker, headquarters country)
+    2. Market metrics (market cap, shares outstanding, currency)
+    3. Exchange and listing information
+    4. Industry classification and sector analysis
+    5. IPO date and company maturity assessment
+    6. Geographic and regulatory environment considerations
+    7. Company size classification (large-cap, mid-cap, etc.)
+    8. Overall corporate profile assessment for investment purposes
+gather_news_sentiment:
+  description: >
+    You are a 'News and Sentiment Analyst' and use the get_stock_news tool to gather 
+    comprehensive company news for {company_name} from the last 30 days. Analyze 
+    the news headlines, summaries, categories, sources, related companies, and publication 
+    frequency to determine market sentiment and identify factors impacting stock performance. 
+    Pay special attention to news categories, source credibility, and any mentions of 
+    related companies that might affect the target stock.
+  expected_output: >
+    A comprehensive news and sentiment analysis including:
+    1. Executive summary of news sentiment (bullish/bearish/neutral)
+    2. Analysis of news frequency and intensity (high/medium/low news coverage)
+    3. Breakdown of news categories and their sentiment implications
+    4. Assessment of source credibility and news quality
+    5. Identification of key catalysts, risks, or market-moving events
+    6. Analysis of related companies/stocks mentioned and their potential impact
+    7. Overall sentiment score (1-10 scale) with directional bias
+    8. Key headlines that could significantly impact stock price
+
+
+make_investment_decision:
+  description: >
+    You are a 'Senior Investment Advisor'. Based on the comprehensive analysis provided
+    by the Stock Information Specialist, Company Profile Analyst, and News Analyst,
+    make a final investment recommendation for {company_name} and how much to invest from {max_amount}. Consider technical
+    analysis, fundamental analysis, and market sentiment to determine whether to BUY,
+    HOLD, or SELL the stock and if BUY then how much to invest from {max_amount}. Provide clear reasoning, risk assessment, and confidence level.
+  expected_output: >
+    A final investment recommendation report including:
+    1. Clear investment decision: BUY/HOLD/SELL
+    2. Recommended investment amount from {max_amount} if BUY
+    3. Detailed reasoning combining all three analyses
+    4. Risk assessment and potential downside
+    5. Expected timeline and price targets
+    6. Confidence level (1-10 scale), Bar chart information
+    7. Alternative scenarios consideration
+    8. Executive summary for quick decision making

crew.py

@@ -0,0 +1,100 @@
+
+# crew.py
+from crewai import Agent, Crew, Process, Task, LLM
+from crewai.project import CrewBase, agent, crew, task
+from dotenv import load_dotenv
+import os
+
+from tools.retrieve_financial_data import retrieve_financial_data
+from tools.company_profile_tool import get_company_profile
+from tools.news_tool import get_stock_news
+
+# Load environment variables
+load_dotenv()
+
+@CrewBase
+class PredictingStock():
+    """PredictingStock crew"""
+
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'
+
+    def __init__(self):
+        self.llm = LLM(
+            model="claude-3-haiku-20240307",
+            api_key=os.getenv("ANTHROPIC_API_KEY")
+        )
+
+    @agent
+    def stock_information_specialist(self) -> Agent:
+        return Agent(
+            config=self.agents_config['stock_information_specialist'],
+            llm=self.llm,
+            tools=[retrieve_financial_data],
+            verbose=True
+        )
+
+    @agent
+    def company_profile_specialist(self) -> Agent:
+        return Agent(
+            config=self.agents_config['company_profile_specialist'],
+            llm=self.llm,
+            tools=[get_company_profile],
+            verbose=True
+        )
+
+    @agent
+    def news_analyst(self) -> Agent:
+        return Agent(
+            config=self.agents_config['news_analyst'],
+            llm=self.llm,
+            tools=[get_stock_news],
+            verbose=True
+        )
+
+    @agent
+    def investment_advisor(self) -> Agent:
+        return Agent(
+            config=self.agents_config['investment_advisor'],
+            llm=self.llm,
+            verbose=True
+        )
+
+    @task
+    def generate_stock_information(self) -> Task:
+        return Task(
+            config=self.tasks_config['generate_stock_information'],
+            agent=self.stock_information_specialist()
+        )
+
+    @task
+    def analyze_company_profile(self) -> Task:
+        return Task(
+            config=self.tasks_config['analyze_company_profile'],
+            agent=self.company_profile_specialist()
+        )
+
+    @task
+    def gather_news_sentiment(self) -> Task:
+        return Task(
+            config=self.tasks_config['gather_news_sentiment'],
+            agent=self.news_analyst()
+        )
+
+    @task
+    def make_investment_decision(self) -> Task:
+        return Task(
+            config=self.tasks_config['make_investment_decision'],
+            agent=self.investment_advisor(),
+            context=[self.generate_stock_information(), self.analyze_company_profile(), self.gather_news_sentiment()]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the PredictingStock crew"""
+        return Crew(
+            agents=self.agents,  # Automatically created by the @agent decorator
+            tasks=self.tasks,    # Automatically created by the @task decorator
+            process=Process.sequential,
+            verbose=True,
+        )

tools/company_profile_tool.py

@@ -0,0 +1,46 @@
+from crewai.tools import tool
+import finnhub
+import os
+import json
+
+@tool("get_company_profile")
+def get_company_profile(company_symbol: str) -> str:
+    """
+    Retrieves company profile information from Finnhub including country, currency, 
+    exchange, industry, IPO date, market cap, name, phone, shares outstanding, 
+    ticker, and website.
+
+    Args:
+    company_symbol: str -> the ticker symbol of the company (e.g., 'AAPL', 'GOOGL')
+    """
+    try:
+        # Initialize Finnhub client
+        finnhub_client = finnhub.Client(api_key=os.getenv("FINNHUB_API_KEY"))
+        
+        # Get company profile
+        profile = finnhub_client.company_profile2(symbol=company_symbol)
+        
+        if not profile:
+            return f"No company profile found for symbol: {company_symbol}"
+        
+        # Format the profile data for better readability
+        formatted_profile = {
+            "Company Name": profile.get("name", "N/A"),
+            "Ticker Symbol": profile.get("ticker", "N/A"),
+            "Country": profile.get("country", "N/A"),
+            "Currency": profile.get("currency", "N/A"),
+            "Exchange": profile.get("exchange", "N/A"),
+            "Industry": profile.get("finnhubIndustry", "N/A"),
+            "IPO Date": profile.get("ipo", "N/A"),
+            "Market Capitalization": f"${profile.get('marketCapitalization', 0):,}" if profile.get('marketCapitalization') else "N/A",
+            "Shares Outstanding": f"{profile.get('shareOutstanding', 0):,}" if profile.get('shareOutstanding') else "N/A",
+            "Phone": profile.get("phone", "N/A"),
+            "Website": profile.get("weburl", "N/A"),
+            "Logo": profile.get("logo", "N/A")
+        }
+        
+        # Convert to JSON string for better formatting
+        return json.dumps(formatted_profile, indent=2)
+        
+    except Exception as e:
+        return f"Error retrieving company profile for {company_symbol}: {str(e)}"

tools/news_tool.py

@@ -0,0 +1,135 @@
+# from crewai.tools import tool
+# from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
+# import json
+
+# @tool("get_stock_news")
+# def get_stock_news(company_ticker: str) -> str:
+#     """
+#     Retrieves the latest news and market sentiment for a given stock ticker 
+#     from Yahoo Finance News.
+
+#     Args:
+#     company_ticker: str -> the ticker symbol of the company (e.g., 'AAPL', 'GOOGL')
+#     """
+#     try:
+#         # Initialize Yahoo Finance News tool
+#         yahoo_news_tool = YahooFinanceNewsTool()
+        
+#         # Get news for the company
+#         news_result = yahoo_news_tool.run(company_ticker)
+        
+#         if not news_result:
+#             return f"No news found for ticker: {company_ticker}"
+        
+#         # If the result is already a string, return it
+#         if isinstance(news_result, str):
+#             return news_result
+        
+#         # If it's a dict or list, format it as JSON
+#         return json.dumps(news_result, indent=2, ensure_ascii=False)
+        
+#     except Exception as e:
+#         return f"Error retrieving news for {company_ticker}: {str(e)}"
+    
+
+from crewai.tools import tool
+import finnhub
+import os
+import json
+from datetime import datetime, timedelta
+
+@tool("get_stock_news")
+def get_stock_news(company_ticker: str) -> str:
+    """
+    Retrieves the latest company news for a given stock ticker from Finnhub.
+    Gets news from the last 30 days to capture recent developments and market sentiment.
+
+    Args:
+    company_ticker: str -> the ticker symbol of the company (e.g., 'AAPL', 'GOOGL')
+    """
+    try:
+        # Initialize Finnhub client
+        finnhub_client = finnhub.Client(api_key=os.getenv("FINNHUB_API_KEY"))
+        
+        # Calculate date range (last 30 days)
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=30)
+        
+        # Format dates as required by Finnhub API
+        from_date = start_date.strftime("%Y-%m-%d")
+        to_date = end_date.strftime("%Y-%m-%d")
+        
+        # Get company news
+        news_data = finnhub_client.company_news(
+            symbol=company_ticker, 
+            _from=from_date, 
+            to=to_date
+        )
+        
+        if not news_data:
+            return f"No recent news found for ticker: {company_ticker} in the last 30 days"
+        
+        # Format the news data using all available Finnhub fields
+        formatted_news = []
+        for article in news_data[:20]:  # Analyze top 15 most recent articles
+            formatted_article = {
+                "id": article.get("id", "unknown"),
+                "headline": article.get("headline", "No headline available"),
+                "summary": article.get("summary", "No summary available"),
+                "category": article.get("category", "General"),
+                "source": article.get("source", "Unknown source"),
+                "url": article.get("url", ""),
+                "image": article.get("image", ""),
+                "datetime": datetime.fromtimestamp(article.get("datetime", 0)).strftime("%Y-%m-%d %H:%M:%S") if article.get("datetime") else "Unknown date",
+                "unix_timestamp": article.get("datetime", 0),
+                "related_stocks": article.get("related", []) if article.get("related") else []
+            }
+            formatted_news.append(formatted_article)
+        
+        # Sort by datetime (most recent first)
+        formatted_news.sort(key=lambda x: x["unix_timestamp"], reverse=True)
+        
+        # Analyze news categories and sources
+        categories = {}
+        sources = {}
+        related_companies = set()
+        
+        for article in formatted_news:
+            # Count categories
+            category = article["category"]
+            categories[category] = categories.get(category, 0) + 1
+            
+            # Count sources
+            source = article["source"]
+            sources[source] = sources.get(source, 0) + 1
+            
+            # Collect related companies/stocks
+            if article["related_stocks"]:
+                related_companies.update(article["related_stocks"])
+        
+        # Create comprehensive news analysis
+        news_analysis = {
+            "company_ticker": company_ticker,
+            "analysis_period": {
+                "from_date": from_date,
+                "to_date": to_date,
+                "days_analyzed": 30
+            },
+            "news_metrics": {
+                "total_articles_found": len(news_data),
+                "articles_analyzed": len(formatted_news),
+                "average_articles_per_day": round(len(news_data) / 30, 2)
+            },
+            "news_breakdown": {
+                "categories": dict(sorted(categories.items(), key=lambda x: x[1], reverse=True)),
+                "top_sources": dict(sorted(sources.items(), key=lambda x: x[1], reverse=True)[:5]),
+                "related_companies_mentioned": list(related_companies)[:10] if related_companies else []
+            },
+            "recent_articles": formatted_news
+        }
+        
+        return json.dumps(news_analysis, indent=2, ensure_ascii=False)
+        
+    except Exception as e:
+        return f"Error retrieving news for {company_ticker}: {str(e)}\nPlease ensure FINNHUB_API_KEY is properly set in .env file"
+

tools/retrieve_financial_data.py

@@ -0,0 +1,30 @@
+from crewai.tools import tool
+import yfinance as yf
+from datetime import datetime, timedelta
+
+@tool("retrieve_financial_data")
+def retrieve_financial_data(company_name: str) -> str:
+    """
+    It returns the last 6 months of daily stock Open, High, Low, Close, Volume, Dividends, Stock Splits for the specified company.
+
+    Args:
+    company_name: str -> the ticker symbol of the company (e.g., 'AAPL', 'GOOGL')
+    """
+    try:
+        # Calculate dates for last 6 months
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=180)  # Approximately 6 months
+        
+        # Get the data
+        ticker = yf.Ticker(company_name)
+        hist = ticker.history(start=start_date.strftime("%Y-%m-%d"), 
+                             end=end_date.strftime("%Y-%m-%d"))
+        
+        if hist.empty:
+            return f"No data found for ticker symbol: {company_name}"
+        
+        # Convert to JSON and return
+        return hist.to_json(date_format='iso', orient='index')
+        
+    except Exception as e:
+        return f"Error retrieving data for {company_name}: {str(e)}"