vv7

app.py

@@ -175,73 +175,250 @@ def run_crewai_process(user_query, model, temperature):
                 with open(temp_script_path, "w") as f:
                     f.write(generated_code)
 
-                # Execute the temporary script using subprocess
-                try:
-                    # Add debug info and ensure plot is saved with absolute path
-                    debug_script = f"""
-import traceback
-import sys
+                # Create a debug script that will be executed in a subprocess
+                debug_script = """
 import os
-import matplotlib
-# Use non-interactive backend to avoid display issues
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-
-# Debug info
-print("="*80)
-print("STARTING SCRIPT EXECUTION")
-print("="*80)
-print(f"[DEBUG] Python version: {{sys.version}}")
-print(f"[DEBUG] Working directory: {{os.getcwd()}}")
-print("[DEBUG] Directory contents:")
-for f in os.listdir('.'):
-    print(f"  - {{f}}{' (dir)' if os.path.isdir(f) else ''}")
-print("\n" + "="*80 + "\n")
+import sys
+import traceback
 
 try:
-    # Create a test plot first to verify matplotlib is working
-    test_fig, test_ax = plt.subplots()
-    test_ax.plot([1, 2, 3], [1, 4, 9])
-    test_ax.set_title('Test Plot - If you see this, matplotlib is working')
-    test_plot_path = 'test_plot.png'
-    test_fig.savefig(test_plot_path, bbox_inches='tight')
-    print(f"[DEBUG] Test plot saved to: {{os.path.abspath(test_plot_path)}}")
-    print(f"[DEBUG] Test plot size: {{os.path.getsize(test_plot_path)}} bytes")
+    print("\n" + "="*80)
+    print("STOCK PLOT GENERATION")
+    print("="*80)
     
-    # Execute the original script
+    # Import the stock plot module
+    try:
+        import stock_plot
+        
+        # Generate the plot using the module
+        plot_path = stock_plot.plot_stock_gain(["META"], "ytd")
+        
+        print("\n" + "="*80)
+        print("PLOT GENERATION COMPLETE")
+        print("="*80)
+        
+        if plot_path and os.path.exists(plot_path):
+            file_size = os.path.getsize(plot_path)
+            print(f"✓ Plot generated successfully: {os.path.abspath(plot_path)}")
+            print(f"✓ File size: {file_size} bytes")
+            
+            # Also check for plot.png in the root directory
+            if os.path.exists('plot.png'):
+                print(f"✓ Main plot.png found: {os.path.abspath('plot.png')}")
+            else:
+                print("ℹ️ plot.png not found in root directory")
+        else:
+            print("❌ Failed to generate plot or plot file not found")
+            
+    except ImportError as e:
+        print(f"❌ Error importing stock_plot module: {e}")
+        print("Make sure the stock_plot.py file exists in the same directory.")
+        raise
+        
     print("\n" + "="*80)
-    print("EXECUTING USER SCRIPT")
+    print("DIRECTORY CONTENTS")
     print("="*80)
-    {generated_code}
     
