logging

app.py

@@ -4,6 +4,7 @@ import gradio as gr
 import requests
 import pandas as pd
 import torch
+import logging
 from transformers import pipeline
 from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_core.prompts import ChatPromptTemplate
@@ -50,7 +51,7 @@ image_to_text_pipeline = None
 @tool
 def web_search(query: str):
     """Searches the web using DuckDuckGo."""
-    print(f"--- Calling Web Search Tool with query: {query} ---")
+    logging.info(f"--- Calling Web Search Tool with query: {query} ---")
     search = DuckDuckGoSearchRun()
     return search.run(query)
 
@@ -58,12 +59,13 @@ def web_search(query: str):
 @tool
 def math_calculator(expression: str):
     """Calculates the result of a mathematical expression."""
-    print(f"--- Calling Math Calculator Tool with expression: {expression} ---")
+    logging.info(f"--- Calling Math Calculator Tool with expression: {expression} ---")
     try:
         # Use numexpr for safe evaluation
         result = numexpr.evaluate(expression).item()
         return result
     except Exception as e:
+        logging.error(f"Error evaluating expression: {e}")
         return f"Error evaluating expression: {e}"
 
 
@@ -71,26 +73,31 @@ def math_calculator(expression: str):
 def image_analyzer(image_url: str):
     """Analyzes an image and returns a description. Loads the model on first use."""
     global image_to_text_pipeline
-    print(f"--- Calling Image Analyzer Tool with URL: {image_url} ---")
+    logging.info(f"--- Calling Image Analyzer Tool with URL: {image_url} ---")
     try:
         if image_to_text_pipeline is None:
-            print("--- Initializing Image Analyzer pipeline for the first time... ---")
+            logging.info(
+                "--- Initializing Image Analyzer pipeline for the first time... ---"
+            )
             # Lazy-load the pipeline to conserve memory on startup
             image_to_text_pipeline = pipeline(
                 "image-to-text", model="Salesforce/blip-image-captioning-base"
             )
-            print("--- Image Analyzer pipeline initialized. ---")
+            logging.info("--- Image Analyzer pipeline initialized. ---")
 
         description = image_to_text_pipeline(image_url)[0]["generated_text"]
         return description
     except Exception as e:
+        logging.error(f"Error analyzing image: {e}")
         return f"Error analyzing image: {e}"
 
 
 @tool
 def youtube_transcript_reader(youtube_url: str):
     """Reads the transcript of a YouTube video."""
-    print(f"--- Calling YouTube Transcript Reader Tool with URL: {youtube_url} ---")
+    logging.info(
+        f"--- Calling YouTube Transcript Reader Tool with URL: {youtube_url} ---"
+    )
     try:
         loader = YoutubeLoader.from_youtube_url(youtube_url, add_video_info=False)
         docs = loader.load()
@@ -98,6 +105,7 @@ def youtube_transcript_reader(youtube_url: str):
         # Return a manageable chunk of the transcript
         return transcript[:4000]
     except Exception as e:
+        logging.error(f"Error reading YouTube transcript: {e}")
         return f"Error reading YouTube transcript: {e}"
 
 
@@ -111,7 +119,7 @@ class AgentState(TypedDict):
 # --- LangGraph Agent Definition ---
 class GaiaAgent:
     def __init__(self):
-        print("Initializing GaiaAgent...")
+        logging.info("Initializing GaiaAgent...")
         self.tools = [
             web_search,
             math_calculator,
@@ -120,7 +128,7 @@ class GaiaAgent:
         ]
 
         # Initialize the LLM
-        print("Loading LLM... This may take a few minutes on first startup.")
+        logging.info("Loading LLM... This may take a few minutes on first startup.")
         # Using a smaller, CPU-friendly model to avoid memory issues on Hugging Face Spaces
         llm = HuggingFacePipeline.from_model_id(
             model_id="microsoft/Phi-3-mini-4k-instruct",
@@ -135,7 +143,7 @@ class GaiaAgent:
             trust_remote_code=True,  # Required for Phi-3
             device_map="auto",
         )
