Update conversation_logic.py

conversation_logic.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import re
+from fractions import Fraction
 from typing import Any, Dict, List, Optional
 
-from context_parser import mentions_choice_letter, user_is_referring_to_existing_question
+from context_parser import mentions_choice_letter
 from formatting import format_reply
 from models import SolverResult
 from quant_solver import extract_choices, is_quant_question, solve_quant
@@ -28,16 +30,24 @@ class ResponseContext:
     @property
     def combined_question_block(self) -> str:
         parts: List[str] = []
-
         if self.question_text:
             parts.append(self.question_text)
-
         if self.options_text:
             parts.append(self.options_text)
-
         return "\n".join(parts).strip()
 
 
+def normalize_text(s: str) -> str:
+    return (s or "").strip().lower()
+
+
+def get_last_assistant_message(chat_history: List[Dict[str, Any]]) -> str:
+    for item in reversed(chat_history or []):
+        if str(item.get("role", "")).strip().lower() == "assistant":
+            return str(item.get("text", "")).strip()
+    return ""
+
+
 def build_choice_explanation(
     chosen_letter: str,
     result: SolverResult,
@@ -72,26 +82,158 @@ def build_choice_explanation(
     return f"Yes — it’s {chosen_letter}."
 
 
-def get_last_assistant_message(chat_history: List[Dict[str, Any]]) -> str:
-    for item in reversed(chat_history or []):
-        if str(item.get("role", "")).strip().lower() == "assistant":
-            return str(item.get("text", "")).strip()
-    return ""
+def parse_percent_value(text: str) -> Optional[int]:
+    m = re.search(r"(\d+(?:\.\d+)?)\s*%", text or "")
+    if not m:
+        return None
+    try:
+        value = float(m.group(1))
+        if value.is_integer():
+            return int(value)
+        return None
+    except Exception:
+        return None
 
 
-def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Optional[SolverResult]:
-    user_text = ctx.visible_user_text
-    lower = user_text.lower().strip()
-    question_block = ctx.combined_question_block
+def percent_to_fraction_text(percent_value: int) -> str:
+    frac = Fraction(percent_value, 100)
+    return f"{frac.numerator}/{frac.denominator}"
+
+
+def find_matching_choice_for_value(options_text: str, target_value: str) -> Optional[str]:
+    for line in (options_text or "").splitlines():
+        m = re.match(r"\s*([A-E])\)\s*(.+?)\s*$", line.strip(), re.IGNORECASE)
+        if not m:
+            continue
+        letter = m.group(1).upper()
+        value = m.group(2).strip()
+        if value == target_value:
+            return letter
+    return None
+
+
+def handle_percent_fraction_question(ctx: ResponseContext, help_mode: str) -> Optional[SolverResult]:
+    q = ctx.question_text
+    u = normalize_text(ctx.visible_user_text)
+
+    combined = f"{q}\n{ctx.options_text}".lower()
+
+    mentions_fraction_task = (
+        "this equals" in combined
+        or "as a fraction" in combined
+        or "fraction" in combined
+        or "pie chart" in combined
+        or "%" in combined
+    )
+
+    if not mentions_fraction_task:
+        return None
+
+    percent_value = parse_percent_value(q) or parse_percent_value(ctx.visible_user_text)
+    if percent_value is None:
+        return None
+
+    fraction_text = percent_to_fraction_text(percent_value)
+    answer_letter = find_matching_choice_for_value(ctx.options_text, fraction_text)
+
+    asking_task = (
+        "what is the question asking" in u
+        or "what is this asking" in u
+        or "what do i need to do" in u
+    )
+
+    asking_hint = (
+        "hint" in u
+        or "how do i start" in u
+        or "first step" in u
+        or "what do i do first" in u
+        or "can you help" in u
+        or u in {"help", "help me", "i dont get it", "i don't get it"}
+    )
+
+    asking_answer = (
+        "answer" in u
+        or "which one" in u
+        or "what answer" in u
+        or "what is 25% as a fraction" in u
+        or "are you sure" in u
+    )
+
+    if asking_task:
+        reply = "It is asking you to convert 25% into an equivalent fraction and then match it to the correct option."
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=False,
+            help_mode="hint",
+            answer_letter=answer_letter,
+            answer_value=fraction_text,
+        )
+
+    if asking_hint or help_mode == "hint":
+        reply = (
+            "Think of percent as 'out of 100'.\n"
+            f"So {percent_value}% means {percent_value}/100.\n"
+            "Then simplify that fraction and compare it with the options."
+        )
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode="hint",
+            answer_letter=answer_letter,
+            answer_value=fraction_text,
+        )
+
+    if asking_answer or help_mode == "answer":
+        if answer_letter:
+            reply = f"{percent_value}% = {percent_value}/100 = {fraction_text}, so the correct answer is {answer_letter}."
+        else:
+            reply = f"{percent_value}% = {percent_value}/100 = {fraction_text}."
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode="answer",
+            answer_letter=answer_letter,
+            answer_value=fraction_text,
+        )
 