-    # Ensure any pending plots are drawn
-    plt.ioff()
+    # List all files in the current directory
+    for f in sorted(os.listdir('.')):
+        try:
+            fpath = os.path.join('.', f)
+            if os.path.isfile(fpath):
+                size = os.path.getsize(fpath)
+                print(f"  - {f} ({size} bytes)")
+            else:
+                print(f"  - {f}/ (dir)")
+        except Exception as e:
+            print(f"  - {f} (error: {e})")
+            
+    # Check for generated_plots directory
+    plots_dir = 'generated_plots'
+    if os.path.exists(plots_dir) and os.path.isdir(plots_dir):
+        print(f"\nContents of {plots_dir}/:")
+        try:
+            for f in sorted(os.listdir(plots_dir)):
+                try:
+                    fpath = os.path.join(plots_dir, f)
+                    if os.path.isfile(fpath):
+                        size = os.path.getsize(fpath)
+                        print(f"  - {f} ({size} bytes)")
+                except Exception as e:
+                    print(f"  - {f} (error: {e})")
+        except Exception as e:
+            print(f"  Error reading {plots_dir}: {e}")
+    
+except Exception as e:
+    print(f"\n❌ UNEXPECTED ERROR: {str(e)}")
+    print("\nTraceback:")
+    traceback.print_exc()
+    sys.exit(1)
+"""
+    
+    # Create a simple test plot
+    try:
+        # Create a new figure with a larger size
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        # Generate some sample data
+        x = [1, 2, 3, 4, 5]
+        y = [1, 4, 9, 16, 25]
+        
+        # Create the plot
+        ax.plot(x, y, 'b-', linewidth=2, label='Sample Data')
+        
+        # Add labels and title
+        ax.set_title('Test Plot - Matplotlib Verification', fontsize=14)
+        ax.set_xlabel('X Axis', fontsize=12)
+        ax.set_ylabel('Y Axis', fontsize=12)
+        
+        # Add grid and legend
+        ax.grid(True, linestyle='--', alpha=0.7)
+        ax.legend(fontsize=10)
+        
+        # Adjust layout to prevent label cutoff
+        plt.tight_layout()
+        
+        # Save the test plot
+        test_plot_path = 'test_plot.png'
+        fig.savefig(test_plot_path, dpi=120, bbox_inches='tight')
+        print(f"✓ Test plot saved to: {os.path.abspath(test_plot_path)}")
+        
+        # Close the figure to free memory
+        plt.close(fig)
+        
+    except Exception as e:
+        print(f"❌ Error creating test plot: {e}")
+        print("Traceback:")
+        traceback.print_exc()
+    
+    # Save with different formats and verify
+    test_formats = [
+        ('test_plot.png', 'PNG'),
+        ('test_plot.jpg', 'JPEG'),
+        ('test_plot.pdf', 'PDF')
+    ]
     
-    # Save any open figures
+    for filename, fmt in test_formats:
+        try:
+            test_fig.savefig(filename, bbox_inches='tight', dpi=100)
+            abs_path = os.path.abspath(filename)
+            file_size = os.path.getsize(filename)
+            print(f"✓ Saved {{fmt}} to: {{abs_path}} ({{file_size}} bytes)")
+            
+            # Verify file is not empty
+            if file_size == 0:
+                print(f"  ✗ WARNING: {{fmt}} file is empty!")
+            elif file_size < 1024:  # Very small file might be corrupted
+                print(f"  ⚠ WARNING: {{fmt}} file is unusually small ({{file_size}} bytes)")
+                
+        except Exception as e:
+            print(f"✗ Failed to save {{fmt}}: {{str(e)}}")
+    
+    # Clean up
+    plt.close(test_fig)
+    
+    # Test 2: Verify file system access
     print("\n" + "="*80)
-    print("SAVING PLOTS")
+    print("TEST 2: FILE SYSTEM VERIFICATION")
     print("="*80)
     
-    # Get list of all figure numbers
-    fig_nums = plt.get_fignums()
-    print(f"[DEBUG] Found {{len(fig_nums)}} open figures")
+    # Check if files were created
+    for filename, _ in test_formats:
+        if os.path.exists(filename):
+            try:
+                file_size = os.path.getsize(filename)
+                print(f"✓ Found {{filename}} ({{file_size}} bytes)")
+                # Try to read the file
+                with open(filename, 'rb') as f:
+                    header = f.read(4)
+                    print(f"  File header: {{header[:20].hex()}}...")
+            except Exception as e:
+                print(f"✗ Error reading {{filename}}: {{str(e)}}")
+        else:
+            print(f"✗ File not found: {{filename}}")
+    
+    # Execute the original script with error handling
+    print("\n" + "="*80)
+    print("EXECUTING USER SCRIPT")
+    print("="*80)
     
-    if fig_nums:
-        # Save the last figure as plot.png
-        last_fig = plt.figure(fig_nums[-1])
-        plot_path = os.path.abspath('plot.png')
-        last_fig.savefig(plot_path, bbox_inches='tight', dpi=100)
-        print(f"[DEBUG] Saved plot to: {{plot_path}}")
-        print(f"[DEBUG] Plot file size: {{os.path.getsize(plot_path)}} bytes")
+    # Create a safe execution environment
+    try:
+        # Execute the user's code
+        exec_globals = {{'plt': plt, 'pd': __import__('pandas')}}
+        exec_globals.update({{'__builtins__': __builtins__}})
+        
+        # Execute in a separate namespace to avoid polluting globals
+        user_namespace = {{}}
+        user_code = compile(
+            {generated_code!r}.lstrip('\n').lstrip(' '),
+            '<user_code>', 'exec',
+            dont_inherit=True,
+            optimize=2
+        )
+        exec(user_code, user_namespace, user_namespace)
         
-        # Save all figures with unique names
-        for i, num in enumerate(fig_nums, 1):
-            fig = plt.figure(num)
-            fig_path = os.path.abspath(f'plot_{{i}}.png')
-            fig.savefig(fig_path, bbox_inches='tight', dpi=100)
-            print(f"[DEBUG] Saved additional plot to: {{fig_path}} ({{os.path.getsize(fig_path)}} bytes)")
-    else:
-        print("[WARNING] No figures were created in the script")
+        # Ensure any pending plots are drawn
+        plt.ioff()
+        
+        # Save any open figures
+        print("\n" + "="*80)
+        print("SAVING PLOTS")
+        print("="*80)
+        
+        # Get list of all figure numbers
+        fig_nums = plt.get_fignums()
+        print(f"Found {{len(fig_nums)}} open figures")
+        
+        if fig_nums:
+            # Create plots directory if it doesn't exist
+            plots_dir = 'generated_plots'
+            os.makedirs(plots_dir, exist_ok=True)
+            
+            # Save all figures with unique names
+            saved_plots = []
+            for i, num in enumerate(fig_nums, 1):
+                try:
+                    fig = plt.figure(num)
+                    plot_name = f'plot_{{i}}.png'
+                    plot_path = os.path.abspath(os.path.join(plots_dir, plot_name))
+                    
+                    # Save with high DPI and tight layout
+                    fig.savefig(
+                        plot_path,
+                        bbox_inches='tight',
+                        dpi=150,
+                        facecolor=fig.get_facecolor(),
+                        edgecolor='none',
+                        transparent=False
+                    )
+                    
+                    file_size = os.path.getsize(plot_path)
+                    print(f"✓ Saved plot {{i}} to: {{plot_path}} ({{file_size}} bytes)")
+                    saved_plots.append(plot_path)
+                    
+                    # If this is the last figure, also save as plot.png in root
+                    if i == len(fig_nums):
+                        root_plot_path = os.path.abspath('plot.png')
+                        fig.savefig(root_plot_path, bbox_inches='tight', dpi=150)
+                        print(f"✓ Saved main plot to: {{root_plot_path}}")
+                        saved_plots.append(root_plot_path)
+                    
+                except Exception as e:
+                    print(f"✗ Error saving figure {{num}}: {{str(e)}}")
+            
+            if saved_plots:
+                generated_plot_path = saved_plots[-1]  # Use the last saved plot as the main plot
+                print(f"\nSuccessfully saved {{len(saved_plots)}} plot(s)")
+            
+        else:
+            print("ℹ️ No figures were created by the user script")
+            
+    except Exception as e:
+        print(f"\n❌ Error executing user script: {{str(e)}}")
+        print("\nTraceback:")
+        traceback.print_exc()
+        raise
     
     # Print final directory contents
     print("\n" + "="*80)

stock_plot.py

@@ -0,0 +1,157 @@
+"""
+Stock Plot Generation Script
+
+This script generates stock gain plots using yfinance and matplotlib.
+It includes robust error handling and debugging information.
+"""
+
+import os
+import sys
+import traceback
+import platform
+from datetime import datetime
+
+# Configure matplotlib before importing pyplot
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend
+import matplotlib.pyplot as plt
+import pandas as pd
+import yfinance as yf
+
+
+def setup_environment():
+    """Print environment information and verify dependencies."""
+    print("\n" + "=" * 80)
+    print("ENVIRONMENT INFORMATION")
+    print("=" * 80)
+    print(f"Python: {sys.version}")
+    print(f"Platform: {platform.platform()}")
+    print(f"Current directory: {os.getcwd()}")
+    print(f"Python executable: {sys.executable}")
+    print(f"Current time: {datetime.now().isoformat()}")
+    
+    # Verify required packages
+    print("\nChecking dependencies:")
+    for pkg in [('pandas', pd), ('matplotlib', matplotlib), ('yfinance', yf)]:
+        try:
+            print(f"  ✓ {pkg[0]}: {pkg[1].__version__}")
+        except Exception as e:
+            print(f"  ✗ {pkg[0]}: Not available ({e})")
+
+
+def plot_stock_gain(symbols, timeframe="3mo"):
+    """
+    Generate and save stock gain plots.
+    
+    Args:
+        symbols: List of stock symbols or a single symbol string
+        timeframe: Time period to fetch data for (e.g., '1mo', '3mo', '1y')
+        
+    Returns:
+        str: Path to the saved plot file, or None if failed
+    """
+    # Convert single symbol to list
+    if isinstance(symbols, str):
+        symbols = [symbols]
+    
+    print(f"\nProcessing symbols: {', '.join(symbols)} for timeframe: {timeframe}")
+    
+    # Create output directory if it doesn't exist
+    output_dir = 'generated_plots'
+    os.makedirs(output_dir, exist_ok=True)
+    
+    plot_paths = []
+    
+    for symbol in symbols:
+        try:
+            print(f"\n{'='*40}")
+            print(f"Processing: {symbol}")
+            print(f"{'='*40}")
+            
+            # Download stock data
+            print(f"Downloading {timeframe} data for {symbol}...")
+            ticker = yf.Ticker(symbol)
+            stock_data = ticker.history(period=timeframe)
+            
+            if stock_data.empty:
+                print(f"⚠ No data found for {symbol}")
+                continue
+                
+            print(f"Retrieved {len(stock_data)} data points from {stock_data.index[0].date()} to {stock_data.index[-1].date()}")
+            
+            # Calculate percentage gain
+            stock_data['Gain'] = stock_data['Close'].pct_change().fillna(0).cumsum()
+            
+            # Create plot
+            plt.figure(figsize=(12, 6))
+            plt.plot(stock_data.index, stock_data['Gain'], 
+                   linewidth=2, 
+                   label=f'{symbol} Gain')
+            
+            # Format plot
+            plt.title(f'{symbol} Cumulative Gain - {timeframe.upper()}', fontsize=14)
+            plt.xlabel('Date', fontsize=12)
+            plt.ylabel('Cumulative Gain', fontsize=12)
+            plt.legend()
+            plt.grid(True, linestyle='--', alpha=0.7)
+            plt.tight_layout()
+            
+            # Save plot
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            plot_filename = f"{symbol}_{timeframe}_{timestamp}.png"
+            plot_path = os.path.join(output_dir, plot_filename)
+            
+            plt.savefig(plot_path, dpi=120, bbox_inches='tight')
+            plt.close()  # Close the figure to free memory
+            
+            # Verify the file was created
+            if os.path.exists(plot_path):
+                file_size = os.path.getsize(plot_path)
+                print(f"✓ Plot saved: {plot_path} ({file_size} bytes)")
+                plot_paths.append(plot_path)
+                
+                # Also save as plot.png in root for compatibility
+                if symbol == symbols[-1]:  # Only for the last symbol
+                    main_plot_path = 'plot.png'
+                    plt.figure(plt.get_fignums()[-1])  # Get the last figure
+                    plt.savefig(main_plot_path, dpi=120, bbox_inches='tight')
+                    print(f"✓ Main plot saved as: {os.path.abspath(main_plot_path)}")
+            else:
+                print("❌ Failed to save plot")
+                
+        except Exception as e:
+            print(f"❌ Error processing {symbol}: {str(e)}")
+            print("Traceback:")
+            traceback.print_exc()
+    
+    return plot_paths[0] if plot_paths else None
+
+
+def main():
+    """Main execution function."""
+    try:
+        setup_environment()
+        
+        # Default symbols and timeframe
+        symbols = ["META"]
+        timeframe = "ytd"
+        
+        # Generate plots
+        plot_path = plot_stock_gain(symbols, timeframe)
+        
+        if plot_path:
+            print(f"\n✅ Successfully generated plot: {os.path.abspath(plot_path)}")
+            return 0
+        else:
+            print("\n❌ Failed to generate any plots")
+            return 1
+            
+    except Exception as e:
+        print(f"\n❌ Fatal error: {str(e)}")
+        print("Traceback:")
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())