Update app.py

app.py

@@ -1,360 +1,33 @@
 import os
 import gradio as gr
 from dotenv import load_dotenv
+import inspect
 import requests
 import pandas as pd
-import base64
-import mimetypes
-import tempfile
-from smolagents import CodeAgent, OpenAIServerModel, tool
-from dotenv import load_dotenv
-from openai import OpenAI
-from markdownify import markdownify
-from requests.exceptions import RequestException
-
-from typing import Optional, List
-from langchain_core.tools import BaseTool, tool
-#from langchain_community.tools import DuckDuckGoSearchResults
-#from langchain_experimental.tools import PythonREPLTool
-import requests
-from bs4 import BeautifulSoup
-import markdownify
-import pandas as pd
-from io import BytesIO
-#import pytesseract
-from PIL import Image
-from youtube_transcript_api import YouTubeTranscriptApi
-import re
+from langchain_core.messages import HumanMessage
+from agent import build_graph
 
-# Load environment variables
 load_dotenv()
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Initialize the OpenAI model using environment variable for API key
-model = OpenAIServerModel(
-    model_id="o4-mini-2025-04-16",
-    api_base="https://api.openai.com/v1",
-    api_key=os.getenv("openai"),
-)
-
-# Initialize OpenAI client
-openAiClient = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-@tool
-def arvix_search(query: str) -> str:
-    """Search Arxiv for a query and return maximum 3 result.
-    
-    Args:
-        query: The search query."""
-    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
-            for doc in search_docs
-        ])
-    return {"arvix_results": formatted_search_docs}
-            
-
-@tool
-def analyze_image(image_url: str) -> str:
-    """
-    Analyze an image using OpenAI's vision model and return a description.
-    
-    Args:
-        image_url: URL of the image to analyze
-        
-    Returns:
-        A detailed description of the image
-    """
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        return "Error: OpenAI API key not set in environment variables"
-    
-    # Download the image
-    try:
-        response = requests.get(image_url)
-        response.raise_for_status()
-        image_data = response.content
-        base64_image = base64.b64encode(image_data).decode('utf-8')
-    except Exception as e:
-        return f"Error downloading image: {str(e)}"
-    
-    # Call OpenAI API
-    api_url = "https://api.openai.com/v1/chat/completions"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}"
-    }
-    
-    payload = {
-        "model": "gpt-4.1-2025-04-14",
-        "messages": [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": "Describe this image in detail. Include any text, objects, people, actions, and overall context."
-                    },
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{base64_image}"
-                        }
-                    }
-                ]
-            }
-        ],
-        "max_tokens": 500
-    }
-    
-    try:
-        response = requests.post(api_url, headers=headers, json=payload)
-        response.raise_for_status()
-        data = response.json()
-        
-        if "choices" in data and len(data["choices"]) > 0:
-            return data["choices"][0]["message"]["content"]
-        else:
-            return "No description generated"
-    except Exception as e:
-        return f"Error analyzing image: {str(e)}"
-
-@tool
-def analyze_sound(audio_url: str) -> str:
-    """
-    Transcribe an audio file using OpenAI's Whisper model.
-    
-    Args:
-        audio_url: the url of the audio
-        
-    Returns:
-        A transcription of the audio content
-    """
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        return "Error: OpenAI API key not set in environment variables"
-    
-    # Download the audio file
-    try:
-        response = requests.get(audio_url)
-        response.raise_for_status()
-        
-        import tempfile
-        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
-            temp_file.write(response.content)
-            temp_file_path = temp_file.name
-
-        audio_file= open(temp_file_path, "rb")
-        
-    except Exception as e:
-        return f"Error downloading audio: {str(e)}"
-
-    try:
-        transcription = openAiClient.audio.transcriptions.create(
-            model="gpt-4o-transcribe", 
-            file=audio_file
-        )
-        return transcription.text
-    except Exception as e:
-        return f"Error transcribing audio: {str(e)}"
-
-@tool
-def analyze_excel(excel_url: str) -> str:
-    """
-    Process an Excel file and convert it to a text-based format.
-    
-    Args:
-        excel_url: URL of the Excel file to analyze
-        
-    Returns:
-        A text representation of the Excel data
-    """
-    try:
-        # Download the Excel file
-        response = requests.get(excel_url)
-        response.raise_for_status()
-        
-        # Save to a temporary file
-        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as temp_file:
-            temp_file.write(response.content)
-            temp_file_path = temp_file.name
-        
-        # Read the Excel file
-        df = pd.read_excel(temp_file_path)
-        
-        # Convert to a text representation
-        result = []
-        
-        # Add sheet information
-        result.append(f"Excel file with {len(df)} rows and {len(df.columns)} columns")
-        
-        # Add column names
-        result.append("\nColumns:")
-        for i, col in enumerate(df.columns, 1):
-            result.append(f"{i}. {col}")
-        
-        # Add data summary
-        result.append("\nData Summary:")
-        result.append(df.describe().to_string())
-        
-        # Add first few rows as a sample
-        result.append("\nFirst 5 rows:")
-        result.append(df.head().to_string())
-        
-        # Clean up
-        os.unlink(temp_file_path)
-        
-        return "\n".join(result)
-    except Exception as e:
-        return f"Error processing Excel file: {str(e)}"
-
-@tool
-def analyze_text(text_url: str) -> str:
-    """
-    Process a text file and return its contents.
-    
-    Args:
-        text_url: URL of the text file to analyze
-        
-    Returns:
-        The contents of the text file
-    """
-    try:
-        # Download the text file
-        response = requests.get(text_url)
-        response.raise_for_status()
-        
-        # Get the text content
-        text_content = response.text
-        
-        # For very long files, truncate with a note
-        if len(text_content) > 10000:
-            return f"Text file content (truncated to first 10000 characters):\n\n{text_content[:10000]}\n\n... [content truncated]"
-        
-        return f"Text file content:\n\n{text_content}"
-    except Exception as e:
-        return f"Error processing text file: {str(e)}"
-
-@tool
-def transcribe_youtube(youtube_url: str) -> str:
-    """
-    Extract the transcript from a YouTube video.
-    
-    Args:
-        youtube_url: URL of the YouTube video
-        
-    Returns:
-        The transcript of the video
-    """
-    try:
-        # Extract video ID from URL
-        import re
-        video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', youtube_url)
-        if not video_id_match:
-            return "Error: Invalid YouTube URL"
-        
-        video_id = video_id_match.group(1)
-        
-        # Use youtube_transcript_api to get the transcript
-        from youtube_transcript_api import YouTubeTranscriptApi
-        
-        try:
-            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
-            
-            # Combine all transcript segments into a single text
-            full_transcript = ""
-            for segment in transcript_list:
-                full_transcript += segment['text'] + " "
-            
-            return f"YouTube Video Transcript:\n\n{full_transcript.strip()}"
-        except Exception as e:
-            return f"Error extracting transcript: {str(e)}"
-    except Exception as e:
-        return f"Error processing YouTube video: {str(e)}"
-
-
-@tool
-def process_file(task_id: str, file_name: str) -> str:
-    """
-    Fetch and process a file based on task_id and file_name.
-    For images, it will analyze them and return a description of the image.
-    For audio files, it will transcribe them.
-    For Excel files, it will convert them to a text format.
-    For text files, it will return the file contents.
-    Other file types can be ignored for this tool.
-    
-    Args:
-        task_id: The task ID to fetch the file for
-        file_name: The name of the file to process
-        
-    Returns:
-        A description or transcription of the file content
-    """
-    if not task_id or not file_name:
-        return "Error: task_id and file_name are required"
-    
-    # Construct the file URL
-    file_url = f"{DEFAULT_API_URL}/files/{task_id}"
-    
-    try:
-        # Fetch the file
-        response = requests.get(file_url)
-        response.raise_for_status()
-        
-        # Determine file type
-        mime_type, _ = mimetypes.guess_type(file_name)
-        
-        # Process based on file type
-        if mime_type and mime_type.startswith('image/'):
-            # For images, use the analyze_image tool
-            return analyze_image(file_url)
-        elif file_name.lower().endswith('.mp3') or (mime_type and mime_type.startswith('audio/')):
-            # For audio files, use the analyze_sound tool
-            return analyze_sound(file_url)
-        elif file_name.lower().endswith('.xlsx') or (mime_type and mime_type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'):
-            # For Excel files, use the analyze_excel tool
-            return analyze_excel(file_url)
-        elif file_name.lower().endswith(('.txt', '.py', '.js', '.html', '.css', '.json', '.md')) or (mime_type and mime_type.startswith('text/')):
-            # For text files, use the analyze_text tool
-            return analyze_text(file_url)
-        else:
-            # For other file types, return basic information
-            return f"File '{file_name}' of type '{mime_type or 'unknown'}' was fetched successfully. Content processing not implemented for this file type."
-    except Exception as e:
-        return f"Error processing file: {str(e)}"
-
+# --- Basic Agent Definition ---
 
 class BasicAgent:
-    """
-    A simple agent that uses smolagents.CodeAgent with multiple specialized tools:
-    - Tavily search tool for web searches
-    - Image analysis tool for processing images
-    - Audio transcription tool for processing sound files
-    - Excel analysis tool for processing spreadsheet data
-    - Text file analysis tool for processing code and text files
-    - YouTube transcription tool for processing video content
-    - File processing tool for handling various file types
-    
-    The CodeAgent is instantiated once and reused for each question to reduce overhead.
-    """
+    """A langgraph agent."""
     def __init__(self):
         print("BasicAgent initialized.")
-        # Reuse a single CodeAgent instance for all queries
-        self.agent = CodeAgent(tools=[arvix_search,
-                                      analyze_image, 
-                                      analyze_sound, 
-                                      analyze_excel, 
-                                      analyze_text, 
-                                      transcribe_youtube, 
-                                      process_file], model=model)
+        self.graph = build_graph()
 
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        return self.agent.run(question)
-
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):