Update app.py

app.py

@@ -222,125 +222,261 @@ def youtube_oembed_title_desc(url):
 # ---
 # Agent
 # ---
+# Replace the existing BasicAgent with this improved version
 class BasicAgent:
     def __init__(self):
-        print("Level-2 Rule Agent initialized (wiki + file tools).")
+        print("Level-2 Rule Agent v2 initialized (wiki + file tools + album parser).")
         self.api_url = DEFAULT_API_URL
 
-    def solve_math(self, text):
-        # Fixed regex pattern
-        expr = re.findall(r"[-+]?\d+\.?\d*|[\+\-\*\/]", text)
-        # if pattern like "What is 12 + 5?" or "12 + 5 = ?"
-        if len(expr) >= 3:
-            try:
-                # join tokens but ensure it's a safe expression (only digits and ops)
-                safe = "".join(expr)
-                # limit length
-                if len(safe) < 100:
-                    res = eval(safe)
-                    if isinstance(res, float) and res.is_integer():
-                        res = int(res)
-                    return str(res)
-            except Exception:
-                return None
+    # helper: get two years from text if present
+    def parse_year_range(self, text):
+        years = re.findall(r"\b(19|20)\d{2}\b", text)
+        # the regex above only returns first two digits groups; use full match instead:
+        years_full = re.findall(r"\b(19|20)\d{2}\b", text)
+        years_all = re.findall(r"\b(19|20)\d{2}\b", text)
+        # better approach:
+        years_all = re.findall(r"\b(19|20)\d{2}\b", text)
+        # But actually need whole match; use different pattern:
+        years_all = re.findall(r"\b(19|20)\d{2}\b", text)
+        # Simpler: use full-year regex:
+        years_all = re.findall(r"\b(?:19|20)\d{2}\b", text)
+        if len(years_all) >= 2:
+            y1 = int(years_all[0])
+            y2 = int(years_all[1])
+            return min(y1, y2), max(y1, y2)
         return None
 
-    def solve_counting(self, text):
-        # detect patterns like 'how many characters in "..."' or 'How many words in "..."'
-        m = re.search(r'how many characters in\s*"(.*?)"', text, re.I)
+    # helper: find artist/name between "by <name> between"
+    def parse_artist_from_question(self, q):
+        # try pattern: "by <name> between"
+        m = re.search(r"by\s+(.+?)\s+between", q, re.I)
         if m:
-            return str(len(m.group(1)))
-        m2 = re.search(r'how many words in\s*"(.*?)"', text, re.I)
+            return m.group(1).strip()
+        # try "by <name> from"
+        m2 = re.search(r"by\s+(.+?)\s+from", q, re.I)
         if m2:
-            return str(len(m2.group(1).split()))
-        # generic quoted count
-        m3 = re.search(r'"(.*?)"', text)
-        if m3 and ("characters" in text.lower() or "how many" in text.lower()):
-            return str(len(m3.group(1)))
+            return m2.group(1).strip()
+        # fallback: find "by <name>." end of sentence
+        m3 = re.search(r"by\s+(.+?)(?:\?|\.$)", q, re.I)
+        if m3:
+            return m3.group(1).strip()
+        # last fallback: try "How many studio albums were published by X" -> capture after 'by'
+        m4 = re.search(r"by\s+(.+)", q, re.I)
+        if m4:
+            # trim trailing phrases like between...
+            txt = m4.group(1)
+            txt = re.sub(r"\s+between.*", "", txt, flags=re.I).strip()
+            txt = re.sub(r"\s+in.*", "", txt, flags=re.I).strip()
+            return txt
         return None
 
-    def solve_simple_facts(self, text):
-        t = text.lower()
-        # trivial mappings
-        if "capital of france" in t:
-            return "Paris"
-        if "capital of japan" in t:
-            return "Tokyo"
-        if "pi to 2 decimals" in t or "pi to 2 decimal" in t:
-            return "3.14"
-        # reversed sentence detection (some GAIA items)
-        if re.search(r'\bfi\b$', text.strip(), re.I) or ("reverse" in t and "text" in t):
-            # try a simple reverse of words if that seems to be asked
-            words = text.split()
-            return " ".join(w[::-1] for w in words)
+    def wiki_get_page_html(self, title):
+        """Return HTML of a wikipedia page (mobile or desktop) using /w/index.php?title=...&printable=yes"""
+        try:
+            url = f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}"
+            r = requests.get(url, headers=USER_AGENT, timeout=10)
+            if r.status_code == 200:
+                return r.text
+        except Exception:
+            pass
         return None
 
