| """Turn JSON state, instructions and option descriptions into text the model reads. |
| |
| Objects and arrays are flattened into ``path: value`` lines using the same dot-and-index paths |
| TypeSafe questions use to point at parts of the state (``ticket.messages[0].text``), so a question |
| that names `ticket.messages[0].text` finds that exact string next to its value. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| from typing import Any |
|
|
|
|
| def _leaf(value: Any) -> str: |
| if isinstance(value, str): |
| return value |
| if value is None: |
| return "null" |
| if isinstance(value, bool): |
| return "true" if value else "false" |
| return json.dumps(value, ensure_ascii=False) |
|
|
|
|
| def _walk(value: Any, path: str, out: list[str]) -> None: |
| if isinstance(value, dict): |
| if not value: |
| out.append(f"{path}: {{}}" if path else "{}") |
| for k, v in value.items(): |
| _walk(v, f"{path}.{k}" if path else str(k), out) |
| elif isinstance(value, list): |
| if not value: |
| out.append(f"{path}: []" if path else "[]") |
| for i, v in enumerate(value): |
| _walk(v, f"{path}[{i}]", out) |
| else: |
| out.append(f"{path}: {_leaf(value)}" if path else _leaf(value)) |
|
|
|
|
| def render(value: Any) -> str: |
| """Render any EntryType. Strings pass through unchanged; JSON is flattened to path lines.""" |
| if value is None: |
| return "" |
| if isinstance(value, str): |
| return value |
| lines: list[str] = [] |
| _walk(value, "", lines) |
| return "\n".join(lines) |
|
|
|
|
| |
|
|
| _QUESTION_WORDS = {"is", "are", "was", "were", "am", "do", "does", "did", "can", "could", "will", "would", "should", |
| "shall", "has", "have", "had", "may", "might", "must", "which", "what", "who", "whom", "whose", |
| "when", "where", "why", "how"} |
| _SUBJECTS = {"the", "this", "that", "these", "those", "it", "its", "they", "he", "she", "i", "we", "you", "my", "our", |
| "their", "his", "her", "a", "an", "there", "someone", "somebody", "everyone", "nobody", "user", "customer"} |
| CONDITION_TEMPLATES = { |
| "input": "Is the input {c}?", |
| "describe": "Does this describe the input: {c}?", |
| "true_of": "Is this true of the input: {c}?", |
| } |
|
|
|
|
| def condition_form(text: str) -> str: |
| """Classify a yes/no instruction: "question", "statement" or "fragment" ("angry", "asking for a refund", |
| "Contains personal data"). Only fragments are rewritten by ``canonical_condition``.""" |
| s = text.strip() |
| if not s: |
| return "fragment" |
| words = s.split() |
| first = words[0].lower().strip("\"'([") |
| if s.endswith("?") or first in _QUESTION_WORDS: |
| return "question" |
| if len(words) >= 3 and (first in _SUBJECTS or s.endswith(".")) and len(words) <= 60: |
| return "statement" |
| |
| |
| return "fragment" if len(words) <= 8 else "statement" |
|
|
|
|
| def canonical_condition(instructions: Any, template: str = "input") -> Any: |
| """Rewrite a bare yes/no condition into a full question, keeping the caller's words verbatim. |
| |
| A question without its "?" gets one; statements and structured instructions pass through unchanged. |
| """ |
| if not isinstance(instructions, str): |
| return instructions |
| s = instructions.strip() |
| form = condition_form(s) |
| if form == "question": |
| return s if s.endswith("?") else s.rstrip(".") + "?" |
| if form == "statement": |
| return instructions |
| c = s.rstrip(".?!").strip() |
| if c[:1].isupper() and not c[:2].isupper(): |
| c = c[0].lower() + c[1:] |
| return CONDITION_TEMPLATES[template].format(c=c) |
|
|
|
|
| def option_text(qtype: str, key: str, description: Any) -> str: |
| """What the model reads inside one option block. |
| |
| Choice shows ``key: description`` (or the bare key). Score levels show only their description: |
| TypeSafe states that levels are judged without their number. Noul shows yes/no plus the optional |
| criteria text. |
| """ |
| desc = render(description).strip() |
| if qtype == "score": |
| return desc |
| if qtype == "noul": |
| word = "yes" if key == "true" else "no" |
| return f"{word}: {desc}" if desc else word |
| return f"{key}: {desc}" if desc else key |
|
|
