Sync from GitHub f548297062c1b82c3ebf9d03b3ebc9992ba65cf7

cert_study_app/services/quiz_service.py

@@ -132,6 +132,29 @@ def normalize_choice_answer(value: str, ordered: bool = False) -> str:
 
 
 def yes_no_labels(value: str) -> list[str]:
+    if isinstance(value, (list, dict)):
+        raw_value = value
+    else:
+        raw_value = None
+        try:
+            raw_value = json.loads(value) if isinstance(value, str) else None
+        except Exception:
+            raw_value = None
+
+    if isinstance(raw_value, list):
+        values = [
+            item.get("value") or item.get("answer") or item.get("selected_answer")
+            for item in raw_value
+            if isinstance(item, dict)
+        ]
+        labels = yes_no_labels(",".join(str(item) for item in values if item))
+        if labels:
+            return labels
+    elif isinstance(raw_value, dict):
+        labels = yes_no_labels(",".join(str(item) for item in raw_value.values()))
+        if labels:
+            return labels
+
     text = str(value or "").strip().lower()
     if not text:
         return []
@@ -145,6 +168,28 @@ def yes_no_labels(value: str) -> list[str]:
     return labels if len(labels) >= 2 else []
 
 
+def structured_answer_values(value) -> list[str]:
+    if isinstance(value, (list, dict)):
+        raw_value = value
+    else:
+        try:
+            raw_value = json.loads(value) if isinstance(value, str) else None
+        except Exception:
+            raw_value = None
+
+    if isinstance(raw_value, list):
+        values = [
+            item.get("value") or item.get("answer") or item.get("selected_answer")
+            for item in raw_value
+            if isinstance(item, dict)
+        ]
+    elif isinstance(raw_value, dict):
+        values = list(raw_value.values())
+    else:
+        return []
+    return [str(item).strip() for item in values if str(item).strip()]
+
+
 def option_text(options: list[str], label: str) -> str:
     label = option_label(label)
     for index, option in enumerate(options, 1):
@@ -203,7 +248,19 @@ def effective_answer(question) -> str:
     answer = question.answer or ""
     question_type = (question.question_type or "").lower()
     options = normalize_options(question.get_options()) or extract_options_from_stem(question.stem)
-    if question_type in {"hotspot", "table_choice", "matching", "ordering", "yes_no"}:
+    structured_values = structured_answer_values(answer)
+    if structured_values:
+        structured_yn = yes_no_labels(",".join(structured_values))
+        return ",".join(structured_yn or structured_values)
+
+    is_structured_visual = any(
+        keyword in question_type
+        for keyword in ["hotspot", "table_choice", "matching", "ordering", "yes_no", "true/false"]
+    ) and "in-context" not in question_type
+    if is_structured_visual:
+        answer_labels = yes_no_labels(answer)
+        if answer_labels and "true/false" in question_type:
+            return ",".join(answer_labels)
         analysis = visual_analysis(question)
         statements = analysis.get("statements")
         if isinstance(statements, list):
@@ -228,7 +285,7 @@ def effective_answer(question) -> str:
             labels = option_labels_from_texts(options, selected, allow_duplicates=True)
             if labels:
                 return ",".join(labels)
-    if question_type in {"hotspot", "table_choice"} and not yes_no_labels(answer):
+    if is_structured_visual and not yes_no_labels(answer):
         explanation_labels = yes_no_labels(question.explanation or "")
         if explanation_labels:
             return ",".join(explanation_labels)

streamlit_app.py

@@ -680,6 +680,29 @@ def box_choice_labels(question, count: int) -> list[str]:
 
 
 def yes_no_answer_labels(value: str) -> list[str]:
+    if isinstance(value, (list, dict)):
+        raw_value = value
+    else:
+        raw_value = None
+        try:
+            raw_value = json.loads(value) if isinstance(value, str) else None
+        except Exception:
+            raw_value = None
+
+    if isinstance(raw_value, list):
+        values = [
+            item.get("value") or item.get("answer") or item.get("selected_answer")
+            for item in raw_value
+            if isinstance(item, dict)
+        ]
+        labels = yes_no_answer_labels(",".join(str(item) for item in values if item))
+        if labels:
+            return labels
+    elif isinstance(raw_value, dict):
+        labels = yes_no_answer_labels(",".join(str(item) for item in raw_value.values()))
+        if labels:
+            return labels
+
     text = str(value or "")
     if re.fullmatch(r"\s*[YNyn](?:\s*,\s*[YNyn])+\s*", text):
         return [token.upper() for token in re.findall(r"[YNyn]", text)]