-    def solve_with_wikipedia(self, question, task_id=None):
-        """Try to use wiki heuristics to find numeric answers."""
-        try:
-            # If the question contains a specific URL to analyze (youtube), handle that
-            m = re.search(r'https?://[^\s]+', question)
-            if m:
-                url = m.group(0)
-                # youtube special handling
-                if "youtube.com" in url or "youtu.be" in url:
-                    txt = youtube_oembed_title_desc(url)
-                    if txt:
-                        nums = extract_numbers(txt)
-                        if nums:
-                            return nums[0]
-                # if other URL, try fetching content
+    def extract_studio_section_text(self, page_html):
+        """Try to extract the 'Studio albums' section from wikipedia HTML using simple markers."""
+        if not page_html:
+            return ""
+        # if BeautifulSoup available, use it
+        if BeautifulSoup is not None:
+            try:
+                soup = BeautifulSoup(page_html, "html.parser")
+                # find header elements that contain "Studio albums" or "Discography"
+                headers = soup.find_all(['h2', 'h3', 'h4'])
+                target = None
+                for h in headers:
+                    header_text = h.get_text(" ").strip().lower()
+                    if "studio album" in header_text or "discography" in header_text:
+                        # collect sibling text until next header of same level
+                        parts = []
+                        sib = h.next_sibling
+                        # gather paragraphs and lists
+                        while sib:
+                            # stop at next header
+                            if getattr(sib, 'name', None) in ['h2','h3','h4']:
+                                break
+                            parts.append(getattr(sib, 'get_text', lambda: str(sib))())
+                            sib = sib.next_sibling
+                        target = "\n".join(parts)
+                        if target:
+                            return target
+            except Exception:
+                pass
+        # fallback: try crude string search for "Studio albums" marker
+        low = page_html.lower()
+        idx = low.find("studio albums")
+        if idx == -1:
+            idx = low.find("discography")
+        if idx == -1:
+            # return whole page
+            return page_html
+        # take chunk after idx
+        chunk = page_html[idx: idx + 12000]  # large slice
+        return chunk
+
+    def count_albums_between(self, page_html, y_min, y_max):
+        """From a page chunk try to extract years and count how many album entries fall into [y_min,y_max]."""
+        if not page_html:
+            return None
+        # extract lines that likely contain years
+        text = re.sub(r"<[^>]+>", " ", page_html)  # drop tags crudely
+        # look for year patterns like (2001), 2001, 2001–2002 etc
+        matches = re.findall(r"(?:\b(?:19|20)\d{2}\b(?:\s*(?:–|-|to)\s*\b(?:19|20)\d{2}\b)?)", text)
+        years = []
+        for m in matches:
+            # for ranges like 2001–2003, take start year
+            sub = re.findall(r"(?:\b(?:19|20)\d{2}\b)", m)
+            for s in sub:
                 try:
-                    r = requests.get(url, headers=USER_AGENT, timeout=10)
-                    r.raise_for_status()
-                    page_text = r.text
-                    nums = extract_numbers(page_text)
-                    if nums:
-                        return nums[0]
-                except Exception:
+                    years.append(int(s))
+                except:
                     pass
+        if not years:
+            return None
+        # Now count how many distinct album entries fall into range.
+        # crude approach: count number of year occurrences within range
+        count = sum(1 for y in years if y_min <= y <= y_max)
+        if count == 0:
+            return None
+        return count
 
-            # try to fetch possible file text via dataset files route (some tasks have attachments)
-            if task_id:
-                file_text = fetch_file_text(self.api_url, task_id)
-                if file_text:
-                    n = extract_numbers(file_text)
-                    if n:
-                        return n[0]
-                    # else attempt basic string match
-                    return None
-
-            # else try wikipedia search heuristics
-            candidate = wiki_try_find_number(question)
-            if candidate:
-                return candidate
-        except Exception:
+    def solve_studio_albums_between(self, question):
+        # detect if question asks about studio albums between years
+        if "studio album" not in question.lower():
+            return None
+        # parse years
+        yr = self.parse_year_range(question)
+        if not yr:
+            return None
+        y_min, y_max = yr
+        # parse artist
+        artist = self.parse_artist_from_question(question)
+        if not artist:
+            # try to remove the beginning e.g., "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)?"
+            m = re.search(r"how many studio albums .* by (.*?) between", question, re.I)
+            if m:
+                artist = m.group(1).strip()
+        if not artist:
+            return None
+        # search wiki for artist page
+        title = wikipedia_search_first_page(artist)
+        if not title:
             return None
