Update app.py

app.py

@@ -1,419 +1,229 @@
 import gradio as gr
-import MetaTrader5 as mt5
-import pandas as pd
-from datetime import datetime
-from smolagents import CodeAgent, HfApiModel, tool
-import json
-from typing import Dict, List, Optional
+from smolagents import CodeAgent, InferenceClientModel, Tool
+import os
+from PIL import Image
+import tempfile
+import base64
+from io import BytesIO
 
-# Custom MetaTrader Tools
-@tool
-def connect_mt5(login: int, password: str, server: str) -> str:
-    """
-    Connect to MetaTrader 5 terminal
-    
-    Args:
-        login: MT5 account login number
-        password: MT5 account password  
-        server: MT5 server name
-    
-    Returns:
-        Connection status message
-    """
-    try:
-        if not mt5.initialize():
-            return f"Failed to initialize MT5: {mt5.last_error()}"
-        
-        if not mt5.login(login, password=password, server=server):
-            return f"Failed to connect to account {login}: {mt5.last_error()}"
-            
-        return f"Successfully connected to MT5 account {login}"
-    except Exception as e:
-        return f"Error connecting to MT5: {str(e)}"
+# Initialize the image generation tool
+image_generation_tool = Tool.from_space(
+    "black-forest-labs/FLUX.1-schnell",
+    name="image_generator",
+    description="Generate an image from a prompt"
+)
 
-@tool
-def get_account_info() -> str:
-    """
-    Get MetaTrader 5 account information
-    
-    Returns:
-        Account information as formatted string
-    """
-    try:
-        account_info = mt5.account_info()
-        if account_info is None:
-            return "Failed to get account info. Please ensure you're connected to MT5."
-        
-        info_dict = account_info._asdict()
-        formatted_info = "=== ACCOUNT INFORMATION ===\n"
-        formatted_info += f"Login: {info_dict['login']}\n"
-        formatted_info += f"Server: {info_dict['server']}\n"
-        formatted_info += f"Name: {info_dict['name']}\n"
-        formatted_info += f"Company: {info_dict['company']}\n"
-        formatted_info += f"Currency: {info_dict['currency']}\n"
-        formatted_info += f"Balance: {info_dict['balance']:.2f}\n"
-        formatted_info += f"Equity: {info_dict['equity']:.2f}\n"
-        formatted_info += f"Margin: {info_dict['margin']:.2f}\n"
-        formatted_info += f"Free Margin: {info_dict['margin_free']:.2f}\n"
-        formatted_info += f"Margin Level: {info_dict['margin_level']:.2f}%\n"
-        formatted_info += f"Profit: {info_dict['profit']:.2f}\n"
-        
-        return formatted_info
-    except Exception as e:
-        return f"Error getting account info: {str(e)}"
+# Initialize the model and agent
+model = InferenceClientModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+agent = CodeAgent(tools=[image_generation_tool], model=model)
 
-@tool
-def get_closed_trades(days_back: int = 30) -> str:
+def process_message(message, history):
     """
-    Get closed trades from MetaTrader 5
+    Process user message with the SmolagentsAI agent
     
     Args:
-        days_back: Number of days to look back for trades (default: 30)
+        message: User input message
+        history: Chat history
     
     Returns:
-        Formatted string of closed trades
+        Updated chat history
     """
     try:
-        from datetime import datetime, timedelta
-        
-        # Calculate date range
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=days_back)
-        
-        # Get deals (closed trades)
-        deals = mt5.history_deals_get(start_date, end_date)
-        
-        if deals is None or len(deals) == 0:
-            return f"No closed trades found in the last {days_back} days."
-        
-        # Convert to DataFrame for easier handling
-        df = pd.DataFrame(list(deals), columns=deals[0]._asdict().keys())
-        
-        # Filter only actual trades (exclude balance operations)
-        trade_deals = df[df['type'].isin([0, 1])]  # 0=buy, 1=sell
-        
-        if len(trade_deals) == 0:
-            return f"No trading deals found in the last {days_back} days."
-        
-        formatted_trades = f"=== CLOSED TRADES (Last {days_back} days) ===\n"
-        formatted_trades += f"Total deals: {len(trade_deals)}\n\n"
+        # Run the agent with the user's message
+        response = agent.run(message)
         