+    if help_mode == "walkthrough":
+        if answer_letter:
+            reply = (
+                f"Percent means 'per 100', so {percent_value}% = {percent_value}/100.\n"
+                f"Simplify {percent_value}/100 to {fraction_text}.\n"
+                f"Now compare that with the options: {fraction_text} matches choice {answer_letter}."
+            )
+        else:
+            reply = (
+                f"Percent means 'per 100', so {percent_value}% = {percent_value}/100.\n"
+                f"Simplify {percent_value}/100 to {fraction_text}."
+            )
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode="walkthrough",
+            answer_letter=answer_letter,
+            answer_value=fraction_text,
+        )
+
+    return None
+
+
+def handle_choice_letter_followup(ctx: ResponseContext, help_mode: str) -> Optional[SolverResult]:
+    question_block = ctx.combined_question_block
     if not question_block:
         return None
 
-    if not user_is_referring_to_existing_question(user_text, ctx.question_text):
+    user_text = ctx.visible_user_text
+    asked_letter = mentions_choice_letter(user_text)
+    if not asked_letter:
         return None
 
     solved = solve_quant(question_block, "answer")
-    asked_letter = mentions_choice_letter(user_text)
     choices = extract_choices(question_block)
 
     if asked_letter and solved.answer_letter and asked_letter == solved.answer_letter:
@@ -107,7 +249,6 @@ def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Opti
 
     if asked_letter and solved.answer_letter and asked_letter != solved.answer_letter:
         correct_choice_text = choices.get(solved.answer_letter, "").strip()
-
         if help_mode == "hint":
             reply = f"Check the calculation again and compare your result with choice {solved.answer_letter}, not {asked_letter}."
         elif help_mode == "walkthrough":
@@ -128,25 +269,31 @@ def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Opti
             answer_value=solved.answer_value,
         )
 
-    if "what is the question asking" in lower or "what is this asking" in lower:
-        category = ctx.question_category.lower()
-        question_text = ctx.question_text
+    return None
 
-        if "variability" in question_text.lower() or "data" in category:
-            reply = (
-                "It is asking you to compare how spread out each dataset is and decide which one varies the most."
-            )
-        else:
-            reply = (
-                "It is asking you to identify the main task, extract the relevant numbers or relationships, and then choose the matching option."
-            )
 
-        return SolverResult(
-            reply=reply,
-            domain="quant",
-            solved=False,
-            help_mode="hint",
-        )
+def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Optional[SolverResult]:
+    user_text = ctx.visible_user_text
+    lower = normalize_text(user_text)
+    question_block = ctx.combined_question_block
+
+    if not question_block:
+        return None
+
+    percent_fraction = handle_percent_fraction_question(ctx, help_mode)
+    if percent_fraction is not None:
+        return percent_fraction
+
+    choice_followup = handle_choice_letter_followup(ctx, help_mode)
+    if choice_followup is not None:
+        return choice_followup
+
+    if "what is the question asking" in lower or "what is this asking" in lower:
+        if "variability" in ctx.question_text.lower() or "spread" in ctx.question_text.lower():
+            reply = "It is asking you to compare how spread out the answer choices are and identify which dataset varies the most."
+        else:
+            reply = "It is asking you to identify the mathematical task and then match the result to one of the options."
+        return SolverResult(reply=reply, domain="quant", solved=False, help_mode="hint")
 
     if lower in {"help", "can you help", "help me", "i dont get it", "i don't get it"}:
         if help_mode == "hint":
@@ -163,26 +310,20 @@ def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Opti
 
     if "why" in lower or "explain" in lower:
         walkthrough_result = solve_quant(question_block, "walkthrough")
-        if solved.answer_letter and "why is it" not in lower:
-            choice_text = choices.get(solved.answer_letter, "").strip()
-            if choice_text:
-                walkthrough_result.reply += f"\n\nSo the correct choice is {solved.answer_letter} ({choice_text})."
-            else:
-                walkthrough_result.reply += f"\n\nSo the correct choice is {solved.answer_letter}."
         return walkthrough_result
 
     if "answer" in lower or "which one" in lower or "what answer" in lower or "are you sure" in lower:
         return solve_quant(question_block, "answer")
 
     last_ai = get_last_assistant_message(ctx.chat_history)
-    if last_ai and ("that" in lower or "it" in lower or "why" in lower):
+    if last_ai and ("that" in lower or "it" in lower):
         return solve_quant(question_block, "walkthrough")
 
     return None
 
 
 def solve_verbal_or_general(user_text: str, help_mode: str) -> SolverResult:
-    lower = user_text.lower()
+    lower = normalize_text(user_text)
 
     if any(
         k in lower
@@ -261,6 +402,11 @@ def generate_response(
         followup.reply = format_reply(followup.reply, tone, verbosity, transparency, followup.help_mode)
         return followup
 
+    percent_fraction = handle_percent_fraction_question(ctx, help_mode)
+    if percent_fraction is not None:
+        percent_fraction.reply = format_reply(percent_fraction.reply, tone, verbosity, transparency, percent_fraction.help_mode)
+        return percent_fraction
+
     if question_block and is_quant_question(question_block):
         result = solve_quant(question_block, help_mode)
         result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)