# package_app.py

"""
This script demonstrates how to package your value investing AI agent
as a standalone executable application using PyInstaller.
"""

# First, install PyInstaller if you haven't already:
# pip install pyinstaller

# Assuming you have a Streamlit app (from Step 7) in streamlit_app.py
# Here's how to package it as a standalone application

import os
import subprocess
import sys
import shutil

def create_spec_file():
    """Create a PyInstaller spec file for the application."""
    spec_content = """
# -*- mode: python ; coding: utf-8 -*-

block_cipher = None

a = Analysis(
    ['streamlit_app.py'],
    pathex=[],
    binaries=[],
    datas=[],
    hiddenimports=['yfinance', 'pandas', 'numpy', 'matplotlib', 'plotly', 'streamlit'],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher,
    noarchive=False,
)

# Add data files (like images, CSS, etc.)
a.datas += [('icon.png', 'icon.png', 'DATA')]

pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)

exe = EXE(
    pyz,
    a.scripts,
    [],
    exclude_binaries=True,
    name='ValueInvestingAI',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    console=True,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
    icon='icon.ico',
)

coll = COLLECT(
    exe,
    a.binaries,
    a.zipfiles,
    a.datas,
    strip=False,
    upx=True,
    upx_exclude=[],
    name='ValueInvestingAI',
)
    """
    
    with open('value_investing_ai.spec', 'w') as f:
        f.write(spec_content)
    
    print("Created PyInstaller spec file: value_investing_ai.spec")

def create_launcher_script():
    """Create a launcher script that will start Streamlit."""
    launcher_content = """
import os
import subprocess
import sys

if __name__ == "__main__":
    # Get the directory where the executable is located
    if getattr(sys, 'frozen', False):
        # Running as compiled executable
        app_dir = os.path.dirname(sys.executable)
    else:
        # Running as script
        app_dir = os.path.dirname(os.path.abspath(__file__))
    
    # Change to the app directory
    os.chdir(app_dir)
    
    # Launch Streamlit
    subprocess.run([
        sys.executable, 
        "-m", 
        "streamlit", 
        "run", 
        "streamlit_app.py",
        "--browser.serverAddress", 
        "localhost",
        "--server.port", 
        "8501"
    ])
    """
    
    with open('streamlit_launcher.py', 'w') as f:
        f.write(launcher_content)
    
    print("Created Streamlit launcher script: streamlit_launcher.py")

def create_readme():
    """Create a README file with instructions."""
    readme_content = """
# Value Investing AI Agent

This is a standalone application for analyzing stocks using value investing principles.

## How to Use

1. Double-click the "ValueInvestingAI" executable to start the application
2. A command window will open, followed by your default web browser
3. If the browser doesn't open automatically, navigate to http://localhost:8501
4. Use the interface to analyze stocks, compare companies, and manage your portfolio
5. To close the application, close the browser and the command window

## Features

- Single stock analysis based on value investing principles
- Multi-stock comparison
- Portfolio analysis and optimization
- Historical performance tracking

## Troubleshooting

If you encounter any issues:
- Make sure you have an active internet connection
- Check that no other application is using port 8501
- Try restarting the application
- Ensure your firewall isn't blocking the application

## Updates

This is version 1.0.0. Check [our website] for updates and new versions.
    """
    
    with open('README.txt', 'w') as f:
        f.write(readme_content)
    
    print("Created README file: README.txt")

def package_application():
    """Package the application using PyInstaller."""
    try:
        # Create a simple icon file if it doesn't exist
        if not os.path.exists('icon.ico'):
            print("Note: No icon.ico file found. Using default icon.")
        
        # Run PyInstaller
        subprocess.run([
            'pyinstaller',
            'value_investing_ai.spec',
            '--clean'
        ], check=True)
        
        print("\nApplication packaged successfully!")
        print("You can find the executable in the 'dist/ValueInvestingAI' directory.")
        
        # Copy the README to the dist directory
        shutil.copy('README.txt', 'dist/ValueInvestingAI/')
        
    except subprocess.CalledProcessError as e:
        print(f"Error packaging application: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")