-        for _, deal in trade_deals.iterrows():
-            deal_type = "BUY" if deal['type'] == 0 else "SELL"
-            deal_time = datetime.fromtimestamp(deal['time'])
+        # Check if response contains image information
+        if hasattr(response, 'content') and isinstance(response.content, list):
+            # Handle multi-modal response (text + image)
+            text_parts = []
+            images = []
+            
+            for item in response.content:
+                if hasattr(item, 'type'):
+                    if item.type == 'text':
+                        text_parts.append(item.text)
+                    elif item.type == 'image':
+                        images.append(item)
             
-            formatted_trades += f"Ticket: {deal['ticket']}\n"
-            formatted_trades += f"Symbol: {deal['symbol']}\n"
-            formatted_trades += f"Type: {deal_type}\n"
-            formatted_trades += f"Volume: {deal['volume']:.2f}\n"
-            formatted_trades += f"Price: {deal['price']:.5f}\n"
-            formatted_trades += f"Profit: {deal['profit']:.2f}\n"
-            formatted_trades += f"Commission: {deal['commission']:.2f}\n"
-            formatted_trades += f"Swap: {deal['swap']:.2f}\n"
-            formatted_trades += f"Time: {deal_time}\n"
-            formatted_trades += f"Comment: {deal['comment']}\n"
-            formatted_trades += "-" * 40 + "\n"
+            # Combine text parts
+            text_response = ' '.join(text_parts) if text_parts else str(response)
+            
+            # Add images to the response if any
+            if images:
+                text_response += f"\n\n🖼️ Generated {len(images)} image(s)"
+        else:
+            # Handle text-only response
+            text_response = str(response)
         
-        return formatted_trades
+        # Update chat history
+        history.append((message, text_response))
+        return history
         
     except Exception as e:
-        return f"Error getting closed trades: {str(e)}"
+        error_message = f"❌ Error: {str(e)}"
+        history.append((message, error_message))
+        return history
 
-@tool
-def get_trade_statistics(days_back: int = 30) -> str:
-    """
-    Get trading statistics and analysis
-    
-    Args:
-        days_back: Number of days to analyze (default: 30)
+def clear_chat():
+    """Clear the chat history"""
+    return []
+
+def create_interface():
+    """Create the Gradio interface"""
     
-    Returns:
-        Trading statistics as formatted string
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        max-width: 900px !important;
+        margin: auto !important;
+    }
+    .chat-message {
+        padding: 10px !important;
+        margin: 5px 0 !important;
+        border-radius: 10px !important;
+    }
+    .user-message {
+        background-color: #e3f2fd !important;
+        margin-left: 20% !important;
+    }
+    .bot-message {
+        background-color: #f5f5f5 !important;
+        margin-right: 20% !important;
+    }
     """
