Revert script.py to Julia original (parser v1 hurt under temp=0.8 resample)

script.py

@@ -151,176 +151,101 @@ def expected_answer_count(query: str, task_type: str) -> int:
     return len(numbered) or 1
 
 
-def _letter_tokens(text: str) -> list[str] | None:
-    """If text is only option letters (A J L … or A,J,L), return them uppercased."""
-    parts = [p.strip("().[]") for p in re.split(r"[\s,;]+", text.strip()) if p.strip()]
-    if len(parts) >= 2 and all(re.fullmatch(r"[A-Za-z]", p) for p in parts):
-        return [p.upper() for p in parts]
-    letters = re.findall(r"[A-Za-z]", text)
-    if len(letters) >= 2 and re.fullmatch(r"[A-Za-z\s,;]+", text.strip()):
-        return [c.upper() for c in letters]
-    return None
-
-
 def split_single_line_answer(text: str, expected: int, task_type: str) -> list[str]:
     text = text.strip()
-    if not text:
-        return []
+    if expected <= 1:
+        return [text]
 
-    def try_split(pattern: str, require_expected: bool) -> list[str] | None:
+    def try_split(pattern: str) -> list[str] | None:
         parts = [part.strip() for part in re.split(pattern, text) if part.strip()]
-        if require_expected:
-            return parts if len(parts) == expected else None
-        return parts if len(parts) >= 2 else None
+        return parts if len(parts) == expected else None
 
     if task_type == "match_letters":
-        letters = _letter_tokens(text)
-        if letters is not None:
-            if expected <= 1 or len(letters) == expected:
-                return letters
-            if len(letters) > expected:
-                return letters[:expected]
-            return letters
         for pattern in (r"\s+", r",\s*", r";\s*"):
-            if result := try_split(pattern, require_expected=expected > 1):
-                return [p.upper() if re.fullmatch(r"[A-Za-z]", p) else p for p in result]
+            if result := try_split(pattern):
+                return result
+        letters = re.findall(r"[A-Za-z]", text)
+        if len(letters) == expected:
+            return [letter.upper() for letter in letters]
         return [text]
 
-    # Prefer exact expected count when known; else accept any multi-way split.
-    require = expected > 1
     if task_type in ("text_to_num", "num_to_text"):
-        patterns = (r",\s*", r";\s*", r"\s+")
-    else:
-        patterns = (r";\s*", r",\s*")
-    for pattern in patterns:
-        if result := try_split(pattern, require_expected=require):
-            if expected > 1 and len(result) > expected:
-                return result[:expected]
+        for pattern in (r",\s*", r";\s*", r"\s+"):
+            if result := try_split(pattern):
+                return result
+        return [text]
+
+    for pattern in (r";\s*", r",\s*"):
+        if result := try_split(pattern):
             return result
-    # Last resort: comma/semicolon split even when expected heuristic said 1
-    # (common failure: one line with many comma-joined answers).
-    if text.count(",") >= 2 or text.count(";") >= 2:
-        for pattern in (r";\s*", r",\s*"):
-            parts = [p.strip() for p in re.split(pattern, text) if p.strip()]
-            if len(parts) >= 3:
-                return parts[:expected] if expected > 1 else parts
     return [text]
 
 
-def strip_bare_answer(ans: str, task_type: str) -> str:
-    """Remove letter-label prefixes and English gloss tails; keep bare answer forms."""
-    ans = ans.strip()
-    if not ans:
-        return ans
-
-    if task_type == "match_letters":
-        if re.fullmatch(r"[A-Za-z]", ans):
-            return ans.upper()
-        m = re.match(
-            r"^\s*(?:\(([A-Za-z])\)|\[([A-Za-z])\]|([A-Za-z]))\s*[.):\-–—]?\s*(.*)$",
-            ans,
-        )
-        if m:
-            letter = m.group(1) or m.group(2) or m.group(3)
-            rest = (m.group(4) or "").strip()
-            if not rest or len(rest) <= 2:
-                return letter.upper()
-        letters = _letter_tokens(ans)
-        if letters is not None and len(letters) == 1:
-            return letters[0]
-        return ans
-
-    # "A: Luzia is my husband." / "B) foo" / "(C) bar"
-    m = re.match(
-        r"^\s*(?:\(([A-Za-z])\)|\[([A-Za-z])\]|([A-Za-z]))\s*[.):\-–—]\s+(.+)$",
-        ans,
-    )
-    if m:
-        ans = m.group(4).strip()
-
-    # "form - to be called" / "form – English gloss"
-    # Require an English gloss cue after the dash so language-internal hyphens stay.
-    gloss = re.match(
-        r"^(.+?)\s+[-–—]\s+((?:to|the|a|an|in|of|for|being)\b.*)$",
-        ans,
-        flags=re.IGNORECASE,
-    )
-    if gloss:
-        rhs = gloss.group(2)
-        non_ascii = sum(1 for c in rhs if ord(c) > 127)
-        # Drop gloss if RHS is English-looking (few non-ASCII letters).
-        if non_ascii <= 1:
-            ans = gloss.group(1).strip()
-
-    return ans
-
-
-def repair_answer_cardinality(answers: list[str], expected: int, task_type: str) -> list[str]:
-    """Expand collapsed multi-answers; prefer matching expected count when known."""
-    if not answers:
-        return answers
-
-    # Expand any match_letters line that is still a letter cluster.
-    if task_type == "match_letters":
-        expanded: list[str] = []
-        for ans in answers:
-            letters = _letter_tokens(ans)
-            if letters is not None:
-                expanded.extend(letters)
-            elif re.fullmatch(r"[A-Za-z]", ans.strip()):
-                expanded.append(ans.strip().upper())
-            else:
-                one = strip_bare_answer(ans, task_type)
-                letters = _letter_tokens(one)
-                expanded.extend(letters if letters is not None else [one])
-        answers = expanded
-
-    if len(answers) == 1:
-        answers = split_single_line_answer(answers[0], expected, task_type)
-
-    if expected > 1 and len(answers) > expected:
-        answers = answers[:expected]
-    return answers
-
-
 def postprocess_answer(text, query, task_type):
