633 lines
31 KiB
Python
633 lines
31 KiB
Python
"""Stateless chart-choice service used by the API server.
|
||
|
||
Two calls, both recomputed from the same inputs so the browser never supplies
|
||
a minute the server did not derive:
|
||
|
||
* ``build_packet(body)`` -> narrowing question, "certain", or the choice packet
|
||
* ``decide_packet(body)`` -> the packet plus the decision for ``body["answers"]``
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
from datetime import datetime, timedelta
|
||
from typing import Any, Final, TypeAlias
|
||
|
||
from scripts.chart_choice import adaptive, chart_questions, interview
|
||
|
||
from scripts.chart_choice.boundaries import (
|
||
LEGACY_DIVISIONS,
|
||
MAX_WINDOW_MINUTES,
|
||
ChartChoiceInputError,
|
||
ChartRequest,
|
||
Line,
|
||
chart_at,
|
||
find_lines,
|
||
nearest_line,
|
||
representative_minute,
|
||
representative_time,
|
||
segment_around,
|
||
signature,
|
||
)
|
||
from scripts.chart_choice.decision import decide, decide_with_evidence, reported_is_neutral
|
||
from scripts.chart_choice.readings import DOMAIN, DOMAIN_ORDER, LEGACY_DOMAIN_ORDER, SIGN_CN, build_question, describe, varga_chart
|
||
|
||
ENGINE_VERSION: Final = "chart-choice-v1"
|
||
MAX_QUESTIONS: Final = 5
|
||
ROUNDS_VERSION: Final = "chart-choice-v2"
|
||
MAX_ROUNDS: Final = 3
|
||
KEY_CHARTS: Final = adaptive.CHARTS
|
||
MINOR_CHARTS: Final = ("D4", "D12", "D24")
|
||
ONE_SECOND: Final = timedelta(seconds=1)
|
||
Segment: TypeAlias = tuple[datetime, datetime]
|
||
|
||
PRIORITY: Final = {"D1": 0, "D9": 1, "D10": 2, "D2": 3, "D6": 3, "D8": 3}
|
||
|
||
|
||
def _parse_at(value: Any, field: str) -> datetime:
|
||
if not isinstance(value, str):
|
||
raise ChartChoiceInputError(f"{field} must be YYYY-MM-DDTHH:MM")
|
||
try:
|
||
return datetime.strptime(value[:16], "%Y-%m-%dT%H:%M")
|
||
except ValueError as exc:
|
||
raise ChartChoiceInputError(f"{field} must be YYYY-MM-DDTHH:MM") from exc
|
||
|
||
|
||
def _request(body: dict[str, Any]) -> tuple[ChartRequest, datetime, datetime, datetime, bool]:
|
||
try:
|
||
lat, lon, tz = float(body["lat"]), float(body["lon"]), float(body["tz"])
|
||
except (KeyError, TypeError, ValueError) as exc:
|
||
raise ChartChoiceInputError("lat, lon and tz are required") from exc
|
||
if not (-90 <= lat <= 90 and -180 <= lon <= 180 and -14 <= tz <= 14):
|
||
raise ChartChoiceInputError("lat, lon or tz out of range")
|
||
start = _parse_at(body.get("start_at"), "start_at")
|
||
end = _parse_at(body.get("end_at"), "end_at")
|
||
if end <= start:
|
||
raise ChartChoiceInputError("end_at must be after start_at")
|
||
if end - start > timedelta(hours=24):
|
||
raise ChartChoiceInputError("window longer than 24 hours")
|
||
reported_known = isinstance(body.get("reported_at"), str) and bool(body.get("reported_at"))
|
||
reported = _parse_at(body["reported_at"], "reported_at") if reported_known else start + (end - start) / 2
|
||
reported = reported.replace(second=0, microsecond=0)
|
||
if not start <= reported <= end:
|
||
reported_known = False
|
||
reported = (start + (end - start) / 2).replace(second=0, microsecond=0)
|
||
ayanamsa = str(body.get("ayanamsa") or "raman")
|
||
node_mode = str(body.get("node_mode") or "mean")
|
||
if node_mode not in ("mean", "true"):
|
||
raise ChartChoiceInputError("node_mode must be mean or true")
|
||
req = ChartRequest(birth_date=reported.date().isoformat(), lat=lat, lon=lon, tz=tz,
|
||
ayanamsa=ayanamsa, node_mode=node_mode)
|
||
return req, start, end, reported, reported_known
|
||
|
||
|
||
def _at(at: datetime) -> str:
|
||
return at.strftime("%Y-%m-%dT%H:%M")
|
||
|
||
|
||
def _at_s(at: datetime) -> str:
|
||
return at.strftime("%Y-%m-%dT%H:%M:%S")
|
||
|
||
|
||
def _hhmm(at: datetime) -> str:
|
||
return at.strftime("%H:%M")
|
||
|
||
|
||
def _sunrise_local_naive(date_iso: str, lat: float, lon: float, tz: float) -> datetime | None:
|
||
"""Real sunrise in local clock time; None for polar or unavailable cases (never invent 06:00)."""
|
||
try:
|
||
import saham_daynight
|
||
import swisseph as swe
|
||
|
||
noon = datetime.fromisoformat(f"{date_iso}T12:00:00")
|
||
row = saham_daynight.determine_daytime(noon, lat=lat, lon=lon, tz=tz)
|
||
year, month, day, ut_hours = swe.revjul(float(row["sunrise_jd_ut"]))
|
||
return datetime(int(year), int(month), int(day)) + timedelta(hours=float(ut_hours) + float(tz))
|
||
except Exception: # noqa: BLE001 - any failure means "no sunrise anchor", the halves fallback is used
|
||
return None
|
||
|
||
|
||
def _narrowing(req: ChartRequest, start: datetime, end: datetime) -> dict[str, Any]:
|
||
"""Split a wide window in two, at sunrise when sunrise sits well inside it."""
|
||
split = None
|
||
anchor = "half"
|
||
sunrise = _sunrise_local_naive(req.birth_date, req.lat, req.lon, req.tz)
|
||
if sunrise is not None:
|
||
sunrise = sunrise.replace(second=0, microsecond=0)
|
||
margin = timedelta(minutes=20)
|
||
if start + margin <= sunrise <= end - margin:
|
||
split, anchor = sunrise, "sunrise"
|
||
if split is None:
|
||
split = (start + (end - start) / 2).replace(second=0, microsecond=0)
|
||
if anchor == "sunrise":
|
||
prompt = f"你出生时,天已经亮了吗?(当天日出约 {_hhmm(split)})"
|
||
labels = ("天还没亮", "天已经亮了")
|
||
else:
|
||
prompt = "家里人说起你出生的时间,更靠近哪一段?"
|
||
labels = (f"{_hhmm(start)}–{_hhmm(split)}", f"{_hhmm(split)}–{_hhmm(end)}")
|
||
return {
|
||
"anchor": anchor,
|
||
"prompt": prompt,
|
||
"options": [
|
||
{"text": labels[0], "start_at": _at(start), "end_at": _at(split)},
|
||
{"text": labels[1], "start_at": _at(split), "end_at": _at(end)},
|
||
],
|
||
}
|
||
|
||
|
||
def _planets_and_asc(req: ChartRequest, at: datetime) -> tuple[dict[str, float], float]:
|
||
chart = chart_at(req, at)
|
||
planets = {
|
||
name: float(data["lon"]) for name, data in chart.get("planets", {}).items()
|
||
if isinstance(data, dict) and isinstance(data.get("lon"), int | float)
|
||
}
|
||
return planets, float(chart["ascendant"]["lon"])
|
||
|
||
|
||
def _base(req: ChartRequest, start: datetime, end: datetime, reported: datetime, known: bool, version: str) -> dict:
|
||
return {
|
||
"engine_version": version,
|
||
"window": {"start_at": _at(start), "end_at": _at(end)},
|
||
"reported_at": _at(reported),
|
||
"reported_known": known,
|
||
"ayanamsa": req.ayanamsa,
|
||
"node_mode": req.node_mode,
|
||
}
|
||
|
||
|
||
def _line_view(line: Line, order: tuple[str, ...]) -> dict:
|
||
return {"at": _at_s(line.at), "degree": line.degree, "charts": [key for key in order if key in line.flips]}
|
||
|
||
|
||
def _choice(
|
||
req: ChartRequest, base: dict, line: Line, before_seg: Segment, after_seg: Segment,
|
||
reported: datetime, reported_known: bool, order: tuple[str, ...], other_lines: int,
|
||
) -> dict:
|
||
multi = base["engine_version"] == ROUNDS_VERSION
|
||
representative = representative_time if multi else representative_minute
|
||
before_min = representative(before_seg, reported)
|
||
after_min = representative(after_seg, reported)
|
||
reported_side = "before" if reported < line.at else "after"
|
||
flipped = [key for key in order if key in line.flips]
|
||
unchanged = [key for key in order if key not in line.flips]
|
||
pb, ab = _planets_and_asc(req, before_min)
|
||
pa, aa = _planets_and_asc(req, after_min)
|
||
comparisons, questions = [], []
|
||
for key in flipped:
|
||
division = int(key[1:])
|
||
before = describe(key, varga_chart(pb, ab, division))
|
||
after = describe(key, varga_chart(pa, aa, division))
|
||
comparisons.append({"chart": key, "label": DOMAIN[key]["label"], "chart_label": DOMAIN[key]["chart"],
|
||
"before": before, "after": after})
|
||
if len(questions) < MAX_QUESTIONS and (q := build_question(before, after)):
|
||
questions.append({**q, "optional": True} if multi else q)
|
||
|
||
return {
|
||
**base,
|
||
"status": "choose",
|
||
"line": _line_view(line, order),
|
||
"other_lines_in_window": other_lines,
|
||
"reported_side": reported_side,
|
||
"reported_neutral": reported_is_neutral(reported, line.at, reported_known=reported_known),
|
||
"seconds_from_line": int(abs((reported - line.at).total_seconds())),
|
||
"sides": {
|
||
"before": {"from": _at_s(before_seg[0]), "to": _at_s(before_seg[1]), "saved_at": _saved_at(before_min)},
|
||
"after": {"from": _at_s(after_seg[0]), "to": _at_s(after_seg[1]), "saved_at": _saved_at(after_min)},
|
||
},
|
||
"comparisons": comparisons,
|
||
"unchanged": [{"chart": k, "label": DOMAIN[k]["label"]} for k in unchanged],
|
||
"questions": questions,
|
||
**(interview.questions(req, flipped, before_min, after_min) if multi else {}),
|
||
}
|
||
|
||
|
||
def _answer(packet: dict, body: dict, evidence: list[dict] | None = None) -> tuple[dict, dict]:
|
||
if packet["status"] != "choose":
|
||
raise ChartChoiceInputError(f"no choice to make (status {packet['status']})")
|
||
raw = body.get("answers") or {}
|
||
if not isinstance(raw, dict):
|
||
raise ChartChoiceInputError("answers must be an object")
|
||
asked = {q["domain"] for q in packet["questions"]}
|
||
answers = {k: str(v) for k, v in raw.items() if k in asked and v in ("before", "after", "unsure")}
|
||
override = body.get("override_side")
|
||
if evidence is not None:
|
||
decision = decide_with_evidence(answers, evidence, reported_side=packet["reported_side"],
|
||
neutral=packet["reported_neutral"], override=override)
|
||
elif override in ("before", "after"):
|
||
decision = {"chosen_side": override, "rule": "user_override",
|
||
"votes": None, "both_versions_domains": []}
|
||
else:
|
||
decision = decide(answers, reported_side=packet["reported_side"], neutral=packet["reported_neutral"])
|
||
if body.get("read_both_all"):
|
||
decision["both_versions_domains"] = sorted(c["before"]["domain"] for c in packet["comparisons"])
|
||
side = decision["chosen_side"]
|
||
labels = {c["before"]["domain"]: c["label"] for c in packet["comparisons"]}
|
||
return answers, {
|
||
**decision,
|
||
"saved_at": packet["sides"][side]["saved_at"],
|
||
"both_versions": [{"domain": d, "label": labels.get(d, d)} for d in decision["both_versions_domains"]],
|
||
}
|
||
|
||
|
||
def _saved_at(value: datetime) -> str:
|
||
return _at_s(value) if value.second else _at(value)
|
||
|
||
|
||
def _segment(start: datetime, end: datetime) -> dict:
|
||
return {"start_at": _at_s(start), "end_at": _at_s(end)}
|
||
|
||
|
||
def _ordered(lines: list[Line], segment: Segment, reported: datetime) -> list[Line]:
|
||
lo, hi = segment
|
||
return sorted(
|
||
(line for line in lines if lo < line.at <= hi and line.flips.keys() & PRIORITY.keys()),
|
||
key=lambda line: (
|
||
min(PRIORITY[key] for key in line.flips if key in PRIORITY),
|
||
abs(line.at - reported),
|
||
line.at,
|
||
),
|
||
)
|
||
|
||
|
||
def _side(segment: Segment, line: Line, side: str) -> Segment:
|
||
lo, hi = segment
|
||
return (lo, line.at - ONE_SECOND) if side == "before" else (line.at, hi)
|
||
|
||
|
||
def _input_line(value: Any) -> datetime:
|
||
if not isinstance(value, str) or len(value) != 19:
|
||
raise ChartChoiceInputError("line_at must be YYYY-MM-DDTHH:MM:SS")
|
||
try:
|
||
return datetime.strptime(value, "%Y-%m-%dT%H:%M:%S")
|
||
except ValueError as exc:
|
||
raise ChartChoiceInputError("line_at must be YYYY-MM-DDTHH:MM:SS") from exc
|
||
|
||
|
||
def _round_record(line: Line, side: str, rule: str, votes: Any, receipt: dict | None = None) -> dict:
|
||
return {"line_at": _at_s(line.at), "charts": _line_view(line, DOMAIN_ORDER)["charts"],
|
||
"chosen_side": side, "rule": rule, "votes": votes,
|
||
**({key: receipt[key] for key in ("scores", "sources", "decided_by")} if receipt else {})}
|
||
|
||
|
||
def _key_chart_rows(req: ChartRequest, at: datetime, lines: list[Line], rounds: list[dict]) -> list[dict]:
|
||
_, asc = _planets_and_asc(req, at)
|
||
signs = signature(asc, tuple(int(chart[1:]) for chart in KEY_CHARTS))
|
||
rows = []
|
||
for chart in KEY_CHARTS:
|
||
flip = min((line.at for line in lines if chart in line.flips), default=None)
|
||
source = next((row.get("decided_by") for row in reversed(rounds) if chart in row.get("charts", ())), None)
|
||
rows.append({
|
||
"chart": chart, "sign": SIGN_CN[signs[chart]],
|
||
"decided_by": source if flip is None else None,
|
||
**({"flips_at": _at_s(flip)} if flip is not None else {}),
|
||
})
|
||
return rows
|
||
|
||
|
||
def _resume_segment(
|
||
resume: Any, start: datetime, end: datetime,
|
||
) -> tuple[Segment, list[dict], list[dict]]:
|
||
if resume is None:
|
||
return (start, end), [], []
|
||
if not isinstance(resume, dict) or not isinstance(resume.get("segment"), dict):
|
||
raise ChartChoiceInputError("invalid saved segment")
|
||
window = resume["segment"]
|
||
segment = (_input_line(window.get("start_at")), _input_line(window.get("end_at")))
|
||
if not start <= segment[0] <= segment[1] <= end:
|
||
raise ChartChoiceInputError("saved segment is outside its window")
|
||
rounds, events = resume.get("rounds"), resume.get("events")
|
||
if (not isinstance(rounds, list) or not all(isinstance(item, dict) for item in rounds)
|
||
or not isinstance(events, list) or not all(isinstance(item, dict) for item in events)):
|
||
raise ChartChoiceInputError("invalid saved history")
|
||
return segment, list(rounds), list(events)
|
||
|
||
|
||
def _multi(
|
||
body: dict, req: ChartRequest, base: dict, start: datetime, end: datetime,
|
||
reported: datetime, reported_known: bool, *, deciding: bool,
|
||
) -> dict:
|
||
raw = body.get("resolved", [])
|
||
if not isinstance(raw, list) or len(raw) > MAX_ROUNDS:
|
||
raise ChartChoiceInputError("resolved must be a list of at most three choices")
|
||
if "stop" in body and not isinstance(body["stop"], bool):
|
||
raise ChartChoiceInputError("stop must be a boolean")
|
||
resume = body.get("resume")
|
||
saved = body.get("resume_v2")
|
||
if resume is not None and (saved is not None or not isinstance(resume, dict) or len(raw) == MAX_ROUNDS):
|
||
raise ChartChoiceInputError("resume must leave room for the legacy choice")
|
||
segment, rounds, events = _resume_segment(saved, start, end)
|
||
carried_rounds = len(rounds)
|
||
scan_start, scan_end = segment
|
||
lines_by_time: dict[datetime, Line] = {}
|
||
for line in find_lines(req, scan_start, scan_end) if scan_start < scan_end else ():
|
||
previous = lines_by_time.setdefault(line.at, line)
|
||
if previous is not line:
|
||
previous.flips.update(line.flips)
|
||
lines = list(lines_by_time.values())
|
||
# The v1 nearest line can be non-key. It only enters through explicit resume.
|
||
legacy_line = None
|
||
if resume is not None:
|
||
recorded_reported = _parse_at(resume["reported_at"], "resume.reported_at") if "reported_at" in resume else reported
|
||
if not start <= recorded_reported <= end:
|
||
raise ChartChoiceInputError("legacy reported_at is outside its window")
|
||
legacy_line = nearest_line(find_lines(req, start, end, LEGACY_DIVISIONS), recorded_reported)
|
||
normalized: list[dict] = []
|
||
for index, entry in enumerate([resume, *raw] if resume is not None else raw):
|
||
if not isinstance(entry, dict) or entry.get("side") not in ("before", "after"):
|
||
raise ChartChoiceInputError("each resolved entry needs line_at and a side")
|
||
at = _input_line(entry.get("line_at"))
|
||
candidates = _ordered(lines, segment, reported)
|
||
is_resume = index == 0 and resume is not None
|
||
if is_resume:
|
||
line = lines_by_time.get(legacy_line.at) if legacy_line else None
|
||
else:
|
||
line = candidates[0] if candidates else None
|
||
if line is not None and (abs(at - line.at) > ONE_SECOND or (at != line.at and at in lines_by_time)):
|
||
line = None
|
||
if line is None or not segment[0] < line.at <= segment[1]:
|
||
raise ChartChoiceInputError("resolved line is not the next available line")
|
||
side = entry["side"]
|
||
segment_before = segment
|
||
segment = _side(segment, line, side)
|
||
if segment[0] > segment[1]:
|
||
raise ChartChoiceInputError("resolved choice leaves no time in the window")
|
||
history = _round_record(line, side, "legacy_record" if is_resume else "resolved", None)
|
||
normalized_entry = {"line_at": history["line_at"], "side": side}
|
||
if not is_resume and entry.keys() & {"answers", "override_side", "event_answers", "appearance", "birthmarks"}:
|
||
prior = _multi_choice(req, base, lines, segment_before, candidates, reported, reported_known)
|
||
extras, dated, sources = interview.evidence(req, prior, entry, reported)
|
||
answers, receipt = _answer(prior, entry, sources)
|
||
if receipt["chosen_side"] != side:
|
||
raise ChartChoiceInputError("resolved side disagrees with its answers")
|
||
history = _round_record(line, side, receipt["rule"], receipt["votes"], receipt)
|
||
events.extend(dated)
|
||
normalized_entry.update(extras)
|
||
if "answers" in entry:
|
||
normalized_entry["answers"] = answers
|
||
if receipt["rule"] == "user_override":
|
||
normalized_entry["override_side"] = entry["override_side"]
|
||
rounds.append(history)
|
||
if not is_resume:
|
||
normalized.append(normalized_entry)
|
||
|
||
ordered = _ordered(lines, segment, reported)
|
||
confirmed = len(rounds) - carried_rounds
|
||
lo, hi = segment
|
||
result = {
|
||
**base,
|
||
"round": min(confirmed + 1, MAX_ROUNDS),
|
||
"max_rounds": MAX_ROUNDS,
|
||
"remaining_key_lines": len(ordered),
|
||
"ordered_lines": [_line_view(line, DOMAIN_ORDER) for line in ordered],
|
||
"minor_lines": [
|
||
{"at": _at_s(line.at), "charts": [chart for chart in MINOR_CHARTS if chart in line.flips]}
|
||
for line in sorted(lines, key=lambda item: item.at)
|
||
if lo < line.at <= hi and line.flips and line.flips.keys() <= set(MINOR_CHARTS)
|
||
],
|
||
"key_charts": _key_chart_rows(req, representative_time(segment, reported), ordered, rounds),
|
||
"segment": _segment(*segment),
|
||
"resolved": normalized,
|
||
"events": events,
|
||
**({"resume": {"line_at": rounds[0]["line_at"], "side": rounds[0]["chosen_side"]}} if resume is not None else {}),
|
||
}
|
||
stop = body.get("stop", False)
|
||
if not ordered or confirmed == MAX_ROUNDS or stop:
|
||
if deciding and not stop and body.get("override_side") in ("before", "after"):
|
||
raise ChartChoiceInputError("no active line to override")
|
||
rule = "stopped" if stop else "round_limit" if ordered else "no_line_in_range"
|
||
decision = _round_result(req, segment, ordered, rounds, reported, rule, events, confirmed)
|
||
decision["resolved"] = normalized
|
||
return {**result, "status": "certain" if not ordered and not stop else "complete",
|
||
"saved_at": decision["saved_at"], "decision": decision}
|
||
line = ordered[0]
|
||
packet = _multi_choice(req, result, lines, segment, ordered, reported, reported_known)
|
||
if not deciding:
|
||
return packet
|
||
extras, dated, sources = interview.evidence(req, packet, body, reported)
|
||
answers, decision = _answer(packet, body, sources)
|
||
side = decision["chosen_side"]
|
||
segment = _side(segment, line, side)
|
||
rounds.append(_round_record(line, side, decision["rule"], decision["votes"], decision))
|
||
remaining = _ordered(lines, segment, reported)
|
||
decision.update(_round_result(req, segment, remaining, rounds, reported, decision["rule"], [*events, *dated], confirmed + 1))
|
||
decision["resolved"] = [
|
||
*normalized,
|
||
{"line_at": _at_s(line.at), "side": side, "answers": answers, **extras,
|
||
**({"override_side": body["override_side"]} if decision["rule"] == "user_override" else {})},
|
||
]
|
||
return {**packet, "answers": answers, "decision": decision}
|
||
|
||
|
||
def _multi_choice(
|
||
req: ChartRequest, base: dict, lines: list[Line], segment: Segment, ordered: list[Line],
|
||
reported: datetime, reported_known: bool,
|
||
) -> dict:
|
||
line = ordered[0]
|
||
lo, hi = segment
|
||
preceding = max((item.at for item in lines if lo < item.at < line.at), default=lo)
|
||
following = min((item.at for item in lines if line.at < item.at <= hi), default=hi + ONE_SECOND)
|
||
before = (preceding, line.at - ONE_SECOND)
|
||
after = (line.at, min(hi, following - ONE_SECOND))
|
||
return _choice(req, base, line, before, after, reported, reported_known, DOMAIN_ORDER, len(ordered) - 1)
|
||
|
||
|
||
def _round_result(
|
||
req: ChartRequest, segment: Segment, lines: list[Line], rounds: list[dict],
|
||
reported: datetime, rule: str, events: list[dict], confirmed: int,
|
||
) -> dict:
|
||
has_next = bool(lines and confirmed < MAX_ROUNDS and rule != "stopped")
|
||
representative = representative_time(segment, reported)
|
||
evidence = interview.summarize(req, segment, reported, events, representative=representative) if not has_next else None
|
||
return {
|
||
"saved_at": _saved_at(representative),
|
||
"segment": _segment(*segment),
|
||
"rounds": rounds,
|
||
"undetermined_charts": [key for key in KEY_CHARTS if any(key in line.flips for line in lines)],
|
||
"events": events,
|
||
"key_charts": _key_chart_rows(req, representative, lines, rounds),
|
||
**({"events_detail": evidence.pop("events_detail", []), "evidence_summary": evidence} if evidence is not None else {}),
|
||
"remaining_key_lines": len(lines),
|
||
"has_next": has_next,
|
||
"rule": rule,
|
||
}
|
||
|
||
|
||
def _questionnaire(body: dict, req: ChartRequest, base: dict, start: datetime, end: datetime,
|
||
reported: datetime, *, deciding: bool) -> dict:
|
||
if body.get("resolved") or ("chart_answers" in body and not deciding):
|
||
raise ChartChoiceInputError("use chart_answers with the questionnaire decision")
|
||
stop = body.get("stop", False)
|
||
if not isinstance(stop, bool):
|
||
raise ChartChoiceInputError("stop must be a boolean")
|
||
saved = body.get("resume_v2")
|
||
segment, rounds, carried = _resume_segment(saved, start, end)
|
||
if (legacy := body.get("resume")) is not None:
|
||
if saved or not isinstance(legacy, dict) or legacy.get("side") not in ("before", "after"):
|
||
raise ChartChoiceInputError("invalid legacy selection")
|
||
recorded = _parse_at(legacy["reported_at"], "resume.reported_at") if "reported_at" in legacy else reported
|
||
if not start <= recorded <= end:
|
||
raise ChartChoiceInputError("legacy reported_at is outside its window")
|
||
line = nearest_line(find_lines(req, start, end, LEGACY_DIVISIONS), recorded)
|
||
if line is None or _input_line(legacy.get("line_at")) != line.at or not start < line.at <= end:
|
||
raise ChartChoiceInputError("invalid legacy selection")
|
||
segment = _side(segment, line, legacy["side"])
|
||
rounds = [_round_record(line, legacy["side"], "legacy_record", None)]
|
||
|
||
lo, hi = segment
|
||
lines = find_lines(req, lo, hi) if lo < hi else []
|
||
ordered = _ordered(lines, segment, reported)
|
||
allowed = saved.get("undetermined_charts") if saved else None
|
||
if allowed is not None and (not isinstance(allowed, list) or any(chart not in KEY_CHARTS for chart in allowed)):
|
||
raise ChartChoiceInputError("invalid saved charts")
|
||
by_chart = {}
|
||
for chart in KEY_CHARTS:
|
||
if allowed is not None and chart not in allowed:
|
||
continue
|
||
choices = chart_questions.possibilities(chart, segment, lines)
|
||
if len(choices) > 1:
|
||
by_chart[chart] = choices
|
||
asked = chart_questions.questions(req, reported, by_chart)
|
||
packet = {
|
||
**base,
|
||
"status": "questionnaire",
|
||
"segment": _segment(*segment),
|
||
"remaining_key_lines": len(ordered),
|
||
"ordered_lines": [_line_view(line, DOMAIN_ORDER) for line in ordered],
|
||
"minor_lines": [{"at": _at_s(line.at), "charts": list(line.flips)}
|
||
for line in lines if lo < line.at <= hi and line.flips.keys() <= set(MINOR_CHARTS)],
|
||
"question_charts": [{"chart": chart, "possibilities": len(choices)} for chart, choices in by_chart.items()],
|
||
"chart_questions": asked,
|
||
"events": carried,
|
||
"key_charts": _key_chart_rows(req, representative_time(segment, reported), ordered, rounds),
|
||
}
|
||
if not deciding:
|
||
return packet
|
||
constraints, dated = chart_questions.evidence(body.get("chart_answers", {}), asked, reported, interview._today(req))
|
||
selected, retained, conflicts = chart_questions.select_segment(segment, reported, constraints)
|
||
remaining = _ordered(lines, selected, reported)
|
||
decision = _round_result(req, selected, remaining, rounds, reported, "stopped", [*carried, *dated], 0)
|
||
decision["rule"] = "stopped" if stop else "chart_answers" if asked else "no_line_in_range"
|
||
sources = {"event": "event", "supplement": "supplement", "appearance": "appearance", "birthmarks": "appearance"}
|
||
by_source = {item.chart: sources[item.kind] for item in reversed(retained)}
|
||
for chart in decision["key_charts"]:
|
||
if "flips_at" not in chart and chart["chart"] in by_source:
|
||
chart["decided_by"] = by_source[chart["chart"]]
|
||
decision.update(conflict=conflicts, resolved=[])
|
||
return {**packet, "status": "complete", "saved_at": decision["saved_at"], "decision": decision}
|
||
|
||
|
||
def _adaptive(body: dict, req: ChartRequest, base: dict, segment: Segment, reported: datetime,
|
||
*, deciding: bool) -> dict:
|
||
if any(key in body for key in ("resolved", "resume", "resume_v2")) or ("chart_answers" in body and not deciding):
|
||
raise ChartChoiceInputError("adaptive questionnaire needs a fresh range and chart answers")
|
||
stop = body.get("stop", False)
|
||
if not isinstance(stop, bool):
|
||
raise ChartChoiceInputError("stop must be a boolean")
|
||
lo, hi = segment
|
||
lines = find_lines(req, lo, hi, adaptive.DIVISIONS) if lo < hi else []
|
||
ordered = _ordered(lines, segment, reported)
|
||
result = adaptive.replay(req, reported, segment, lines, body.get("chart_answers", {}), stop=stop)
|
||
unsettled, question, live = result["unsettled"], result["next"], result["live"]
|
||
pending_lines = [line for line in ordered if any(chart in line.flips for chart in unsettled)]
|
||
packet = {
|
||
**base,
|
||
"status": "questionnaire",
|
||
"segment": _segment(live[0][0], live[-1][1]),
|
||
"remaining_key_lines": len(pending_lines),
|
||
"ordered_lines": [_line_view(line, DOMAIN_ORDER) for line in pending_lines],
|
||
"minor_lines": [{"at": _at_s(line.at), "charts": list(line.flips)}
|
||
for line in lines if lo < line.at <= hi and line.flips.keys() <= set(MINOR_CHARTS)],
|
||
"question_charts": [{"chart": chart, "possibilities": len({choice.sign for choice in choices})}
|
||
for chart, choices in unsettled.items()],
|
||
"chart_questions": [question] if question else [],
|
||
"confirmed_charts": len(KEY_CHARTS) - len(unsettled),
|
||
}
|
||
if question or not deciding:
|
||
return packet
|
||
selected, _, _ = chart_questions.select_segment(segment, reported, result["constraints"])
|
||
decision = _round_result(req, selected, pending_lines, [], reported, "stopped", result["events"], 0)
|
||
decision["evidence_summary"]["confidence"] = adaptive.confidence(
|
||
req, reported, selected, result["atoms"], [*result["events"], *result["health_events"]],
|
||
)
|
||
if not stop:
|
||
decision["rule"] = ("round_limit" if len(result["asked"]) == adaptive.MAX_ANSWERS else
|
||
"chart_answers" if ordered else "no_line_in_range")
|
||
sources = {"event": "event", "supplement": "supplement", "appearance": "appearance", "birthmarks": "appearance"}
|
||
by_source = {item.chart: sources[item.kind] for item in result["constraints"]}
|
||
for row in decision["key_charts"]:
|
||
chart = row["chart"]
|
||
if chart in unsettled:
|
||
first = unsettled[chart][0]
|
||
different = next(choice for choice in unsettled[chart] if choice.sign != first.sign)
|
||
flip = min(line.at for line in ordered if chart in line.flips and first.segment[1] < line.at <= different.segment[0])
|
||
row["flips_at"] = _at_s(flip)
|
||
else:
|
||
row.pop("flips_at", None)
|
||
row["decided_by"] = by_source.get(chart)
|
||
asked = [{**item, **{key: [_segment(*part) for part in item[key]] for key in ("before", "after")}}
|
||
for item in result["asked"]]
|
||
default_at, default_window, default_lines = reported, base["window"], ordered
|
||
declared = body.get("reported_default_window")
|
||
if declared is not None:
|
||
if not isinstance(declared, dict):
|
||
raise ChartChoiceInputError("invalid reported default window")
|
||
default_lo = _parse_at(declared.get("start_at"), "reported_default_window.start_at")
|
||
default_hi = _parse_at(declared.get("end_at"), "reported_default_window.end_at")
|
||
default_at = _parse_at(body.get("reported_at"), "reported_at") if body.get("reported_at") else (
|
||
default_lo + (default_hi - default_lo) / 2
|
||
).replace(second=0, microsecond=0)
|
||
if not (default_lo <= lo < hi <= default_hi and default_lo <= default_at <= default_hi
|
||
and default_hi - default_lo <= timedelta(hours=24)):
|
||
raise ChartChoiceInputError("invalid reported default window")
|
||
default_window = {"start_at": _at(default_lo), "end_at": _at(default_hi)}
|
||
default_lines = _ordered(find_lines(req, default_lo, default_hi, tuple(int(chart[1:]) for chart in KEY_CHARTS)),
|
||
(default_lo, default_hi), default_at)
|
||
reported_charts = _key_chart_rows(req, default_at, default_lines, [])
|
||
decision["reported_choice"] = {
|
||
"saved_at": _saved_at(default_at),
|
||
"segment": default_window,
|
||
"reported_known": base["reported_known"] or (declared is not None and bool(body.get("reported_at"))),
|
||
"key_charts": reported_charts,
|
||
"undetermined_charts": [row["chart"] for row in reported_charts if "flips_at" in row],
|
||
"remaining_key_lines": len(default_lines),
|
||
}
|
||
decision.update(asked=asked, conflict=result["conflict"], resolved=[], undetermined_charts=list(unsettled),
|
||
stop_reason=result["stop_reason"])
|
||
return {**packet, "status": "complete", "saved_at": decision["saved_at"], "decision": decision}
|
||
|
||
|
||
def _evaluate(body: dict, *, deciding: bool) -> dict:
|
||
req, start, end, reported, known = _request(body)
|
||
adaptive_mode = body.get("adaptive") is True
|
||
questionnaire = adaptive_mode or body.get("questionnaire") is True or "chart_answers" in body
|
||
multi = questionnaire or "resolved" in body or "resume" in body or "resume_v2" in body or "stop" in body
|
||
base = _base(req, start, end, reported, known, ROUNDS_VERSION if multi else ENGINE_VERSION)
|
||
if end - start > timedelta(minutes=MAX_WINDOW_MINUTES):
|
||
if deciding or body.get("resolved") or body.get("resume") or body.get("resume_v2"):
|
||
raise ChartChoiceInputError("narrow the window before resolving lines")
|
||
return {**base, "status": "needs_narrowing", "narrowing": _narrowing(req, start, end)}
|
||
if adaptive_mode:
|
||
return _adaptive(body, req, base, (start, end), reported, deciding=deciding)
|
||
if questionnaire:
|
||
return _questionnaire(body, req, base, start, end, reported, deciding=deciding)
|
||
if multi:
|
||
return _multi(body, req, base, start, end, reported, known, deciding=deciding)
|
||
lines = find_lines(req, start, end, LEGACY_DIVISIONS)
|
||
line = nearest_line(lines, reported)
|
||
if line is None:
|
||
if deciding:
|
||
raise ChartChoiceInputError("no choice to make (status certain)")
|
||
return {**base, "status": "certain", "saved_at": _at(reported)}
|
||
before, after = segment_around(lines, line, start, end)
|
||
packet = _choice(req, base, line, before, after, reported, known, LEGACY_DOMAIN_ORDER, len(lines) - 1)
|
||
if not deciding:
|
||
return packet
|
||
answers, decision = _answer(packet, body)
|
||
return {**packet, "answers": answers, "decision": decision}
|
||
|
||
|
||
def build_packet(body: dict[str, Any]) -> dict[str, Any]:
|
||
return _evaluate(body, deciding=False)
|
||
|
||
|
||
def decide_packet(body: dict[str, Any]) -> dict[str, Any]:
|
||
return _evaluate(body, deciding=True)
|