Update app.py

app.py

@@ -4,21 +4,108 @@ import requests
 import inspect
 import pandas as pd
 
+from langgraph.graph import StateGraph, END
+
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+# class BasicAgent:
+#    def __init__(self):
+#        print("BasicAgent initialized.")
+#    def __call__(self, question: str) -> str:
+#        print(f"Agent received question (first 50 chars): {question[:50]}...")
+#        fixed_answer = "This is a default answer."
+#        print(f"Agent returning fixed answer: {fixed_answer}")
+#        return fixed_answer
+
+class SuperSmartAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        self.graph = self._build_graph()
+
+    def _build_graph(self):
+    ############## NODES ###################
+    def check_reversed(state):
+        question = state["question"]
+        reversed_text = question[::-1]
+        if reversed_text.count(' ') > question.count(' '):
+            state["is_reversed"] = True
+        else:
+            state["is_reversed"] = False
+        return state
+    
+    def fix_question(state):
+        if state["is_reversed"]:
+            state["question"] = state["question"][::-1]
+        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
+        return state
+    
+    def generate_code(state):
+        q = state["question"].lower()
+        if "sum" in q:
+            state["response"] = "numbers = [1, 2, 3]\nprint(sum(numbers))"
+        elif "average" in q:
+            state["response"] = "numbers = [1, 2, 3]\nprint(sum(numbers) / len(numbers))"
+        elif "sort" in q:
+            state["response"] = "data = [3, 1, 2]\ndata.sort()\nprint(data)"
+        else:
+            state["response"] = "# Code generation not implemented for this case."
+        return state
+    
+    def fallback(state):
+        state["response"] = "This question doesn't require Python or is unclear."
+        return state
+    
+        # State schema
+        state_schema = {
+            "question": str,
+            "is_reversed": bool,
+            "is_python": bool,
+            "response": str,
+        }
+    
+        builder = StateGraph(state_schema)
+        
+        # Nodes
+        builder.add_node("check_reversed", check_reversed)
+        builder.add_node("fix_question", fix_question)
+        builder.add_node("check_python_suitability", check_python_suitability)
+        builder.add_node("generate_code", generate_code)
+        builder.add_node("fallback", fallback)
+        
+        # Edges
+        builder.set_entry_point("check_reversed")
+        builder.add_edge("check_reversed", "fix_question")
+        builder.add_edge("fix_question", "check_python_suitability")
+        builder.add_conditional_edges(
+            "check_python_suitability",
+            lambda s: "generate_code" if s["is_python"] else "fallback"
+        )
+        builder.add_edge("generate_code", END)
+        builder.add_edge("fallback", END)
+        
+        
+        graph = builder.compile()
+    
+        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):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
@@ -40,7 +127,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = SuperSmartAgent() #BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None