Files
Jyotisha/scripts/chart_choice/service.py

633 lines
31 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)