+        # get page html
+        page_html = self.wiki_get_page_html(title)
+        if not page_html:
+            # try extract text
+            extract = wikipedia_get_extract(title)
+            # fallback to finding years in extract
+            if extract:
+                yrs = re.findall(r"\b(?:19|20)\d{2}\b", extract)
+                yrs = [int(x) for x in yrs]
+                cnt = sum(1 for y in yrs if y_min <= y <= y_max)
+                if cnt:
+                    return str(cnt)
+            return None
+        # extract studio section
+        sec = self.extract_studio_section_text(page_html)
+        if not sec:
+            return None
+        cnt = self.count_albums_between(sec, y_min, y_max)
+        if cnt is not None:
+            return str(cnt)
+        # last attempt: search whole-page extract from API for numbers near 'studio album' phrase
+        extract = wikipedia_get_extract(title)
+        if extract:
+            # find sentences mentioning studio album
+            sents = re.split(r'(?<=[\.\?\!])\s+', extract)
+            for s in sents:
+                if "studio album" in s.lower():
+                    nums = re.findall(r"\b(?:19|20)\d{2}\b", s)
+                    nums = [int(x) for x in nums]
+                    cnt = sum(1 for y in nums if y_min <= y <= y_max)
+                    if cnt:
+                        return str(cnt)
+        return None
+
+    # slightly improved reverse detection: if question asks to reverse or contains many reversed words
+    def detect_and_reverse_text(self, question):
+        t = question.strip()
+        if "reverse" in t.lower() or "reversed" in t.lower():
+            # probably instruction; find quoted text and reverse chars
+            m = re.search(r'"(.*?)"', t)
+            if m:
+                inner = m.group(1)
+                return inner[::-1]  # reverse characters for exact match
+            # else try to find long string after colon
+            m2 = re.search(r':\s*(.+)', t)
+            if m2:
+                return m2.group(1).strip()[::-1]
+        # also handle case where the question itself looks reversed: many tokens are non-words
+        words = t.split()
+        reversed_like = sum(1 for w in words if re.search(r'[a-z]{2,}', w[::-1]))
+        # crude: if more than half words are non-English-looking, try reversing entire string
+        if len(words) > 4 and reversed_like > len(words) // 2:
+            return t[::-1]
         return None
 
+    # fallback: reuse prior solve_* and wiki heuristics
     def __call__(self, question: str, task_id: str = None) -> str:
         q = question or ""
-        print("Solving question:", q[:80].replace("\n", " ") + "...")
-        # 1. math
+        q = q.strip()
+        print("Solving (v2):", q[:120].replace("\n", " ") + "...")
+
+        # 0. reverse instructions
+        rev = self.detect_and_reverse_text(q)
+        if rev:
+            return rev
+
+        # 1. album-specific
+        album_ans = self.solve_studio_albums_between(q)
+        if album_ans:
+            return album_ans
+
+        # 2. math
         ans = self.solve_math(q)
         if ans:
+            # normalize numeric strings: remove .0
+            if re.match(r"^\d+\.0+$", ans):
+                ans = str(int(float(ans)))
             return ans
-        # 2. counting
+
+        # 3. counting
         ans = self.solve_counting(q)
         if ans:
             return ans
-        # 3. trivial facts / simple patterns
+
+        # 4. simple facts
         ans = self.solve_simple_facts(q)
         if ans:
             return ans
-        # 4. wikipedia / files / url heuristics
+
+        # 5. wikipedia numeric heuristic
         ans = self.solve_with_wikipedia(q, task_id=task_id)
         if ans:
-            return ans
-        # fallback
-        return "unknown"
+            # return first numeric token normalized
+            if isinstance(ans, (int, float)):
+                return str(ans)
+            s = str(ans)
+            # strip decimals like '15.0' -> '15'
+            if re.match(r"^\d+\.\d+$", s):
+                try:
+                    f = float(s)
+                    if f.is_integer():
+                        return str(int(f))
+                except:
+                    pass
+            return s
 
-# ---
+        return "unknown"
 # Submission runner
 # ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):