Update app.py

app.py

@@ -16,7 +16,7 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        
+
     def __call__(self, question: str, files=None) -> str:
         """
         files: list of (filename, bytes) tuples. May be None/empty.
@@ -25,33 +25,76 @@ class BasicAgent:
         print(f"Agent received question (first 50 chars): {q[:50]}...")
         if files:
             print("Received files:", [f for f, _ in files])
-        op = self._guess_op(q)      
-        col = self._guess_col(q)
-        if files and op and col:
+
+        op  = self._guess_op(q)    # "sum" | "min" | "max" | "avg" | None
+        col = self._guess_col(q)   # tries to extract a column name
+
+        # ---------- FILES: Excel / CSV / TSV ----------
+        if files:
             for fname, blob in files:
                 low = fname.lower()
-                if low.endswith(".csv") or low.endswith(".tsv"):
+
+                # 1) Excel
+                if low.endswith((".xlsx", ".xls")):
+                    try:
+                        df = pd.read_excel(io.BytesIO(blob), sheet_name=0, engine=None)
+                        # Special: "total sales from food (not including drinks)"
+                        if self._asks_food_not_drinks(q):
+                            total = self._sum_food_excluding_drinks(df)
+                            if total is not None:
+                                return f"{total:.2f}"
+                        # Generic ops on a named column
+                        if op and col:
+                            val = self._op_on_column(df, col, op)
+                            if val is not None:
+                                return self._fmt(val)
+                    except Exception as e:
+                        print(f"Excel read failed for {fname}: {e}")
+
+                # 2) CSV/TSV
+                elif low.endswith(".csv") or low.endswith(".tsv"):
                     sep = "\t" if low.endswith(".tsv") else ","
                     try:
                         df = pd.read_csv(io.BytesIO(blob), sep=sep)
-                        if col in df.columns:
-                            s = pd.to_numeric(df[col], errors="coerce").dropna()
-                            if len(s):
-                                return self._apply_op(op, s)
-                        # loose match if exact not found
-                        match = self._fuzzy_find_col(col, df.columns)
-                        if match:
-                            s = pd.to_numeric(df[match], errors="coerce").dropna()
-                            if len(s):
-                                return self._apply_op(op, s)
+                        # Special: "total sales from food (not including drinks)"
+                        if self._asks_food_not_drinks(q):
+                            total = self._sum_food_excluding_drinks(df)
+                            if total is not None:
+                                return f"{total:.2f}"
+                        # Generic ops on a named column
+                        if op and col:
+                            val = self._op_on_column(df, col, op)
+                            if val is not None:
+                                return self._fmt(val)
                     except Exception as e:
-                        print(f"CSV read failed for {fname}: {e}")
+                        print(f"CSV/TSV read failed for {fname}: {e}")
+
+        # ---------- TEXT-ONLY FALLBACKS ----------
+        # trivial arithmetic like "what is 12 + 7"
+        m = re.search(r"(?i)\bwhat\s+is\s+(\d+)\s*([+\-*/x])\s*(\d+)\b", q)
+        if not m:
+            m = re.search(r"\b(\d+)\s*([+\-*/x])\s*(\d+)\b", q)
+        if m:
+            a, opchar, b = int(m.group(1)), m.group(2).lower(), int(m.group(3))
+            if opchar in ("x", "*"): return str(a * b)
+            if opchar == "+":        return str(a + b)
+            if opchar == "-":        return str(a - b)
+            if opchar == "/":        return "undefined" if b == 0 else (str(int(a/b)) if (a/b).is_integer() else str(a/b))
 
-        # Fallback: default answer (replace with your real logic next)
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        # min/max/sum/avg over numbers present in the question itself
+        nums = [int(x) for x in re.findall(r"\b\d+\b", q)]
+        if nums:
+            if re.search(r"(?i)\b(min|minimum|smallest|lowest)\b", q): return str(min(nums))
+            if re.search(r"(?i)\b(max|maximum|largest|highest)\b", q): return str(max(nums))
+            if re.search(r"(?i)\b(sum|total|added up)\b", q):          return str(sum(nums))
+            if re.search(r"(?i)\b(avg|average|mean)\b", q):
+                avg = sum(nums) / len(nums)
+                return str(int(avg)) if float(avg).is_integer() else f"{avg:.2f}"
 
+        # Final fallback
+        return "This is a default answer."
+
+    # ----------------- Helpers -----------------
     def _guess_op(self, q: str):
         if re.search(r"(?i)\b(sum|total|added up)\b", q): return "sum"
         if re.search(r"(?i)\b(min|minimum|smallest|lowest)\b", q): return "min"
@@ -70,18 +113,72 @@ class BasicAgent:
         wl = (wanted or "").lower()
         for c in cols:
             s = str(c)
-            if s.lower() == wl: return s
+            if s.lower() == wl:
+                return s
         for c in cols:
             s = str(c)
-            if wl in s.lower(): return s
+            if wl in s.lower():
+                return s
+        return None
+
+    def _op_on_column(self, df: pd.DataFrame, col: str, op: str):
+        target = col if col in df.columns else self._fuzzy_find_col(col, df.columns)
+        if not target:
+            return None
+        s = pd.to_numeric(df[target], errors="coerce").dropna()
+        if s.empty:
+            return None
+        if op == "sum": return s.sum()
+        if op == "min": return s.min()
+        if op == "max": return s.max()
+        if op == "avg": return s.mean()
         return None
 
-    def _apply_op(self, op, series):
-        if op == "sum": return self._fmt(series.sum())
-        if op == "min": return self._fmt(series.min())
-        if op == "max": return self._fmt(series.max())
-        if op == "avg": return self._fmt(series.mean())
-        return "unknown"
+    def _asks_food_not_drinks(self, q: str) -> bool:
+        # matches questions like: "total sales from food (not including drinks)"
+        return bool(
+            re.search(r"(?i)total\s+sales.*food.*not.*drink", q) or
+            re.search(r"(?i)food.*not.*drink", q)
+        )
+
+    def _sum_food_excluding_drinks(self, df: pd.DataFrame):
+        # 1) Try find a categorical column
+        cat_col = None
+        for c in df.columns:
+            cl = str(c).lower()
+            if any(k in cl for k in ["category", "type", "group", "item", "product", "menu", "name"]):
+                cat_col = c
+                break
+
+        # 2) Try find a numeric money column
+        money_col = None
+        for c in df.columns:
+            cl = str(c).lower()
+            if any(k in cl for k in ["sales", "revenue", "amount", "total", "usd", "price", "value"]):
+                money_col = c
+                break
+        if money_col is None:
+            for c in df.columns:
+                s = pd.to_numeric(df[c], errors="coerce")
+                if s.notna().sum() >= max(3, int(0.5 * len(df))):
+                    money_col = c
+                    break
+        if money_col is None:
+            return None
+
+        mask = pd.Series([True] * len(df))
+        if cat_col is not None:
+            cats = df[cat_col].astype(str).str.lower()
+            exclude_words = ["drink", "beverage", "soda", "juice", "coffee", "tea", "cola", "water"]
+            include_words = ["food", "burger", "sandwich", "fries", "salad", "wrap", "meal",
+                             "nugget", "chicken", "beef", "fish", "pizza", "dessert"]
+            ex_mask = cats.str.contains("|".join(exclude_words), na=False)
+            in_mask = cats.str.contains("|".join(include_words), na=False)
+            mask = (~ex_mask) & (in_mask | True)  # keep non-drinks even if not explicitly labeled as food
+
+        s_money = pd.to_numeric(df[money_col], errors="coerce")
+        total = s_money[mask].dropna().sum()
+        return float(total) if pd.notna(total) else None
 
     def _fmt(self, x):
         try:
@@ -90,6 +187,7 @@ class BasicAgent:
         except Exception:
             return str(x)
 
+
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,