File size: 6,542 Bytes
e9dac18
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
"""The answer the user reads, in the language the user wrote in.

Nothing here decides anything: the text is built from the verdict ``decide`` produced and from the
words the lexicon of that language provides. Two kinds of text meet in one reply, and the boundary
between them is deliberate:

* every label, state name and reason is taken from ``lexicon/<lang>.json``, so the framing of the
  answer belongs to the user's language;
* the mathematical content -- the canonical sentence the stratum understood and the answer the math
  stratum returned -- is passed through byte for byte, because it is a value and not prose.

The sentence the stratum understood is always shown. A user who wrote in Italian and gets back
``integral 3*x^2 from 0 to 2 wrt x`` can see which reading was used, and that is the whole point of
a stratum: the interpretation is inspectable, not hidden inside a model.

When no answer can be shown, the reply says so in the user's language and lists the forms this
language variety does understand, from ``lexicon.examples``, so the failure is a correction and not
a dead end.
"""

import re
from typing import Any, Dict, List, Optional

from . import decide as decide_module
from . import lexicon

FIELDS = ("word", "kind", "detail", "left", "right", "slot")
_PLACEHOLDER = re.compile(r"\{[a-z_]+\}")


def _fill(text: str) -> str:
    """Drop a placeholder the template kept: an unfilled brace must never reach the user."""
    return _PLACEHOLDER.sub("", text).replace("  ", " ").strip(" ;,:")


def note_fields(dossier: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
    """The fields each reason carries, collected from the notes the readers left behind."""
    out: Dict[str, Dict[str, Any]] = {}
    for reading in [dossier.get("reading_a") or {}, dossier.get("reading_b") or {},
                    dossier.get("reading_direct") or {}]:
        for note in reading.get("notes") or []:
            if isinstance(note, dict) and note.get("reason"):
                fields = {key: note[key] for key in FIELDS if key in note}
                out.setdefault(str(note["reason"]), fields)
    for reason, fields in ((dossier.get("math") or {}).get("reason_fields") or {}).items():
        out.setdefault(str(reason), dict(fields))
    return out


def _kind_understood(dossier: Dict[str, Any]) -> str:
    """The kind of problem the stratum solved, as the identifier the math language uses."""
    for key in ("reading_a", "reading_b", "reading_direct"):
        reading = dossier.get(key) or {}
        if reading.get("kind"):
            return str(reading["kind"])
    return ""


def _sentence(dossier: Dict[str, Any]) -> str:
    """The canonical sentence that was, or would have been, handed to the math stratum."""
    compare = dossier.get("compare") or {}
    math_verdict = dossier.get("math") or {}
    for source in (dossier.get("sent"), compare.get("left"), math_verdict.get("problem_math")):
        if source:
            return str(source)
    for key in ("reading_a", "reading_b", "reading_direct"):
        reading = dossier.get(key) or {}
        if reading.get("math"):
            return str(reading["math"])
    return ""


def _check_line(lang: str, records: Optional[List[Dict[str, Any]]]) -> str:
    """How many envelopes of the run the referee of the orchestrator confirmed."""
    if not records:
        return ""
    good = sum(1 for record in records if record.get("claimed") == record.get("referee"))
    return lexicon.labels(lang)["check"].format(a=good, b=len(records))


def reply(dossier: Dict[str, Any], final: Optional[Dict[str, Any]] = None,
          records: Optional[List[Dict[str, Any]]] = None, lang: Optional[str] = None) -> Dict[str, Any]:
    """Build the user-facing answer: one text block plus the machine-readable parts."""
    lang = lang or str(dossier.get("lang") or "en")
    if lang not in lexicon.codes():
        lang = "en"
    verdict = final or decide_module.decide(dossier)
    labels = lexicon.labels(lang)
    states = lexicon.reading_labels(lang)
    fields = note_fields(dossier)

    lines: List[str] = []
    state = str(verdict.get("state", "NONE"))
    lines.append("%s: %s" % (labels["status"], states.get(state, state)))
    sentence = _sentence(dossier)
    kind = _kind_understood(dossier)
    if sentence and state not in ("NOT COVERED", "NONE"):
        lines.append("%s (%s): %s" % (labels["understood"], kind, sentence))
    if verdict.get("answer"):
        lines.append("%s: %s" % (labels["answer"], verdict["answer"]))
    lines.append(labels["assurance"].replace("{n}", str(verdict.get("assurance", 0))))
    math_verdict = dossier.get("math") or {}
    if math_verdict.get("status"):
        # Which solver family the math stratum used is its own bookkeeping and nothing the reader
        # of an answer asked for; what belongs in the reply is the verdict and, when the math
        # stratum abstained, the reason it abstained.
        tail = str(math_verdict["status"])
        why = math_verdict.get("reason") or math_verdict.get("note") or ""
        if not why and math_verdict.get("reasons"):
            why = str(math_verdict["reasons"][0])
        if why:
            tail += " (" + why + ")"
        lines.append("%s: %s" % (labels["math_layer"], tail))
    reasons = [str(reason) for reason in verdict.get("reasons") or []]
    if reasons:
        math_verdict = dossier.get("math") or {}
        fields.setdefault("referee", {"detail": ", ".join(str(item) for item in verdict.get("detected") or [])})
        fields.setdefault("math_unknown", {"detail": str(math_verdict.get("reason")
                                                           or math_verdict.get("note") or "")})
        texts = [_fill(lexicon.translate_reason(lang, reason, **(fields.get(reason) or {}))) for reason in reasons]
        lines.append("%s: %s" % (labels["notes"], "; ".join(texts)))
    check = _check_line(lang, records)
    if check:
        lines.append(check)
    if state in ("NOT COVERED", "AMBIGUOUS", "NONE") and not verdict.get("answer"):
        samples = lexicon.examples(lang)
        if samples:
            lines.append("%s: %s" % (labels["question"], " | ".join(samples[:5])))
    return {
        "lang": lang,
        "language": lexicon.language_name(lang),
        "state": state,
        "assurance": verdict.get("assurance", 0),
        "answer": verdict.get("answer", ""),
        "sentence": sentence,
        "kind": kind,
        "reasons": reasons,
        "lines": lines,
        "text": "\n".join(lines),
    }