-    """Keep only the lines after the last 'FINAL ANSWERS:' marker, one answer per line.
-    Point 1: repair cardinality (letter/comma collapses). Point 2: bare-answer cleanup."""
+    """Keep only the lines after the last 'FINAL ANSWERS:' marker, one answer per line,
+    stopping at the first empty line. If eval_type is multiple and only one line as answer, split at whitespace."""
+    # Updated regex to be more flexible with surrounding characters
     marker_match = list(re.finditer(r"(?im)^[^\w\n]*final answers?[^\w\n]*:?\s*$", text))
     if marker_match:
         text_after_marker = text[marker_match[-1].end():]
+        #print('FOUND FINAL ANSWER', text_after_marker)
     else:
+        #print("No 'FINAL ANSWERS:' marker found")
         return []
 
     answers = []
-    for line in text_after_marker.splitlines():
-        stripped_line = line.strip("`").strip()
-        if stripped_line == "":
-            continue
+    answer_lines = text_after_marker.splitlines()
+    for i, line in enumerate(answer_lines):
+        stripped_line = line.strip('`').strip()
 
-        match_numbered_prefix = re.match(r"^\s*\d+[.)]\s+(.*)", stripped_line)
-        cleaned_line = (
-            match_numbered_prefix.group(1).strip()
-            if match_numbered_prefix
-            else stripped_line
-        )
-        cleaned_line = re.sub(r"\*\*", "", cleaned_line).strip()
+        # Stop processing if an empty line is encountered (not as first line)
+        if stripped_line=='':
+          continue
 
-        if task_type == "match_letters":
-            letters = _letter_tokens(cleaned_line)
-            if letters is not None:
-                answers.extend(letters)
-                continue
-            cleaned_line = strip_bare_answer(cleaned_line, task_type)
+        # Use a more precise regex to only remove numbering if it's a prefix to other text
+        # This ensures that lines which are just numbers (e.g., '1') are not stripped.
+        match_numbered_prefix = re.match(r"^\s*\d+[.)]\s+(.*)", stripped_line)
+        if match_numbered_prefix:
+            cleaned_line = match_numbered_prefix.group(1).strip()
         else:
-            cleaned_line = strip_bare_answer(cleaned_line, task_type)
+            cleaned_line = stripped_line
 
+        # Remove any bold markdown '**'
+        cleaned_line = re.sub(r"\*\*", "", cleaned_line).strip()
+
+        # Specific handling for 'match_letters' task type to strip extra words
+        if task_type == 'match_letters':
+            parts = [
+                part.strip("().[]")
+                for part in re.split(r"[\s,;]+", cleaned_line)
+                if part.strip()
+            ]
+            if not (len(parts) > 1 and all(re.fullmatch(r"[A-Za-z]", part) for part in parts)):
+                match_letter_word = re.match(
+                    r"^\s*(?:\(([A-Za-z])\)|\[([A-Za-z])\]|([A-Za-z]))\.?:?\s*(.*)$",
+                    cleaned_line,
+                )
+                if match_letter_word:
+                    letter = (
+                        match_letter_word.group(1)
+                        or match_letter_word.group(2)
+                        or match_letter_word.group(3)
+                    )
+                    cleaned_line = letter.upper()
+
+        # Append the cleaned, non-empty line
         if cleaned_line:
             answers.append(cleaned_line)
 
+    #print('PARSED ANSWERS', answers)
+
+    # Compare against QUERY length: sometimes model forgets newlines
+    #print('QUERY', query)
     expected = expected_answer_count(query, task_type)
-    answers = repair_answer_cardinality(answers, expected, task_type)
-    answers = [strip_bare_answer(a, task_type) for a in answers if a.strip()]
+    query_len = len(query.splitlines()) - 2
+    #print(query_len)
+    if len(answers) == 1 and expected > 1:
+        answers = split_single_line_answer(answers[0], expected, task_type)
     return answers
 
 rows = []