def main():
    """Main function to package the application."""
    print("Packaging Value Investing AI Agent as a standalone application...")
    
    # Check if streamlit_app.py exists
    if not os.path.exists('streamlit_app.py'):
        print("Error: streamlit_app.py not found in the current directory.")
        print("Please make sure your Streamlit application is named 'streamlit_app.py'.")
        return
    
    # Create necessary files
    create_spec_file()
    create_launcher_script()
    create_readme()
    
    # Package the application
    package_application()
    
    print("\nDeployment package created successfully!")
    print("To distribute your application:")
    print("1. Zip the 'dist/ValueInvestingAI' directory")
    print("2. Share the zip file with your users")
    print("3. Users can extract the zip and run the 'ValueInvestingAI' executable")

if __name__ == "__main__":
    main()

# Files needed for Heroku deployment

# 1. requirements.txt - List all dependencies
"""
streamlit==1.22.0
pandas==1.5.3
numpy==1.24.3
matplotlib==3.7.1
plotly==5.14.1
yfinance==0.2.18
scikit-learn==1.2.2
"""

# 2. Procfile - Tell Heroku how to run your app
"""
web: streamlit run streamlit_app.py --server.port $PORT
"""

# 3. runtime.txt - Specify Python version
"""
python-3.10.11
"""

# 4. setup.sh - Configure Streamlit
"""
mkdir -p ~/.streamlit/

echo "\
[general]\n\
email = \"your-email@example.com\"\n\
" > ~/.streamlit/credentials.toml

echo "\
[server]\n\
headless = true\n\
enableCORS = false\n\
port = $PORT\n\
" > ~/.streamlit/config.toml
"""

# 5. Deploy to Heroku - Commands to run in terminal
"""
# Install Heroku CLI if you haven't already
# https://devcenter.heroku.com/articles/heroku-cli

# Login to Heroku
heroku login

# Create a new Heroku app
heroku create value-investing-ai

# Initialize git repository if not already done
git init
git add .
git commit -m "Initial commit"

# Set remote repository
heroku git:remote -a value-investing-ai

# Push to Heroku
git push heroku master

# Open the app in browser
heroku open
"""

# 6. Schedule regular updates (optional) - Create a scheduler.py file
"""
import os
import requests
import schedule
import time
import logging

# Set up logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.FileHandler("scheduler.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

def ping_app():
    """Ping the app to keep it awake."""
    try:
        url = "https://value-investing-ai.herokuapp.com/"
        response = requests.get(url)
        logger.info(f"Pinged app, status code: {response.status_code}")
    except Exception as e:
        logger.error(f"Error pinging app: {e}")

def update_data():
    """Trigger data update in the app."""
    try:
        url = "https://value-investing-ai.herokuapp.com/update_data"
        response = requests.get(url)
        logger.info(f"Updated data, status code: {response.status_code}")
    except Exception as e:
        logger.error(f"Error updating data: {e}")

def main():
    """Schedule regular tasks."""
    # Ping the app every 20 minutes to prevent it from sleeping
    schedule.every(20).minutes.do(ping_app)
    
    # Update financial data once per day (after market close)
    schedule.every().day.at("18:00").do(update_data)
    
    logger.info("Scheduler started")
    
    while True:
        schedule.run_pending()
        time.sleep(60)

if __name__ == "__main__":
    main()
"""

# 7. Add update_data endpoint to streamlit_app.py
"""
# Add this to your streamlit_app.py file

import time
import threading
import streamlit as st

# Global variable to track last update time
last_update_time = time.time()
update_lock = threading.Lock()

def update_financial_data():
    """Update all financial data in the background."""
    global last_update_time
    
    with update_lock:
        # Check if update was done recently (within last hour)
        if time.time() - last_update_time < 3600:
            return "Data was updated recently. Skipping update."
        
        # Perform data update
        # This would call your data fetching functions
        # For example:
        # update_stock_data()
        # update_market_data()
        # etc.
        
        # Update the last update time
        last_update_time = time.time()
        
        return "Data updated successfully."

# Add a route for data updates
# This is a bit of a hack since Streamlit doesn't support proper API endpoints
# We'll use query parameters to trigger updates
if "update_data" in st.experimental_get_query_params():
    update_result = update_financial_data()
    st.write(update_result)
    # Exit early to avoid rendering the rest of the app
    st.stop()
"""

# Dockerfile for Flask + React application

# Backend Dockerfile (in backend directory)
"""
FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]
"""

# Frontend Dockerfile (in frontend directory)
"""
FROM node:16-alpine as build

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]
"""

# nginx.conf for frontend
"""
server {
    listen 80;
    
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
        try_files $uri $uri/ /index.html;
    }
    
    location /api {
        proxy_pass http://backend:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
"""