-    try:
-        from datetime import datetime, timedelta
-        
-        # Calculate date range
-        end_date = datetime.now()
-        start_date = end_date - timedelta(days=days_back)
-        
-        # Get deals
-        deals = mt5.history_deals_get(start_date, end_date)
-        
-        if deals is None or len(deals) == 0:
-            return f"No trades found for statistics in the last {days_back} days."
-        
-        # Convert to DataFrame
-        df = pd.DataFrame(list(deals), columns=deals[0]._asdict().keys())
-        trade_deals = df[df['type'].isin([0, 1])]
-        
-        if len(trade_deals) == 0:
-            return f"No trading deals found for statistics."
-        
-        # Calculate statistics
-        total_trades = len(trade_deals)
-        total_profit = trade_deals['profit'].sum()
-        total_commission = trade_deals['commission'].sum()
-        total_swap = trade_deals['swap'].sum()
-        net_profit = total_profit + total_commission + total_swap
-        
-        winning_trades = trade_deals[trade_deals['profit'] > 0]
-        losing_trades = trade_deals[trade_deals['profit'] < 0]
-        
-        win_rate = (len(winning_trades) / total_trades * 100) if total_trades > 0 else 0
-        avg_win = winning_trades['profit'].mean() if len(winning_trades) > 0 else 0
-        avg_loss = losing_trades['profit'].mean() if len(losing_trades) > 0 else 0
-        
-        stats = f"=== TRADING STATISTICS (Last {days_back} days) ===\n"
-        stats += f"Total Trades: {total_trades}\n"
-        stats += f"Winning Trades: {len(winning_trades)}\n"
-        stats += f"Losing Trades: {len(losing_trades)}\n"
-        stats += f"Win Rate: {win_rate:.1f}%\n"
-        stats += f"Average Win: {avg_win:.2f}\n"
-        stats += f"Average Loss: {avg_loss:.2f}\n"
-        stats += f"Total Profit: {total_profit:.2f}\n"
-        stats += f"Total Commission: {total_commission:.2f}\n"
-        stats += f"Total Swap: {total_swap:.2f}\n"
-        stats += f"Net Profit: {net_profit:.2f}\n"
+    
+    with gr.Blocks(
+        title="🤖 AI Agent with Image Generation",
+        theme=gr.themes.Soft(),
+        css=custom_css
+    ) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # 🤖 AI Agent with Image Generation
+        
+        This intelligent agent can help you with various tasks and generate images using FLUX.1-schnell!
+        
+        **What you can do:**
+        - Ask questions and get intelligent responses
+        - Request image generation with detailed prompts
+        - Combine text and image requests in natural language
+        
+        **Example prompts:**
+        - "Generate an image of a sunset over mountains"
+        - "Create a logo for a tech startup"
+        - "Show me a futuristic city"
+        - "Help me write code and create an illustration for it"
+        """)
+        
+        # Chat interface
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Chat history
+                chatbot = gr.Chatbot(
+                    label="💬 Chat with AI Agent",
+                    height=500,
+                    show_copy_button=True,
+                    show_share_button=True,
+                    avatar_images=("👤", "🤖"),
+                    bubble_full_width=False
+                )
+                
+                # Input area
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Ask me anything or request an image generation...",
+                        lines=2,
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send 🚀", variant="primary", scale=1)
+                
+                # Control buttons
+                with gr.Row():
+                    clear_btn = gr.Button("Clear Chat 🗑️", variant="secondary")
+                    examples_btn = gr.Button("Show Examples 💡", variant="secondary")
         
-        # Most traded symbols
-        symbol_counts = trade_deals['symbol'].value_counts()
-        stats += f"\nMost Traded Symbols:\n"
-        for symbol, count in symbol_counts.head(5).items():
-            stats += f"  {symbol}: {count} trades\n"
+        # Examples section (initially hidden)
+        examples_section = gr.Markdown(
+            """
+            ### 💡 Example Prompts:
+            
+            **Image Generation:**
+            - "Generate a realistic photo of a golden retriever playing in a park"
+            - "Create a minimalist logo design for a coffee shop"
+            - "Show me an abstract art piece with vibrant colors"
+            - "Generate a cyberpunk-style illustration of a neon city"
+            
+            **Text + Image Combination:**
+            - "Explain quantum computing and create a visual representation"
+            - "Write a short story about space exploration and generate an accompanying image"
+            - "Help me design a website layout and show me a mockup"
+            
+            **General AI Tasks:**
+            - "Help me write a Python function to sort a list"
+            - "Explain the concept of machine learning in simple terms"
+            - "Create a meal plan for the week"
+            """,
+            visible=False
+        )
         
-        return stats
+        # Event handlers
+        def send_message(message, history):
+            if not message.strip():
+                return history, ""
+            return process_message(message, history), ""
         
-    except Exception as e:
-        return f"Error calculating statistics: {str(e)}"
-
-@tool
-def disconnect_mt5() -> str:
-    """
-    Disconnect from MetaTrader 5
-    
-    Returns:
-        Disconnection status message
-    """
-    try:
-        mt5.shutdown()
-        return "Successfully disconnected from MT5"
-    except Exception as e:
-        return f"Error disconnecting from MT5: {str(e)}"
-
-# Initialize the agent with Hugging Face model
-def create_agent():
-    """Create and return the SmolagentsAI agent with MT5 tools"""
-    try:
-        # Use a free model from Hugging Face
-        model = HfApiModel("microsoft/DialoGPT-medium")
+        def toggle_examples(examples_visible):
+            return gr.update(visible=not examples_visible)
         
-        # Create agent with MetaTrader tools
-        agent = CodeAgent(
-            tools=[
-                connect_mt5, 
-                get_account_info, 
-                get_closed_trades, 
-                get_trade_statistics, 
-                disconnect_mt5
-            ],
-            model=model,
-            max_steps=10
+        # Wire up the events
+        send_btn.click(
+            send_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input]
         )
         
-        return agent
-    except Exception as e:
-        return None, f"Error creating agent: {str(e)}"
-
-# Global variables
-agent = None
-is_connected = False
-
-def initialize_agent():
-    """Initialize the agent"""
-    global agent
-    agent, error = create_agent()
-    if agent is None:
-        return f"Failed to initialize agent: {error}"
-    return "Agent initialized successfully!"
-
-def connect_to_mt5(login, password, server):
-    """Connect to MT5 with credentials"""
-    global agent, is_connected
-    
-    if agent is None:
-        return "Please initialize the agent first!"
-    
-    try:
-        login_int = int(login)
-        result = agent.run(f"Connect to MT5 with login {login_int}, password {password}, and server {server}")
+        msg_input.submit(
+            send_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input]
+        )
         
-        if "Successfully connected" in result:
-            is_connected = True
-            return result
-        else:
-            is_connected = False
-            return result
-            
-    except ValueError:
-        return "Login must be a valid number"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def chat_with_agent(message, history):
-    """Main chat function for the agent"""
-    global agent, is_connected
-    
-    if agent is None:
-        return history + [("Please initialize the agent first!", "")]
-    
-    if not is_connected:
-        return history + [(message, "Please connect to MT5 first using your credentials in the connection tab.")]
-    
-    try:
-        # Run the agent with the user's message
-        response = agent.run(message)
-        history.append((message, response))
-        return history
-    except Exception as e:
-        error_msg = f"Error processing request: {str(e)}"
-        history.append((message, error_msg))
-        return history
-
-# Create Gradio interface
-def create_gradio_interface():
-    """Create the Gradio interface"""
-    
-    with gr.Blocks(title="MetaTrader 5 AI Agent", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🤖 MetaTrader 5 AI Agent")
-        gr.Markdown("An intelligent agent that can access your MT5 account and provide trading information.")
+        clear_btn.click(
+            clear_chat,
+            outputs=chatbot
+        )
         
-        with gr.Tabs():
-            # Setup Tab
-            with gr.TabItem("🔧 Setup"):
-                gr.Markdown("### Initialize Agent")
-                init_btn = gr.Button("Initialize Agent", variant="primary")
-                init_output = gr.Textbox(label="Initialization Status", interactive=False)
-                
-                init_btn.click(
-                    initialize_agent,
-                    outputs=init_output
-                )
-                
-                gr.Markdown("### Connect to MetaTrader 5")
-                with gr.Row():
-                    login_input = gr.Textbox(label="Login", placeholder="Your MT5 login number")
-                    password_input = gr.Textbox(label="Password", type="password", placeholder="Your MT5 password")
-                    server_input = gr.Textbox(label="Server", placeholder="Your MT5 server name")
-                
-                connect_btn = gr.Button("Connect to MT5", variant="primary")
-                connection_output = gr.Textbox(label="Connection Status", interactive=False)
-                
-                connect_btn.click(
-                    connect_to_mt5,
-                    inputs=[login_input, password_input, server_input],
-                    outputs=connection_output
-                )
-            
-            # Chat Tab
-            with gr.TabItem("💬 Chat with Agent"):
-                gr.Markdown("### Ask the Agent About Your Trading Account")
-                gr.Markdown("""
-                **Example prompts you can try:**
-                - "Show me my account information"
-                - "Get my closed trades from the last 30 days"
-                - "What are my trading statistics?"
-                - "Show me trades from the last 7 days"
-                - "Calculate my win rate and profit"
-                """)
-                
-                chatbot = gr.Chatbot(
-                    label="MT5 Agent Chat",
-                    height=400,
-                    show_copy_button=True
-                )
-                
-                msg = gr.Textbox(
-                    label="Your Message",
-                    placeholder="Ask about your account, trades, or statistics...",
-                    lines=2
-                )
-                
-                with gr.Row():
-                    send_btn = gr.Button("Send", variant="primary")
-                    clear_btn = gr.Button("Clear Chat")
-                
-                # Event handlers
-                def send_message(message, history):
-                    return chat_with_agent(message, history), ""
-                
-                def clear_chat():
-                    return []
-                
-                send_btn.click(
-                    send_message,
-                    inputs=[msg, chatbot],
-                    outputs=[chatbot, msg]
-                )
-                
-                msg.submit(
-                    send_message,
-                    inputs=[msg, chatbot],
-                    outputs=[chatbot, msg]
-                )
-                
-                clear_btn.click(
-                    clear_chat,
-                    outputs=chatbot
-                )
-            
-            # Help Tab
-            with gr.TabItem("❓ Help"):
-                gr.Markdown("""
-                ## How to Use This Application
-                
-                ### 1. Setup
-                - First, click "Initialize Agent" in the Setup tab
-                - Enter your MT5 credentials (login, password, server)
-                - Click "Connect to MT5"
-                
-                ### 2. Chat with Agent
-                - Go to the "Chat with Agent" tab
-                - Ask questions about your trading account
-                - The agent can provide account info, closed trades, and statistics
-                
-                ### Sample Questions:
-                - "What's my account balance and equity?"
-                - "Show me all closed trades from last week"
-                - "Calculate my trading performance statistics"
-                - "What symbols do I trade most?"
-                - "What's my win rate?"
-                
-                ### Requirements:
-                - MetaTrader 5 terminal must be installed and running
-                - Valid MT5 account credentials
-                - Internet connection for the AI model
-                
-                ### Troubleshooting:
-                - Make sure MT5 terminal is running before connecting
-                - Check your credentials are correct
-                - Ensure your MT5 account allows API access
-                - Try reinitializing the agent if you encounter errors
-                """)
+        # Examples toggle
+        examples_visible = gr.State(False)
+        examples_btn.click(
+            lambda visible: (gr.update(visible=not visible), not visible),
+            inputs=examples_visible,
+            outputs=[examples_section, examples_visible]
+        )
         
         # Footer
-        gr.Markdown("---")
-        gr.Markdown("*Powered by SmolagentsAI and MetaTrader 5 API*")
+        gr.Markdown("""
+        ---
+        **Powered by:**
+        - 🧠 **Model**: Qwen2.5-Coder-32B-Instruct
+        - 🎨 **Image Generation**: FLUX.1-schnell
+        - 🤖 **Framework**: SmolagentsAI
+        - 🌐 **Interface**: Gradio
+        
+        *Built for Hugging Face Spaces*
+        """)
     
     return demo
 
-# Launch the application
+# Launch the interface
 if __name__ == "__main__":
-    # Create and launch the Gradio interface
-    demo = create_gradio_interface()
+    demo = create_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,  # Creates a public link
-        debug=True
-    )
+        share=False,  # Set to False for HF Spaces
+        show_error=True
+    )
+