Update app.py

app.py

@@ -8,9 +8,11 @@ from typing import TypedDict
 import string
 
 
-###
-
+from transformers import pipeline
+import re
 import wikipedia
+import wikipediaapi
+
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -27,60 +29,43 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 #        print(f"Agent returning fixed answer: {fixed_answer}")
 #        return fixed_answer
 
+
+
 class SuperSmartAgent:
     def __init__(self):
         self.graph = self._build_graph()
 
     def _build_graph(self):
-        ############## NODES ###################
         def score_text(text):
-            # Count alphanumeric characters
             alnum_count = sum(c.isalnum() for c in text)
-            # Count spaces
             space_count = text.count(' ')
-            # Count punctuation marks
             punctuation_count = sum(c in string.punctuation for c in text)
-            # Check if text ends with sentence punctuation (., !, ?)
             ends_properly = text[-1] in '.!?'
-            
-            # Simple heuristic score: alnum + spaces + bonus if ends properly
             score = alnum_count + space_count
             if ends_properly:
-                score += 5  # give bonus if text ends with punctuation
-            
+                score += 5
             return score
 
         def check_reversed(state):
             question = state["question"]
             reversed_candidate = question[::-1]
-        
             original_score = score_text(question)
             reversed_score = score_text(reversed_candidate)
-        
-            print(f"Original text score: {original_score}")
-            print(f"Reversed text score: {reversed_score}")
-        
             if reversed_score > original_score:
-                print("Detected reversed text. Marking as reversed.")
                 state["is_reversed"] = True
             else:
-                print("No reversal detected.")
                 state["is_reversed"] = False
             return state
-        
+
         def fix_question(state):
             if state.get("is_reversed", False):
-                print(f"Fixing question by reversing: {state['question']}")
                 state["question"] = state["question"][::-1]
-                print(f"Fixed question: {state['question']}")
             return state
 
         def check_riddle_or_trick(state):
-            print(f"Checking riddle/trick keywords in question: {state['question']}")
             q = state["question"].lower()
             keywords = ["opposite of", "if you understand", "riddle", "trick question", "what comes next", "i speak without"]
             state["is_riddle"] = any(kw in q for kw in keywords)
-            print(f"is_riddle: {state['is_riddle']}")
             return state
 
         def solve_riddle(state):
@@ -97,16 +82,13 @@ class SuperSmartAgent:
             else:
                 state["response"] = "Could not solve riddle."
             return state
-        
+
         def check_python_suitability(state):
             question = state["question"].lower()
             patterns = ["sum", "average", "count", "sort", "generate", "regex", "convert"]
-            if any(word in question for word in patterns):
-                state["is_python"] = True
-            else:
-                state["is_python"] = False
+            state["is_python"] = any(word in question for word in patterns)
             return state
-    
+
         def generate_code(state):
             q = state["question"].lower()
             if "sum" in q:
@@ -118,84 +100,23 @@ class SuperSmartAgent:
             else:
                 state["response"] = "# Code generation not implemented for this case."
             return state
-        
+
         def fallback(state):
-            print(f"Fallback triggered. Final question state: {state['question']}")
             state["response"] = "This question doesn't require Python or is unclear."
             return state
 
-        ###################
-        def general_reasoning_qa(state):
-            question = state["question"]
-        
-            # Step 1: Search Wikipedia for relevant pages
-            search_results = wikipedia.search(question)
-            relevant_pages = search_results[:3]  # get top 3 pages
-        
-            context = ""
-            for title in relevant_pages:
-                try:
-                    page = wikipedia.page(title)
-                    context += page.content + "\n"
-                except:
-                    continue
-        
-            if not context:
-                state["response"] = "Sorry, I couldn’t find enough information."
-                return state
-        
-            # Step 2: Process the context to extract relevant information
-            # This is a simplified approach; in practice, you'd use more sophisticated NLP techniques
-            # For example, you can look for numerical data, dates, names, etc., in the context
-        
-            # Example: Extract numbers and names from the context
-            import re
-            numbers = re.findall(r'\d+', context)
-            names = re.findall(r'\b[A-Z][a-z]+ [A-Z][a-z]+\b', context)  # Simplified pattern for names
-
-            # Step 3: Generate an answer based on the processed context
-            # This is a placeholder; in practice, you'd need a more sophisticated method
-            if "How many" in question:
-                if numbers:
-                    # Assume the first number is relevant (this is a very simplistic approach)
-                    state["response"] = f"The answer is {numbers[0]}."
-                else:
-                    state["response"] = "I couldn't find a numerical answer in the context."
-            elif "who" in question.lower() or "what" in question.lower():
-                if names:
-                    # Assume the first name is relevant (this is a very simplistic approach)
-                    state["response"] = f"The answer is {names[0]}."
-                else:
-                    state["response"] = "I couldn't find a relevant name in the context."
-            else:
-                # Fallback to returning a summary if no specific pattern matches
-                try:
-                    page = wikipedia.page(relevant_pages[0])
-                    summary = page.summary
-                    state["response"] = summary
-                except Exception as e:
-                    state["response"] = f"Error fetching Wikipedia content: {e}"
-        
-            return state
-
-
-
         def check_reasoning_needed(state):
             q = state["question"].lower()
