Spaces:
Sleeping
Sleeping
| """String operation solver: reverse, case conversion, length, counting, | |
| substring extraction, and letter sorting on a quoted or clearly-delimited | |
| target string. | |
| Only fires when the operand string can be unambiguously extracted (quoted, | |
| or following a clear "the string X" / "of X" marker) and the operation is one | |
| of the supported shapes; otherwise falls through with confident=False. | |
| """ | |
| from __future__ import annotations | |
| import re | |
| from routing_agent.classifier import TaskType | |
| from routing_agent.models import Task | |
| from routing_agent.solvers import SolverResult | |
| _QUOTED_RE = re.compile(r"[\"'“”](?P<value>[^\"'“”]*)[\"'“”]") | |
| def _all_quoted_spans(prompt: str) -> list[str]: | |
| return [m.group("value") for m in _QUOTED_RE.finditer(prompt)] | |
| def _extract_target(prompt: str) -> str | None: | |
| """Extract the operand string: the *last* quoted span. | |
| Most operations have exactly one quoted span (the operand itself). The | |
| count-char-occurrences shape has two ("l" ... "hello") — the character | |
| to search for, then the source string to search in — so the last quoted | |
| span is always the operand being operated on. | |
| """ | |
| spans = _all_quoted_spans(prompt) | |
| if not spans: | |
| return None | |
| return spans[-1] | |
| # "reverse the order of the words" (or "word order") means token-reversal, | |
| # not character-reversal — checked before the generic _REVERSE_RE so the | |
| # more specific shape always wins. | |
| _REVERSE_WORD_ORDER_RE = re.compile( | |
| r"\breverse\b.*\b(order of the words|word order)\b", re.IGNORECASE | |
| ) | |
| _REVERSE_RE = re.compile(r"\breverse\b", re.IGNORECASE) | |
| _UPPER_RE = re.compile(r"\buppercase\b|\bupper[- ]?case\b", re.IGNORECASE) | |
| _LOWER_RE = re.compile(r"\blowercase\b|\blower[- ]?case\b", re.IGNORECASE) | |
| _LENGTH_RE = re.compile(r"how many (?P<unit>letters|characters)\b|\blength of\b", re.IGNORECASE) | |
| _COUNT_CHAR_RE = re.compile( | |
| r"how many (?:times does |occurrences of )?.*(?:occur|appear)", re.IGNORECASE | |
| ) | |
| _COUNT_WORD_RE = re.compile(r"how many words\b", re.IGNORECASE) | |
| _FIRST_N_RE = re.compile(r"first (?P<n>\d+) characters", re.IGNORECASE) | |
| _LAST_N_RE = re.compile(r"last (?P<n>\d+) characters", re.IGNORECASE) | |
| _SORT_RE = re.compile(r"sort the letters", re.IGNORECASE) | |
| def try_solve(task: Task, task_type: TaskType) -> SolverResult: | |
| """Attempt to solve a string-operation task on a quoted operand. | |
| Requires the target string to be explicitly quoted in the prompt (no | |
| heuristic "the rest of the sentence is the string" guessing) so the | |
| solver never mis-segments prose from the operand. | |
| """ | |
| if task_type != TaskType.STRING_OP: | |
| return SolverResult(answer=None, confident=False) | |
| prompt = task.prompt.strip() | |
| # Count-char-occurrences has two quoted spans (character, source string) | |
| # and must be checked before generic target extraction picks the wrong one. | |
| if _COUNT_CHAR_RE.search(prompt): | |
| spans = _all_quoted_spans(prompt) | |
| if len(spans) == 2 and len(spans[0]) == 1: | |
| char, source = spans | |
| return SolverResult(answer=str(source.count(char)), confident=True) | |
| return SolverResult(answer=None, confident=False) | |
| target = _extract_target(prompt) | |
| if target is None: | |
| return SolverResult(answer=None, confident=False) | |
| if _REVERSE_WORD_ORDER_RE.search(prompt): | |
| return SolverResult(answer=" ".join(reversed(target.split())), confident=True) | |
| if _REVERSE_RE.search(prompt): | |
| return SolverResult(answer=target[::-1], confident=True) | |
| if _UPPER_RE.search(prompt): | |
| return SolverResult(answer=target.upper(), confident=True) | |
| if _LOWER_RE.search(prompt): | |
| return SolverResult(answer=target.lower(), confident=True) | |
| first_n_match = _FIRST_N_RE.search(prompt) | |
| if first_n_match: | |
| n = int(first_n_match.group("n")) | |
| return SolverResult(answer=target[:n], confident=True) | |
| last_n_match = _LAST_N_RE.search(prompt) | |
| if last_n_match: | |
| n = int(last_n_match.group("n")) | |
| return SolverResult(answer=target[-n:] if n > 0 else "", confident=True) | |
| if _COUNT_WORD_RE.search(prompt): | |
| word_count = len(target.split()) | |
| return SolverResult(answer=str(word_count), confident=True) | |
| if _LENGTH_RE.search(prompt): | |
| return SolverResult(answer=str(len(target)), confident=True) | |
| if _SORT_RE.search(prompt): | |
| return SolverResult(answer="".join(sorted(target)), confident=True) | |
| return SolverResult(answer=None, confident=False) | |