# docker-compose.yml (in root directory)
"""
version: '3'

services:
  backend:
    build: ./backend
    container_name: value-investing-backend
    restart: always
    environment:
      - FLASK_ENV=production
    volumes:
      - ./backend:/app
    networks:
      - app-network

  frontend:
    build: ./frontend
    container_name: value-investing-frontend
    restart: always
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network

networks:
  app-network:
    driver: bridge
"""

# Deployment commands
"""
# Build and start the containers
docker-compose up -d --build

# View logs
docker-compose logs -f

# Stop the containers
docker-compose down
"""

# AWS Elastic Beanstalk deployment
"""
# Install EB CLI
pip install awsebcli

# Initialize EB application
eb init -p docker value-investing-app

# Create environment
eb create value-investing-production

# Deploy
eb deploy

# Open in browser
eb open
"""

# maintenance.py

"""
Automated maintenance script for a value investing AI agent.
This script performs regular maintenance tasks to keep your agent running smoothly.
"""

import os
import sys
import logging
import datetime
import subprocess
import requests
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import json
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Set up logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("maintenance.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger("maintenance")

class MaintenanceManager:
    """Manager for automated maintenance tasks."""
    
    def __init__(self, config_file="maintenance_config.json"):
        """Initialize the maintenance manager."""
        self.config = self.load_config(config_file)
        self.today = datetime.datetime.now().strftime("%Y-%m-%d")
        self.report_data = {
            "date": self.today,
            "tasks_completed": [],
            "tasks_failed": [],
            "warnings": [],
            "recommendations": []
        }
    
    def load_config(self, config_file):
        """Load configuration from JSON file."""
        try:
            if os.path.exists(config_file):
                with open(config_file, 'r') as f:
                    return json.load(f)
            else:
                logger.warning(f"Config file {config_file} not found. Using default configuration.")
                return {
                    "data_update": {
                        "enabled": True,
                        "api_keys": {}
                    },
                    "performance_tracking": {
                        "enabled": True,
                        "benchmark": "SPY"
                    },
                    "dependency_updates": {
                        "enabled": True,
                        "auto_update": False
                    },
                    "backup": {
                        "enabled": True,
                        "backup_dir": "./backups"
                    },
                    "notifications": {
                        "enabled": False,
                        "email": {
                            "smtp_server": "",
                            "port": 587,
                            "username": "",
                            "password": "",
                            "from_email": "",
                            "to_email": ""
                        }
                    }
                }
        except Exception as e:
            logger.error(f"Error loading config: {e}")
            sys.exit(1)
    
    def update_financial_data(self):
        """Update financial data from APIs."""
        try:
            logger.info("Updating financial data...")
            
            # This would call your data fetching functions
            # For example:
            # update_stock_data()
            # update_market_data()
            
            # Simulate successful update
            logger.info("Financial data updated successfully.")
            self.report_data["tasks_completed"].append("Financial data update")
            return True
        except Exception as e:
            logger.error(f"Error updating financial data: {e}")
            self.report_data["tasks_failed"].append("Financial data update")
            self.report_data["warnings"].append(f"Financial data update failed: {e}")
            return False
    
    def check_api_health(self):
        """Check the health of financial data APIs."""
        try:
            logger.info("Checking API health...")
            
            # List of APIs to check
            apis = [
                {"name": "Yahoo Finance", "url": "https://query1.finance.yahoo.com/v8/finance/chart/AAPL"},
                {"name": "Alpha Vantage", "url": "https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=AAPL&apikey=demo"}
            ]
            
            all_healthy = True
            
            for api in apis:
                try:
                    response = requests.get(api["url"], timeout=10)
                    if response.status_code == 200:
                        logger.info(f"{api['name']} API is healthy.")
                    else:
                        logger.warning(f"{api['name']} API returned status code {response.status_code}.")
                        self.report_data["warnings"].append(f"{api['name']} API may be experiencing issues (status code {response.status_code}).")
                        all_healthy = False
                except Exception as e:
                    logger.error(f"Error checking {api['name']} API: {e}")
                    self.report_data["warnings"].append(f"{api['name']} API is unreachable: {e}")
                    all_healthy = False
            
            if all_healthy:
                self.report_data["tasks_completed"].append("API health check")
            else:
                self.report_data["tasks_completed"].append("API health check (with warnings)")
            
            return all_healthy
        except Exception as e:
            logger.error(f"Error checking API health: {e}")
            self.report_data["tasks_failed"].append("API health check")
            return False
    
    def track_performance(self):
        """Track the performance of investment recommendations."""
        try:
            if not self.config["performance_tracking"]["enabled"]:
                logger.info("Performance tracking disabled in config.")
                return True
            
            logger.info("Tracking investment performance...")
            
            # This would load your agent's past recommendations and track their performance
            # For example:
            # recommendations = load_past_recommendations()
            # performance = calculate_performance(recommendations)
            
            # Simulate performance tracking
            # In a real implementation, you would calculate actual returns
            
            # Create a sample performance chart
            dates = pd.date_range(end=pd.Timestamp.today(), periods=30)
            portfolio_values = 100 * (1 + np.cumsum(np.random.normal(0.001, 0.01, 30)))
            benchmark_values = 100 * (1 + np.cumsum(np.random.normal(0.0005, 0.01, 30)))
            
            plt.figure(figsize=(10, 6))
            plt.plot(dates, portfolio_values, label="Portfolio")
            plt.plot(dates, benchmark_values, label=self.config["performance_tracking"]["benchmark"])
            plt.title("Investment Performance")
            plt.xlabel("Date")
            plt.ylabel("Value")
            plt.legend()
            plt.grid(True)
            
            # Save the chart
            performance_dir = "./performance"
            os.makedirs(performance_dir, exist_ok=True)
            chart_path = f"{performance_dir}/performance_{self.today}.png"
            plt.savefig(chart_path)
            plt.close()
            
            logger.info(f"Performance chart saved to {chart_path}")
            self.report_data["tasks_completed"].append("Performance tracking")
            
            # Add performance insights to the report
            portfolio_return = (portfolio_values[-1] / portfolio_values[0] - 1) * 100
            benchmark_return = (benchmark_values[-1] / benchmark_values[0] - 1) * 100
            
            self.report_data["recommendations"].append(
                f"Portfolio performance: {portfolio_return:.2f}% vs {benchmark_return:.2f}% ({self.config['performance_tracking']['benchmark']})"
            )
            
            if portfolio_return < benchmark_return:
                self.report_data["recommendations"].append(
                    "Consider reviewing your value investing criteria as performance is below benchmark."
                )
            
            return True
        except Exception as e:
            logger.error(f"Error tracking performance: {e}")
            self.report_data["tasks_failed"].append("Performance tracking")
            return False
    
    def check_dependencies(self):
        """Check for updates to dependencies."""
        try:
            if not self.config["dependency_updates"]["enabled"]:
                logger.info("Dependency updates disabled in config.")
                return True
            
            logger.info("Checking for dependency updates...")
            
            # Get list of outdated packages
            result = subprocess.run(
                [sys.executable, "-m", "pip", "list", "--outdated", "--format=json"],
                capture_output=True,
                text=True
            )
            
            if result.returncode != 0:
                logger.error(f"Error checking dependencies: {result.stderr}")
                self.report_data["tasks_failed"].append("Dependency check")
                return False
            
            outdated = json.loads(result.stdout)
            
            if not outdated:
                logger.info("All dependencies are up to date.")
                self.report_data["tasks_completed"].append("Dependency check")
                return True
            
            # Log outdated packages
            logger.info(f"Found {len(outdated)} outdated packages:")
            for package in outdated:
                logger.info(f"  {package['name']} {package['version']} -> {package['latest_version']}")
            
            self.report_data["tasks_completed"].append("Dependency check")
            self.report_data["recommendations"].append(
                f"Update {len(outdated)} outdated packages: " + 
                ", ".join([f"{p['name']} ({p['version']} -> {p['latest_version']})" for p in outdated[:3]]) +
                (f" and {len(outdated) - 3} more" if len(outdated) > 3 else "")
            )
            
            # Auto-update if configured
            if self.config["dependency_updates"]["auto_update"]:
                logger.info("Auto-updating dependencies...")
                
                for package in outdated:
                    try:
                        subprocess.run(
                            [sys.executable, "-m", "pip", "install", "--upgrade", package["name"]],
                            check=True
                        )
                        logger.info(f"Updated {package['name']} to {package['latest_version']}")
                    except subprocess.CalledProcessError as e:
                        logger.error(f"Error updating {package['name']}: {e}")
                
                logger.info("Dependency updates completed.")
                self.report_data["tasks_completed"].append("Dependency updates")
            
            return True
        except Exception as e:
            logger.error(f"Error checking dependencies: {e}")
            self.report_data["tasks_failed"].append("Dependency check")
            return False
    
    def create_backup(self):
        """Create a backup of the application and data."""
        try:
            if not self.config["backup"]["enabled"]:
                logger.info("Backups disabled in config.")
                return True
            
            logger.info("Creating backup...")
            
            # Create backup directory if it doesn't exist
            backup_dir = self.config["backup"]["backup_dir"]
            os.makedirs(backup_dir, exist_ok=True)
            
            # Create a timestamped backup directory
            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            backup_path = os.path.join(backup_dir, f"backup_{timestamp}")
            os.makedirs(backup_path, exist_ok=True)
            
            # Backup code
            # In a real implementation, you might use git or copy specific directories
            # For this example, we'll just create a placeholder
            with open(os.path.join(backup_path, "backup_info.txt"), "w") as f:
                f.write(f"Backup created on {self.today}\n")
                f.write("This is a placeholder for a real backup process.\n")
            
            logger.info(f"Backup created at {backup_path}")
            self.report_data["tasks_completed"].append("Backup creation")
            
            # Clean up old backups (keep last 5)
            backups = sorted([
                os.path.join(backup_dir, d) for d in os.listdir(backup_dir)
                if os.path.isdir(os.path.join(backup_dir, d)) and d.startswith("backup_")
            ])
            
            if len(backups) > 5:
                for old_backup in backups[:-5]:
                    logger.info(f"Removing old backup: {old_backup}")
                    # In a real implementation, you would use shutil.rmtree(old_backup)
                    # For this example, we'll just log it
            
            return True
        except Exception as e:
            logger.error(f"Error creating backup: {e}")
            self.report_data["tasks_failed"].append("Backup creation")
            return False
    
    def send_report(self):
        """Send a maintenance report via email."""
        try:
            if not self.config["notifications"]["enabled"]:
                logger.info("Notifications disabled in config.")
                return True
            
            logger.info("Sending maintenance report...")
            
            # Create report content
            report = f"""
            
            
                
            
            
                
Value Investing AI Agent - Maintenance Report
                
Date: {self.report_data['date']}
                
                
Tasks Completed
                

                    {"".join([f"
{task}
" for task in self.report_data['tasks_completed']])}
                
                
                
Tasks Failed
                

                    {"".join([f"
{task}
" for task in self.report_data['tasks_failed']])}
                
                
                
Warnings
                

                    {"".join([f"
{warning}
" for warning in self.report_data['warnings']])}
                
                
                
Recommendations
                

                    {"".join([f"
{rec}
" for rec in self.report_data['recommendations']])}
                
            
            
            """
            
            # Save report to file
            report_path = f"maintenance_report_{self.today}.html"
            with open(report_path, "w") as f:
                f.write(report)
            
            logger.info(f"Report saved to {report_path}")
            
            # Send email if configured
            email_config = self.config["notifications"]["email"]
            if all([email_config["smtp_server"], email_config["username"], 
                    email_config["password"], email_config["from_email"], 
                    email_config["to_email"]]):
                
                msg = MIMEMultipart()
                msg["From"] = email_config["from_email"]
                msg["To"] = email_config["to_email"]
                msg["Subject"] = f"Value Investing AI - Maintenance Report {self.today}"
                
                msg.attach(MIMEText(report, "html"))
                
                with smtplib.SMTP(email_config["smtp_server"], email_config["port"]) as server:
                    server.starttls()
                    server.login(email_config["username"], email_config["password"])
                    server.send_message(msg)
                
                logger.info(f"Report sent to {email_config['to_email']}")
            
            return True
        except Exception as e:
            logger.error(f"Error sending report: {e}")
            return False
    
    def run_maintenance(self):
        """Run all maintenance tasks."""
        logger.info("Starting maintenance tasks...")
        
        # Run tasks
        self.update_financial_data()
        self.check_api_health()
        self.track_performance()
        self.check_dependencies()
        self.create_backup()
        
        # Send report
        self.send_report()
        
        logger.info("Maintenance completed.")
        
        # Return success if no tasks failed
        return len(self.report_data["tasks_failed"]) == 0

if __name__ == "__main__":
    manager = MaintenanceManager()
    success = manager.run_maintenance()
    sys.exit(0 if success else 1)