@@ -691,8 +714,12 @@ def yes_no_answer_labels(value: str) -> list[str]:
 
 def is_yes_no_hotspot(question) -> bool:
     question_type = (question.get("question_type") or "").lower()
-    if question_type not in {"hotspot", "table_choice"}:
+    if "in-context" in question_type:
+        return False
+    if not any(keyword in question_type for keyword in ["hotspot", "table_choice", "yes_no", "true/false"]):
         return False
+    if "true/false" in question_type:
+        return True
     text = " ".join(
         [
             question.get("question") or "",
@@ -706,6 +733,65 @@ def is_yes_no_hotspot(question) -> bool:
     )
 
 
+def statement_option_rows(options: list[str], expected_count: int) -> list[str]:
+    rows = []
+    for option in options or []:
+        text = str(option or "").strip()
+        if not text:
+            continue
+        cleaned = re.sub(r"^\s*(?:[0-9]+|[A-Z])[-.)]\s*", "", text).strip()
+        if re.fullmatch(r"예|아니오|아니요|yes|no", cleaned, re.I):
+            continue
+        rows.append(cleaned)
+    if expected_count and len(rows) >= expected_count:
+        return rows[:expected_count]
+    return rows
+
+
+def grouped_option_rows(options: list[str]) -> list[dict]:
+    grouped = {}
+    order = []
+    for option in options or []:
+        text = str(option or "").strip()
+        match = re.match(r"^\s*(\d+)-([A-Z])[\.)]?\s*(.+)$", text, re.I)
+        if not match:
+            continue
+        group_key = match.group(1)
+        body = match.group(3).strip()
+        row_label = f"항목 {group_key}"
+        value = body
+        if ":" in body:
+            row_label, value = [part.strip() for part in body.split(":", 1)]
+        if group_key not in grouped:
+            grouped[group_key] = {"label": row_label, "options": []}
+            order.append(group_key)
+        grouped[group_key]["options"].append(value)
+    rows = [grouped[key] for key in order]
+    return rows if len(rows) >= 2 and all(row["options"] for row in rows) else []
+
+
+def render_grouped_option_selects(question, key_prefix, rows):
+    selections = []
+    all_yes_no = all(
+        all(str(option).strip().lower() in {"yes", "no", "예", "아니오", "아니요"} for option in row["options"])
+        for row in rows
+    )
+    st.markdown("#### 항목별 답안")
+    for index, row in enumerate(rows, 1):
+        options = [str(option).strip() for option in row["options"] if str(option).strip()]
+        selected = st.selectbox(
+            row["label"] or f"항목 {index}",
+            ["선택 안 함"] + options,
+            key=f"{key_prefix}_grouped_options_{question['id']}_{index}",
+        )
+        if selected != "선택 안 함":
+            if all_yes_no:
+                selections.append("Y" if selected.lower() in {"yes", "예"} else "N")
+            else:
+                selections.append(selected)
+    return ",".join(selections) if len(selections) == len(rows) else None
+
+
 def visual_statements(question) -> list[dict]:
     try:
         analysis = json.loads(question.get("visual_analysis_json") or "{}")
@@ -761,12 +847,16 @@ def render_answer_input(question, key_prefix):
     if statement_rows:
         return render_yes_no_matrix(question, f"{key_prefix}_statements", statement_rows)
 
+    grouped_rows = grouped_option_rows(options)
+    if grouped_rows:
+        return render_grouped_option_selects(question, key_prefix, grouped_rows)
+
     if is_yes_no_hotspot(question):
         answer_count = len(yes_no_answer_labels(question.get("answer") or "")) or len(
             yes_no_answer_labels(question.get("explanation") or "")
         )
         row_count = max(3, answer_count, len(statement_rows))
-        rows = yes_no_lines(question.get("question") or "")
+        rows = statement_option_rows(options, row_count) or yes_no_lines(question.get("question") or "")
         if statement_rows:
             rows = statement_rows
         if len(rows) < row_count: