Update app.py

app.py

@@ -3,13 +3,13 @@ from dotenv import load_dotenv
 import gradio as gr
 import requests
 
-from typing import List, Dict, Union
+import os
 import requests
-#import wikipediaapi
-#import google.generativeai as genai
 from typing import List, Dict, Union
-import requests
 import pandas as pd
+import wikipediaapi
+import PyPDF2
+from docx import Document
 
 load_dotenv()
 
@@ -17,27 +17,22 @@ load_dotenv()
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Configure Gemini
-#genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
 
 # --- Basic Agent Definition ---
 class BasicAgent:
-    def __init__(self, model="google/gemma-7b"):
+    def __init__(self, model="gemini-2.0-flash-lite"):
         self.api_url = f"https://api-inference.huggingface.co/models/{model}"
         self.headers = {"Authorization": f"Bearer {os.getenv('HF_API_KEY')}"}
+        # Wikipedia setup (with proper User-Agent)
+        self.wiki = wikipediaapi.Wikipedia(
+            language='en',
+            user_agent='SearchAgent/1.0 ([email protected])'  # CHANGE THIS!
+        )
+        
+        # SearxNG meta-search (replace with your instance)
+        self.searx_url = "https://searx.space/search"  # CHANGE THIS!
         print("BasicAgent initialized.")
-  
-        # Initialize other required components
-        self.searx_url = "https://searx.space/search"  # Set your SearxNG instance URL
-        #self.wiki = wikipediaapi.Wikipedia('en')  # Requires wikipedia-api package
-    
-        #genai.configure(api_key=os.getenv('GEMINI_API_KEY'))
-        #self.model = genai.GenerativeModel(model)
-        #usage
-        #agent = HuggingFaceAgent("google/gemma-7b")  # Same architecture as Gemini
-        #print(agent.generate("Explain quantum computing"))
-      
-    
+
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         fixed_answer = self.generate_response(question)
@@ -45,19 +40,21 @@ class BasicAgent:
         return fixed_answer
 
 
-     # to check
     def generate_response(self, prompt: str) -> str:
-        """Get response from Gema"""
+        """Get response from HuggingFace model"""
         try:
-            response = self.model.generate_content(prompt)
-            return response.text
+            response = requests.post(
+                self.api_url,
+                headers=self.headers,
+                json={"inputs": prompt}
+            )
+            response.raise_for_status()
+            return response.json()[0]['generated_text']
         except Exception as e:
             return f"Error generating response: {str(e)}"
 
-
-
     def web_search(self, query: str) -> List[Dict]:
-        """Use SearxNG meta-search engine"""
+        """Search using SearxNG (meta-search engine)"""
         params = {
             "q": query,
             "format": "json",
@@ -70,13 +67,13 @@ class BasicAgent:
         except requests.RequestException:
             return []
 
-    #def wikipedia_search(self, query: str) -> str:
-    #    """Get Wikipedia summary"""
-    #    page = self.wiki.page(query)
-    #    return page.summary if page.exists() else "No Wikipedia page found"
+    def wikipedia_search(self, query: str) -> str:
+        """Get Wikipedia summary"""
+        page = self.wiki.page(query)
+        return page.summary if page.exists() else "No Wikipedia page found"
 
     def process_document(self, file_path: str) -> str:
-        """Handle PDF, Word, CSV, Excel files"""
+        """Extract text from PDF, Word, CSV, Excel"""
         if not os.path.exists(file_path):
             return "File not found"
         
@@ -84,9 +81,12 @@ class BasicAgent:
         
         try:
             if ext == '.pdf':
-                return self._process_pdf(file_path)
+                with open(file_path, 'rb') as f:
+                    reader = PyPDF2.PdfReader(f)
+                    return "\n".join([page.extract_text() for page in reader.pages])
             elif ext in ('.doc', '.docx'):
-                return self._process_word(file_path)
+                doc = Document(file_path)
+                return "\n".join([para.text for para in doc.paragraphs])
             elif ext == '.csv':
                 return pd.read_csv(file_path).to_string()
             elif ext in ('.xls', '.xlsx'):
@@ -96,54 +96,44 @@ class BasicAgent:
         except Exception as e:
             return f"Error processing document: {str(e)}"
 
-    def _process_pdf(self, file_path: str) -> str:
-        """Process PDF using Gemini's vision capability"""
-        try:
-            # For Gemini 1.5 or later which supports file uploads
-            with open(file_path, "rb") as f:
-#                file = genai.upload_file(f)
-                response = self.model.generate_content(
-                    ["Extract and summarize the key points from this document:", file]
-                )
-                return response.text
-        except:
-            # Fallback for older Gemini versions
-            try:
-                import PyPDF2
-                with open(file_path, 'rb') as f:
-                    reader = PyPDF2.PdfReader(f)
-                    return "\n".join([page.extract_text() for page in reader.pages])
-            except ImportError:
-                return "PDF processing requires PyPDF2 (pip install PyPDF2)"
-
-    def _process_word(self, file_path: str) -> str:
-        """Process Word documents"""
-        try:
-            from docx import Document
-            doc = Document(file_path)
-            return "\n".join([para.text for para in doc.paragraphs])
-        except ImportError:
-            return "Word processing requires python-docx (pip install python-docx)"
-
-    def process_request(self, request: Union[str, Dict]) -> str:
-        """
-        Handle different request types:
-        - Direct text queries
-        - File processing requests
-        - Complex multi-step requests
-        """
-        if isinstance(request, dict):
-            if 'steps' in request:
-                results = []
-                for step in request['steps']:
-                    if step['type'] == 'search':
-                        results.append(self.web_search(step['query']))
-                    elif step['type'] == 'process':
-                        results.append(self.process_document(step['file']))
-                return self.generate_response(f"Process these results: {results}")
-            return "Unsupported request format"
+    def __call__(self, query: str) -> str:
+        """Handle queries (text, search, or file processing)"""
+        print(f"Processing query: {query[:50]}...")
+        
+        # If it's a file path, process it
+        if os.path.exists(query):
+            return self.process_document(query)
+        
+        # If it's a Wikipedia-style query (e.g., "wikipedia:Python")
+        if query.lower().startswith("wikipedia:"):
+            topic = query.split(":")[1].strip()
+            return self.wikipedia_search(topic)
         
-        return self.generate_response(request)
+        # If it's a web search (e.g., "search:best LLMs 2024")
+        if query.lower().startswith("search:"):
+            search_query = query.split(":")[1].strip()
+            results = self.web_search(search_query)
+            return "\n".join([f"{r['title']}: {r['url']}" for r in results])
+        
+        # Default: Use HuggingFace for text generation
+        return self.generate_response(query)
+
+# Example Usage
+if __name__ == "__main__":
+    agent = BasicAgent()
+    
+    # Test Wikipedia search
+    print(agent("wikipedia:Python"))
+    
+    # Test web search (requires SearxNG instance)
+    # print(agent("search:best programming languages 2024"))
+    
+    # Test text generation
+    print(agent("Explain quantum computing in simple terms"))
+    
+    # Test file processing (example: PDF)
+    # print(agent("/path/to/document.pdf"))
+    
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """