Update app.py

app.py

@@ -9,13 +9,27 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_community.retrievers import BM25Retriever
 
 from smolagents import Tool, CodeAgent
+from huggingface_hub.inference_api import InferenceApi
 
-from huggingface_hub.inference_api import InferenceApi  # <--- NEW import
+
+# Wrapper class to adapt HuggingFace Inference API to have .generate()
+class HuggingFaceInferenceWrapper:
+    def __init__(self, inference_api):
+        self.inference_api = inference_api
+
+    def generate(self, prompt: str, **kwargs) -> str:
+        # Call the inference API with prompt, return generated text
+        response = self.inference_api(inputs=prompt)
+        if isinstance(response, dict) and "generated_text" in response:
+            return response["generated_text"]
+        elif isinstance(response, str):
+            return response
+        else:
+            raise ValueError(f"Unexpected response format: {response}")
 
 
 hf_token = os.getenv("HUGGINGFACE_API_KEY")
 print("Token from env var:", hf_token)
-os.environ["HUGGINGFACE_API_KEY"] = hf_token
 
 if hf_token:
     os.environ["HUGGINGFACE_API_KEY"] = hf_token
@@ -26,38 +40,29 @@ else:
 print("HUGGINGFACE_API_KEY in env:", "HUGGINGFACE_API_KEY" in os.environ)
 print("HUGGINGFACE_API_KEY value (masked):", os.environ.get("HUGGINGFACE_API_KEY", "")[:5] + "...")
 
-
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the agent on them, submits all answers,
-    and displays the results.
-    """
-    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username = f"{profile.username}"
+        username = profile.username
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
-    api_url = "https://agents-course-unit4-scoring.hf.space"  # Replace with your actual API URL or set as env var
+    api_url = "https://agents-course-unit4-scoring.hf.space"
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # --- Instantiate Agent ---
     try:
-        # Load knowledge base dataset and filter
         knowledge_base = datasets.load_dataset("m-ric/huggingface_doc", split="train")
         knowledge_base = knowledge_base.filter(lambda row: row["source"].startswith("huggingface/transformers"))
 
-        # Create source Documents for retriever
         source_docs = [
             Document(page_content=doc["text"], metadata={"source": doc["source"].split("/")[1]})
             for doc in knowledge_base
         ]
 
-        # Split documents into chunks
         text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=500,
             chunk_overlap=50,
@@ -67,7 +72,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         )
         docs_processed = text_splitter.split_documents(source_docs)
 
-        # Define the Retriever tool
         class RetrieverTool(Tool):
             name = "retriever"
             description = (
@@ -98,27 +102,17 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         retriever_tool = RetrieverTool(docs_processed)
 
-        # Initialize HF Inference API client with your token
-        inference = InferenceApi(repo_id="Qwen/Qwen2.5-VL-7B-Instruct", token=hf_token)
-
-        # Wrap inference client in a callable class for smolagents compatibility
-        class HuggingFaceInferenceWrapper:
-            def __init__(self, client):
-                self.client = client
-
-            def __call__(self, prompt: str):
-                response = self.client(inputs=prompt)
-                if isinstance(response, dict):
-                    # Usually HF text generation returns {'generated_text': "..."}
-                    return response.get("generated_text") or str(response)
-                return str(response)
+        # Initialize HuggingFace InferenceApi
+        inference_api = InferenceApi(repo_id="Qwen/Qwen2.5-VL-7B-Instruct", token=hf_token)
+        # Wrap it so it supports .generate()
+        model_wrapper = HuggingFaceInferenceWrapper(inference_api)
 
         agent = CodeAgent(
             tools=[retriever_tool],
-            model=HuggingFaceInferenceWrapper(inference),
+            model=model_wrapper,
             max_steps=4,
             verbosity_level=2,
-            stream_outputs=False,
+            stream_outputs=False,  # Set False because this model doesn't support streaming here
         )
 
     except Exception as e:
@@ -127,53 +121,34 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Code repo URL not available"
     print(agent_code)
 
-    # --- Fetch Questions ---
-    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         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(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 Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
 
-    # --- Run Agent on Questions ---
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            # Run the agent
-            submitted_answer = agent.run(question_text)  # Use .run() for smolagents CodeAgent
+            submitted_answer = agent.run(question_text)
             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}"})
 
     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)
 
-    # --- 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)
 
-    # --- Submit Answers ---
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -185,38 +160,14 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
         results_df = pd.DataFrame(results_log)
         return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
+        status_message = f"Submission Failed: {e}"
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
 
-# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
@@ -261,6 +212,9 @@ if __name__ == "__main__":
         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?).")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-" * (60 + len(" App Starting ")) + "\n")
 
-    demo.launch(debug=True)
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)