-        print("LLM loaded successfully.")
+        logging.info("LLM loaded successfully.")
 
         # Create the agent graph
         prompt = PromptTemplate(
@@ -151,7 +159,7 @@ Question: {question}
 
         self.agent = prompt | llm | StrOutputParser()
         self.graph = self._create_graph()
-        print("GaiaAgent initialized successfully.")
+        logging.info("GaiaAgent initialized successfully.")
 
     def _create_graph(self):
         graph = StateGraph(AgentState)
@@ -165,7 +173,7 @@ Question: {question}
         return graph.compile()
 
     def _call_agent(self, state: AgentState):
-        print("--- Calling Agent ---")
+        logging.info("--- Calling Agent ---")
         message_history = "\n".join(state["messages"])
         response = self.agent.invoke(
             {"messages": message_history, "question": state["question"]}
@@ -173,7 +181,7 @@ Question: {question}
         return {"messages": [response], "sender": "agent"}
 
     def _decide_action(self, state: AgentState):
-        print("--- Deciding Action ---")
+        logging.info("--- Deciding Action ---")
         response = state["messages"][-1]
         if "FINAL ANSWER:" in response:
             return END
@@ -181,12 +189,13 @@ Question: {question}
             return "tools"
 
     def _call_tools(self, state: AgentState):
-        print("--- Calling Tools ---")
+        logging.info("--- Calling Tools ---")
         raw_tool_call = state["messages"][-1]
 
         # Simple regex to find tool calls like tool_name("argument") or tool_name(argument)
         tool_call_match = re.search(r"(\w+)\s*\((.*?)\)", raw_tool_call, re.DOTALL)
         if not tool_call_match:
+            logging.warning("No valid tool call found in agent response.")
             return {"messages": ["No valid tool call found."], "sender": "tools"}
 
         tool_name = tool_call_match.group(1).strip()
@@ -207,15 +216,17 @@ Question: {question}
                 result = tool_to_call.run(tool_input)
                 return {"messages": [str(result)], "sender": "tools"}
             except Exception as e:
+                logging.error(f"Error executing tool {tool_name}: {e}")
                 return {
                     "messages": [f"Error executing tool {tool_name}: {e}"],
                     "sender": "tools",
                 }
         else:
+            logging.warning(f"Tool '{tool_name}' not found.")
             return {"messages": [f"Tool '{tool_name}' not found."], "sender": "tools"}
 
     def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:100]}...")
+        logging.info(f"Agent received question: {question[:100]}...")
 
         initial_state = {"question": question, "messages": [], "sender": "user"}
 
@@ -229,10 +240,12 @@ Question: {question}
         )
         if match:
             extracted_answer = match.group(1).strip()
-            print(f"Agent returning final answer: {extracted_answer}")
+            logging.info(f"Agent returning final answer: {extracted_answer}")
             return extracted_answer
         else:
-            print("Agent could not find a final answer in the required format.")
+            logging.warning(
+                "Agent could not find a final answer in the required format."
+            )
             # Return a fallback answer if parsing fails
             return "Could not determine the final answer."
 
@@ -243,14 +256,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     and displays the results.
     """
     if not profile:
-        print("User not logged in.")
+        logging.warning("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
     username = profile.username
-    print(f"User logged in: {username}")
+    logging.info(f"User logged in: {username}")
 
     space_id = os.getenv("SPACE_ID")
     if not space_id:
+        logging.error("SPACE_ID environment variable is not set. Cannot proceed.")
         return "SPACE_ID environment variable is not set. Cannot proceed.", None
 
     api_url = DEFAULT_API_URL
@@ -261,28 +275,30 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     try:
         agent = GaiaAgent()
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
+        logging.critical(f"Error instantiating agent: {e}", exc_info=True)
         return f"Error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(f"Agent code URL: {agent_code}")
+    logging.info(f"Agent code URL: {agent_code}")
 
     # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+    logging.info(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=20)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
+            logging.warning("Fetched questions list is empty.")
             return "Fetched questions list is empty.", None
-        print(f"Fetched {len(questions_data)} questions.")
+        logging.info(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
+        logging.error(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
     # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
+    logging.info(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
@@ -302,7 +318,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 }
             )
         except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
+            logging.error(f"Error running agent on task {task_id}: {e}", exc_info=True)
             results_log.append(
                 {
                     "Task ID": task_id,
@@ -312,6 +328,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             )
 
     if not answers_payload:
+        logging.warning("Agent did not produce any answers.")
         return "Agent did not produce any answers.", pd.DataFrame(results_log)
 
     # 4. Prepare and Submit
@@ -320,7 +337,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         "agent_code": agent_code,
         "answers": answers_payload,
     }
-    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
+    logging.info(f"Submitting {len(answers_payload)} answers for user '{username}'...")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -332,12 +349,16 @@ 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.")
+        logging.info("Submission successful.")
         return final_status, pd.DataFrame(results_log)
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}. Detail: {e.response.text}"
+        logging.error(f"Submission Failed: {error_detail}")
         return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
     except Exception as e:
+        logging.critical(
+            f"An unexpected error occurred during submission: {e}", exc_info=True
+        )
         return f"An unexpected error occurred during submission: {e}", pd.DataFrame(
             results_log
         )
@@ -373,5 +394,11 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    logging.info("\n" + "-" * 30 + " App Starting " + "-" * 30)
     demo.launch(debug=True, share=False)