A self-chosen side removes the line from the segment, so the saved record kept nothing about what the other side changes. The decision now keeps each chosen line with the charts that change across it, and the report's scenario statement lists those domains. Grade caps, report text and the writing prompt are unchanged. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DbBXoyn7Hj3LCW3BUs5bZ8
791 lines
39 KiB
Python
791 lines
39 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 (
|
||
EDGE_GUARD_SECONDS,
|
||
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:
|
||
charts = [key for key in order if key in line.flips]
|
||
return {"at": _at_s(line.at), "degree": line.degree, "charts": charts,
|
||
"flips": {key: {"before": SIGN_CN[line.flips[key][0]], "after": SIGN_CN[line.flips[key][1]]}
|
||
for key in charts}}
|
||
|
||
|
||
def _line_summary(lines: list[Line], reference: datetime) -> dict:
|
||
ordered = sorted((line for line in lines if line.flips.keys() & set(KEY_CHARTS)), key=lambda line: line.at)
|
||
nearest = min(ordered, key=lambda line: (abs(line.at - reference), line.at), default=None)
|
||
chart_lines: dict[str, list[dict]] = {}
|
||
for line in ordered:
|
||
view = _line_view(line, KEY_CHARTS)
|
||
for chart, signs in view["flips"].items():
|
||
chart_lines.setdefault(chart, []).append({"at": view["at"], **signs})
|
||
charts: dict[str, dict] = {}
|
||
for chart, flips in chart_lines.items():
|
||
closest = min(flips, key=lambda flip: abs(_input_line(flip["at"]) - reference))
|
||
charts[chart] = {**closest, "count": len(flips), "lines": flips}
|
||
return {"nearest_at": _at_s(nearest.at) if nearest else None, "line_count": len(ordered), "charts": charts}
|
||
|
||
|
||
def _comparisons(req: ChartRequest, before_at: datetime, after_at: datetime, charts: list[str]) -> list[dict]:
|
||
pb, ab = _planets_and_asc(req, before_at)
|
||
pa, aa = _planets_and_asc(req, after_at)
|
||
return [
|
||
{"chart": key, "label": DOMAIN[key]["label"], "chart_label": DOMAIN[key]["chart"],
|
||
"before": describe(key, varga_chart(pb, ab, int(key[1:]))),
|
||
"after": describe(key, varga_chart(pa, aa, int(key[1:])))}
|
||
for key in charts
|
||
]
|
||
|
||
|
||
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]
|
||
comparisons = _comparisons(req, before_min, after_min, flipped)
|
||
questions = []
|
||
for comparison in comparisons:
|
||
if len(questions) < MAX_QUESTIONS and (q := build_question(comparison["before"], comparison["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),
|
||
"line_summary": _line_summary(default_lines, default_at),
|
||
}
|
||
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 _self_choice_at(segment: Segment, reported: datetime, original: Segment) -> datetime:
|
||
lo, hi = segment
|
||
if lo <= reported <= hi:
|
||
return reported
|
||
|
||
guard = timedelta(seconds=EDGE_GUARD_SECONDS)
|
||
guarded_lo = lo + guard if lo != original[0] else lo
|
||
# A segment before a line ends one second before the line itself.
|
||
guarded_hi = hi + ONE_SECOND - guard if hi != original[1] else hi
|
||
first = guarded_lo.replace(second=0, microsecond=0)
|
||
if first < guarded_lo:
|
||
first += timedelta(minutes=1)
|
||
last = guarded_hi.replace(second=0, microsecond=0)
|
||
if first <= last:
|
||
return first if reported < lo else last
|
||
|
||
minute = representative_minute((lo, hi + ONE_SECOND), reported)
|
||
return minute if lo <= minute <= hi else representative_time(segment, reported)
|
||
|
||
|
||
def _self_choice_lines(req: ChartRequest, start: datetime, end: datetime) -> list[Line]:
|
||
by_time: dict[datetime, Line] = {}
|
||
for line in find_lines(req, start, end, tuple(int(chart[1:]) for chart in KEY_CHARTS)):
|
||
if start < line.at <= end:
|
||
previous = by_time.setdefault(line.at, line)
|
||
if previous is not line:
|
||
previous.flips.update(line.flips)
|
||
return sorted(by_time.values(), key=lambda line: line.at)
|
||
|
||
|
||
def _self_choice_scenarios(
|
||
req: ChartRequest, segment: Segment, lines: list[Line], reported: datetime, original: Segment,
|
||
) -> tuple[list[dict], int]:
|
||
starts = [segment[0], *(line.at for line in lines)]
|
||
ends = [*(line.at - ONE_SECOND for line in lines), segment[1]]
|
||
pieces = list(zip(starts, ends))
|
||
|
||
def distance(index: int) -> tuple[timedelta, int]:
|
||
lo, hi = pieces[index]
|
||
return max(lo - reported, reported - hi, timedelta()), index
|
||
|
||
nearest = sorted(range(len(pieces)), key=distance)[:4]
|
||
primary = nearest[0]
|
||
scenarios = []
|
||
for index in sorted(nearest):
|
||
piece = pieces[index]
|
||
saved = _self_choice_at(piece, reported, original)
|
||
scenarios.append({
|
||
"segment": _segment(*piece), "saved_at": _saved_at(saved),
|
||
"key_charts": _key_chart_rows(req, saved, [], []), "is_primary": index == primary,
|
||
})
|
||
return scenarios, len(pieces) - len(scenarios)
|
||
|
||
|
||
def _self_choice(
|
||
body: dict, req: ChartRequest, segment: Segment, reported: datetime, *, deciding: bool,
|
||
) -> dict:
|
||
choices = body.get("choices")
|
||
if not isinstance(choices, list):
|
||
raise ChartChoiceInputError("choices must be a list")
|
||
original = segment
|
||
all_lines = _self_choice_lines(req, *original)
|
||
if not all_lines:
|
||
raise ChartChoiceInputError("no self-choice line in the window")
|
||
|
||
lines = all_lines
|
||
next_line = nearest_line(lines, reported)
|
||
comparison_segment = None
|
||
# BUG-1997: every line the user took a side on, with the charts whose ascendant differs across it.
|
||
# Once a line is chosen it leaves the segment, so nothing else records what the other side changes.
|
||
chosen_lines: list[dict] = []
|
||
for entry in choices:
|
||
if not isinstance(entry, dict) or set(entry) != {"line_at", "side"}:
|
||
raise ChartChoiceInputError("each choice needs only line_at and side")
|
||
side = entry["side"]
|
||
if (side not in ("before", "after", "unsure") or next_line is None
|
||
or _input_line(entry["line_at"]) != next_line.at):
|
||
raise ChartChoiceInputError("self-choice line is not the next available line")
|
||
if side == "unsure":
|
||
next_line = None
|
||
else:
|
||
opposing = "after" if side == "before" else "before"
|
||
lo, hi = _side(segment, next_line, opposing)
|
||
opposing_lines = [line.at for line in lines if lo < line.at <= hi]
|
||
if opposing_lines:
|
||
if opposing == "before":
|
||
lo = opposing_lines[-1]
|
||
else:
|
||
hi = opposing_lines[0] - ONE_SECOND
|
||
comparison_segment = (lo, hi)
|
||
chosen_lines.append({"at": _at_s(next_line.at), "side": side,
|
||
"charts": [key for key in KEY_CHARTS if key in next_line.flips]})
|
||
segment = _side(segment, next_line, side)
|
||
lines = [line for line in lines if segment[0] < line.at <= segment[1]]
|
||
next_line = nearest_line(lines, reported)
|
||
|
||
scenarios, omitted = _self_choice_scenarios(req, segment, lines, reported, original)
|
||
primary = next(item for item in scenarios if item["is_primary"])
|
||
saved = datetime.fromisoformat(primary["saved_at"])
|
||
resolved = {
|
||
"saved_at": primary["saved_at"], "segment": _segment(*segment), "choices": choices,
|
||
"key_charts": _key_chart_rows(req, saved, lines, []), "line_summary": _line_summary(lines, reported),
|
||
"remaining_lines": [{"at": _at_s(line.at), "charts": [key for key in KEY_CHARTS if key in line.flips]}
|
||
for line in lines],
|
||
"scenarios": scenarios, "scenarios_omitted": omitted, "both_versions": [],
|
||
"chosen_lines": chosen_lines,
|
||
}
|
||
if comparison_segment:
|
||
comparison_at = _self_choice_at(comparison_segment, reported, original)
|
||
resolved["comparison_scenario"] = {
|
||
"segment": _segment(*comparison_segment), "saved_at": _saved_at(comparison_at),
|
||
"key_charts": _key_chart_rows(req, comparison_at, [], []), "is_primary": False,
|
||
}
|
||
if len(lines) == 1:
|
||
line = lines[0]
|
||
other = next(item for item in scenarios if not item["is_primary"])
|
||
resolved.update(chosen_side="before" if saved < line.at else "after",
|
||
other_saved_at=other["saved_at"],
|
||
both_versions=[DOMAIN[key]["key"] for key in KEY_CHARTS if key in line.flips])
|
||
elif lines:
|
||
resolved.update(chosen_side="none", other_saved_at=None)
|
||
elif choices:
|
||
resolved["chosen_side"] = choices[-1]["side"]
|
||
|
||
result = {"decision": resolved}
|
||
if not deciding and next_line is not None:
|
||
view = _line_view(next_line, KEY_CHARTS)
|
||
result["next"] = {**view, "comparisons": _comparisons(req, next_line.at - ONE_SECOND, next_line.at, view["charts"])}
|
||
return result
|
||
|
||
|
||
def _evaluate(body: dict, *, deciding: bool) -> dict:
|
||
req, start, end, reported, known = _request(body)
|
||
if body.get("self_choice") is True:
|
||
return _self_choice(body, req, (start, end), reported, deciding=deciding)
|
||
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)
|