Datasets:

chenpanli
/

integrals

"""Answer extraction from raw model responses.
Separated from :mod:`pattern_parser` (which is a generic brace scanner) so that
extraction *outcomes* are first-class: "the API returned nothing", "the model
never wrote a box", and "the box was truncated mid-brace" are kept apart rather
than collapsed into one undifferentiated parse-error counter, which would hide
whether a failure was a client timeout or bad model output.
"""
from __future__ import annotations

import re
from dataclasses import dataclass
from enum import Enum

from .pattern_parser import PatternParseError, parse_command_braces

# Tolerant of the whitespace mangling seen in byte-BPE-corrupted outputs, where
# "FINAL ANSWER" arrives as "FINALĠANSWER" or with the space removed entirely.
_FINAL_ANSWER = re.compile(r"FINAL\W{0,4}ANSWER", re.IGNORECASE)


class ExtractionStatus(str, Enum):
    OK = "ok"
    EMPTY = "empty"              # API returned nothing (timeout, retries exhausted)
    NO_BOXED = "no_boxed"        # text produced, but no \boxed{} anywhere
    UNBALANCED = "unbalanced"    # \boxed{ opened and never closed (truncation)
    # Produced only by llm.core.mcq.extraction, whose contract is an answer
    # *line* rather than a box: text was produced, but nothing in it -- no
    # marker, no box, no option letter at the end -- named an option. It lives
    # here rather than in a second enum so the trace writer, the sentinel tables
    # and every `frac_<reason>` metric keep switching on one type.
    NO_ANSWER = "no_answer"


@dataclass
class ExtractResult:
    status: ExtractionStatus
    value: str = ""
    n_matches: int = 0
    chosen_index: int | None = None
    detail: str = ""


def extract_boxed(text: str | None, *, prefer_final_answer: bool = False) -> ExtractResult:
    """Pull the answer out of a raw model response.
    By default returns the **last** ``\\boxed{}``, which is what makes this
    robust to reasoning traces that box intermediate results.
    With ``prefer_final_answer``, the first box appearing after a
    ``FINAL ANSWER`` marker wins, falling back to the last box when there is no
    marker. Running both strategies as separate lm-eval filter ensembles scores
    them side by side, which is how the cost of template-bleed is measured.
    """
    if text is None or not str(text).strip():
        return ExtractResult(ExtractionStatus.EMPTY, detail="response was empty or None")

    text = str(text)

    if prefer_final_answer:
        marker = None
        for marker in _FINAL_ANSWER.finditer(text):
            pass  # keep the last marker; models often restate the instruction first
        if marker is not None:
            tail = text[marker.end():]
            try:
                boxes = parse_command_braces(tail, command="boxed")
            except PatternParseError:
                boxes = []
            if boxes:
                return ExtractResult(ExtractionStatus.OK, boxes[0].strip(),
                                     n_matches=len(boxes), chosen_index=0,
                                     detail="first box after FINAL ANSWER")

    try:
        boxes = parse_command_braces(text, command="boxed")
    except PatternParseError as exc:
        return ExtractResult(ExtractionStatus.UNBALANCED, detail=str(exc))

    if not boxes:
        if "\\boxed" in text:
            # The command is present but never opened a brace group.
            return ExtractResult(ExtractionStatus.UNBALANCED,
                                 detail="\\boxed present but no brace group followed")
        return ExtractResult(ExtractionStatus.NO_BOXED, detail="no \\boxed{} in response")

    return ExtractResult(ExtractionStatus.OK, boxes[-1].strip(),
                         n_matches=len(boxes), chosen_index=len(boxes) - 1,
                         detail="last box")

	"""Answer extraction from raw model responses.

	Separated from :mod:`pattern_parser` (which is a generic brace scanner) so that
	extraction outcomes are first-class: "the API returned nothing", "the model
	never wrote a box", and "the box was truncated mid-brace" are kept apart rather
	than collapsed into one undifferentiated parse-error counter, which would hide
	whether a failure was a client timeout or bad model output.
	"""
	from __future__ import annotations

	import re
	from dataclasses import dataclass
	from enum import Enum

	from .pattern_parser import PatternParseError, parse_command_braces

	# Tolerant of the whitespace mangling seen in byte-BPE-corrupted outputs, where
	# "FINAL ANSWER" arrives as "FINALĠANSWER" or with the space removed entirely.
	_FINAL_ANSWER = re.compile(r"FINAL\W{0,4}ANSWER", re.IGNORECASE)


	class ExtractionStatus(str, Enum):
	OK = "ok"
	EMPTY = "empty" # API returned nothing (timeout, retries exhausted)
	NO_BOXED = "no_boxed" # text produced, but no \boxed{} anywhere
	UNBALANCED = "unbalanced" # \boxed{ opened and never closed (truncation)
	# Produced only by llm.core.mcq.extraction, whose contract is an answer
	# line rather than a box: text was produced, but nothing in it -- no
	# marker, no box, no option letter at the end -- named an option. It lives
	# here rather than in a second enum so the trace writer, the sentinel tables
	# and every `frac_<reason>` metric keep switching on one type.
	NO_ANSWER = "no_answer"


	@dataclass
	class ExtractResult:
	status: ExtractionStatus
	value: str = ""
	n_matches: int = 0
	chosen_index: int \| None = None
	detail: str = ""


	def extract_boxed(text: str \| None, *, prefer_final_answer: bool = False) -> ExtractResult:
	"""Pull the answer out of a raw model response.

	By default returns the last ``\\boxed{}``, which is what makes this
	robust to reasoning traces that box intermediate results.

	With ``prefer_final_answer``, the first box appearing after a
	``FINAL ANSWER`` marker wins, falling back to the last box when there is no
	marker. Running both strategies as separate lm-eval filter ensembles scores
	them side by side, which is how the cost of template-bleed is measured.
	"""
	if text is None or not str(text).strip():
	return ExtractResult(ExtractionStatus.EMPTY, detail="response was empty or None")

	text = str(text)

	if prefer_final_answer:
	marker = None
	for marker in _FINAL_ANSWER.finditer(text):
	pass # keep the last marker; models often restate the instruction first
	if marker is not None:
	tail = text[marker.end():]
	try:
	boxes = parse_command_braces(tail, command="boxed")
	except PatternParseError:
	boxes = []
	if boxes:
	return ExtractResult(ExtractionStatus.OK, boxes[0].strip(),
	n_matches=len(boxes), chosen_index=0,
	detail="first box after FINAL ANSWER")

	try:
	boxes = parse_command_braces(text, command="boxed")
	except PatternParseError as exc:
	return ExtractResult(ExtractionStatus.UNBALANCED, detail=str(exc))

	if not boxes:
	if "\\boxed" in text:
	# The command is present but never opened a brace group.
	return ExtractResult(ExtractionStatus.UNBALANCED,
	detail="\\boxed present but no brace group followed")
	return ExtractResult(ExtractionStatus.NO_BOXED, detail="no \\boxed{} in response")

	return ExtractResult(ExtractionStatus.OK, boxes[-1].strip(),
	n_matches=len(boxes), chosen_index=len(boxes) - 1,
	detail="last box")