-            # very rough heuristic — refine as needed
             needs_reasoning = any(word in q for word in ["whose", "only", "first", "after", "before", "no longer", "not", "but", "except"])
             state["needs_reasoning"] = needs_reasoning
             return state
-    
 
         def check_wikipedia_suitability(state):
             q = state["question"].lower()
-            # Simple heuristic: if it's a "who is", "what is", or named entity
             triggers = ["wikipedia","Wikipedia","who is", "what is", "when did", "where is", "tell me about", "How many"]
             state["is_wiki"] = any(trigger in q for trigger in triggers)
-            print(f"is_wiki: {state['is_wiki']}")
             return state
-        
+
         def search_wikipedia(state):
             question = state["question"]
             try:
@@ -203,7 +124,7 @@ class SuperSmartAgent:
                 if not page_titles:
                     state["response"] = "No relevant Wikipedia article found."
                     return state
-        
+
                 page = wikipedia.page(page_titles[0])
                 summary = page.summary
                 state["response"] = summary
@@ -211,8 +132,65 @@ class SuperSmartAgent:
                 state["response"] = f"Error fetching Wikipedia content: {e}"
             return state
 
-        ##################
-        
+        def preprocess_context(context):
+            context = re.sub(r'\[\d+\]', '', context)  # Remove citations
+            context = re.sub(r'\s+', ' ', context).strip()  # Clean whitespace
+            return context
+
+        def validate_answer(question, answer):
+            if "how many" in question.lower():
+                if not re.search(r'\d+', answer):
+                    return False
+            return True
+
+        def general_reasoning_qa(state):
+            question = state["question"]
+
+            # Step 1: Search Wikipedia and gather context
+            context = ""
+            try:
+                wiki_wiki = wikipediaapi.Wikipedia('en')
+                search_results = wiki_wiki.search(question, results=3)  # get top 3 pages
+
+                for title in search_results:
+                    page = wiki_wiki.page(title)
+                    if page.exists():
+                        context += page.text + "\n"
+            except Exception as e:
+                state["response"] = f"Error fetching Wikipedia content: {e}"
+                return state
+
+            if not context:
+                state["response"] = "Sorry, I couldn’t find enough information."
+                return state
+
+            context = preprocess_context(context)
+
+            # Step 2: Use a pre-trained QA model to generate the answer
+            try:
+                qa_pipeline = pipeline("question-answering")
+                result = qa_pipeline(question=question, context=context)
+                answer = result['answer']
+
+                if validate_answer(question, answer):
+                    state["response"] = answer
+                else:
+                    # Fallback: return a summary if the answer is not validated
+                    try:
+                        page_titles = wikipedia.search(question)
+                        if page_titles:
+                            page = wikipedia.page(page_titles[0])
+                            summary = page.summary
+                            state["response"] = summary
+                        else:
+                            state["response"] = "No relevant Wikipedia article found."
+                    except Exception as e:
+                        state["response"] = f"Error fetching Wikipedia content: {e}"
+            except Exception as e:
+                state["response"] = f"Error generating answer: {e}"
+
+            return state
+
         class AgentState(TypedDict, total=False):
             question: str
             is_reversed: bool
@@ -220,10 +198,8 @@ class SuperSmartAgent:
             is_riddle: bool
             use_tool: str
             response: str
-        
-        builder = StateGraph(AgentState)
-
 
+        builder = StateGraph(AgentState)
         # --- Nodes ---
         builder.add_node("check_reversed", check_reversed)
         builder.add_node("fix_question", fix_question)
@@ -236,34 +212,33 @@ class SuperSmartAgent:
         builder.add_node("check_python_suitability", check_python_suitability)
         builder.add_node("generate_code", generate_code)
         builder.add_node("fallback", fallback)
-        
+
         # Entry
         builder.set_entry_point("check_reversed")
-
         # Edges
         builder.add_edge("check_reversed", "fix_question")
         builder.add_edge("fix_question", "check_riddle_or_trick")
-        
+
         builder.add_conditional_edges(
             "check_riddle_or_trick",
             lambda s: "solve_riddle" if s.get("is_riddle") else "check_wikipedia_suitability"
         )
-        
+
         builder.add_conditional_edges(
             "check_wikipedia_suitability",
             lambda s: "search_wikipedia" if s.get("is_wiki") else "check_reasoning_needed"
         )
-        
+
         builder.add_conditional_edges(
             "check_reasoning_needed",
             lambda s: "general_reasoning_qa" if s.get("needs_reasoning") else "check_python_suitability"
         )
-        
+
         builder.add_conditional_edges(
             "check_python_suitability",
             lambda s: "generate_code" if s.get("is_python") else "fallback"
         )
-        
+
         # Ends
         builder.add_edge("solve_riddle", END)
         builder.add_edge("search_wikipedia", END)
@@ -271,20 +246,16 @@ class SuperSmartAgent:
         builder.add_edge("generate_code", END)
         builder.add_edge("fallback", END)
 
-
-
-        
-  
         graph = builder.compile()
         return graph
-        
+
     def __call__(self, question: str) -> str:
-        # use self.graph to process the question
         state = {"question": question}
         result = self.graph.invoke(state)
         return result.get("response", "No answer generated.")
 
 
+
 ########################################
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """