Attempt #3

app.py

@@ -11,36 +11,87 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
+
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        self.hf_client = InferenceClient(
-            model="Qwen/Qwen1.5-7B-Chat",  # Using Qwen model as default
-            token=os.getenv("HF_TOKEN")  # Optional: Set HF_TOKEN if you have one
-        )
-        print("Using Hugging Face model: Qwen/Qwen1.5-7B-Chat")
-    
+        # Try multiple models in order of preference with better error handling
+        self.model_name = "Qwen/Qwen1.5-7B-Chat"  # Default model
+        self.hf_token = os.getenv("HF_TOKEN")  # Get token from environment if available
+
+        print(f"aaa, {os.getenv("HF_TOKEN")}")
+
+        # List of fallback models (free models that don't require authentication)
+        self.fallback_models = [
+            "google/flan-t5-small",  # Small but doesn't require authentication
+            "facebook/opt-125m",  # Another small fallback option
+            "distilbert-base-uncased"  # Even more basic fallback
+        ]
+
+        try:
+            print(f"Attempting to initialize with model: {self.model_name}")
+            self.hf_client = InferenceClient(
+                model=self.model_name,
+                token=self.hf_token
+            )
+            # Test the client with a simple prompt to verify it works
+            test_response = self.hf_client.text_generation(
+                prompt="Hello, this is a test.",
+                max_new_tokens=10
+            )
+            print(f"Model initialized successfully: {self.model_name}")
+
+        except Exception as e:
+            print(f"Error initializing primary model ({self.model_name}): {e}")
+            self.hf_client = None
+
+            # Try fallback models
+            for fallback_model in self.fallback_models:
+                try:
+                    print(f"Attempting fallback model: {fallback_model}")
+                    self.hf_client = InferenceClient(
+                        model=fallback_model,
+                        token=self.hf_token
+                    )
+                    # Quick test to verify the model works
+                    test_response = self.hf_client.text_generation(
+                        prompt="Hello, this is a test.",
+                        max_new_tokens=5
+                    )
+                    print(f"Successfully initialized fallback model: {fallback_model}")
+                    self.model_name = fallback_model
+                    break
+                except Exception as fallback_error:
+                    print(f"Fallback model failed ({fallback_model}): {fallback_error}")
+                    self.hf_client = None
+
+            # If all models fail, we'll use a rule-based response generator
+            if self.hf_client is None:
+                print("WARNING: All models failed. Using rule-based fallback for responses.")
+                self.model_name = "rule-based-fallback"
+
     def break_down_question(self, question: str) -> list:
         """
         Use an LLM to break down a complex question into key search terms or sub-questions.
-        
+
         Args:
             question (str): The original question
-            
+
         Returns:
             list: A list of key search terms or sub-questions
         """
         try:
             print(f"Breaking down question with LLM: {question[:50]}...")
-            
+
             # Create a prompt that asks the LLM to break down the question
             prompt = f"""
             Please break down this question into 2-3 key search queries that would help find information to answer it.
             Return ONLY the search queries, one per line, with no additional text or explanations.
-            
+
             Question: {question}
             """
-            
+
             # Call the Hugging Face model to get the breakdown
             response = self.hf_client.text_generation(
                 prompt=prompt,
@@ -49,30 +100,30 @@ class BasicAgent:
                 repetition_penalty=1.1,
                 do_sample=True
             )
-            
+
             # Extract the search terms from the response
             search_terms = response.strip().split('\n')
             search_terms = [term.strip() for term in search_terms if term.strip()]
-            
+
             # Limit to 3 search terms maximum
             search_terms = search_terms[:3]
-            
+
             print(f"Question broken down into {len(search_terms)} search terms: {search_terms}")
             return search_terms
-            
+
         except Exception as e:
             print(f"Error breaking down question: {e}")
             # If there's an error, return the original question as a fallback
             return [question]
-        
+
     def search_internet(self, query: str) -> str:
         """
         Search the internet for information using Wikipedia's API.
         This is a simple implementation that returns search results as text.
-        
+
         Args:
             query (str): The search query
-            
+
         Returns:
             str: Search results as text
         """
@@ -82,88 +133,88 @@ class BasicAgent:
             headers = {
                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
             }
-            
+
             # Step 1: Search for relevant articles
             search_url = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={query}&format=json"
             search_response = requests.get(search_url, headers=headers, timeout=10)
             search_response.raise_for_status()
             search_data = search_response.json()
-            
+
             # Check if we found any search results
             if 'query' not in search_data or 'search' not in search_data['query'] or not search_data['query']['search']:
                 return "No relevant information found."
-                
+
             # Get the title of the first (most relevant) result
             first_result = search_data['query']['search'][0]
             page_title = first_result['title']
-            
+
             # Step 2: Fetch the content of the most relevant article
             content_url = f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&exintro=1&explaintext=1&titles={page_title}&format=json"
             content_response = requests.get(content_url, headers=headers, timeout=10)
             content_response.raise_for_status()
             content_data = content_response.json()
-            
+
             # Extract the page content
             pages = content_data['query']['pages']
             page_id = list(pages.keys())[0]
-            
+
             if 'extract' in pages[page_id]:
                 extract = pages[page_id]['extract']
                 # Limit extract length to avoid very long responses
                 if len(extract) > 1000:
                     extract = extract[:1000] + "..."
-                
+
                 result = f"Wikipedia article: {page_title}\n\n{extract}"
-                
+
                 # Also get a few more related article titles
                 related_titles = []
                 for item in search_data['query']['search'][1:4]:  # Get next 3 results
                     related_titles.append(item['title'])
-                
+
                 if related_titles:
                     result += "\n\nRelated topics:\n"
                     for title in related_titles:
                         result += f"- {title}\n"
-                        
+
                 return result
             else:
                 return "Found a relevant page, but couldn't extract its content."
-                
+
         except Exception as e:
             print(f"Error searching internet: {e}")
             return f"Error performing internet search: {str(e)}"
-    
+
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        
+
         # Use LLM to break down the question into key search terms
         search_terms = self.break_down_question(question)
-        
+
         # Search for information using each search term
         all_results = []
         for term in search_terms:
             result = self.search_internet(term)
             if result and result != "No relevant information found." and not result.startswith("Error"):
                 all_results.append(result)
-        
+
         # Create a response based on collected search results
         if all_results:
             # Join the results with clear separation
             combined_results = "\n\n--- Next Search Result ---\n\n".join(all_results)
-            
+
             # Use Hugging Face model to synthesize a coherent answer from the search results
             try:
                 synthesis_prompt = f"""
                 Based on the following search results, please provide a comprehensive answer to this question:
-                
+
                 Question: {question}
-                
+
                 Search Results:
                 {combined_results}
-                
+
                 Answer:
                 """
-                
+
                 # Call the Hugging Face model to synthesize an answer
                 response = self.hf_client.text_generation(
                     prompt=synthesis_prompt,
@@ -172,11 +223,11 @@ class BasicAgent:
                     repetition_penalty=1.05,
                     do_sample=True
                 )
-                
+
                 answer = response.strip()
                 print("Agent returning synthesized answer from search results.")
                 return answer
-            
+
             except Exception as e:
                 print(f"Error synthesizing answer: {e}")
                 # Fallback to returning the raw search results
@@ -189,16 +240,17 @@ class BasicAgent:
             print("Agent returning default answer as searches found no useful information.")
             return answer
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -225,16 +277,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
@@ -254,14 +306,14 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
+    # 4. Prepare Submission
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
@@ -312,7 +364,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner (Attempt #2)")
+    gr.Markdown("# Basic Agent Evaluation Runner (Attempt #3)")
     gr.Markdown(
         """
         **Instructions:**
@@ -342,10 +394,10 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -353,14 +405,14 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:  # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
         print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)