Files
Jyotisha/scripts/chart_choice/service.py
T
2026-11-13 14:36:26 +08:00

436 lines
20 KiB
Python
Raw 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 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,
)
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, 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 = ("D1", "D9", "D10", "D2", "D6", "D8")
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 _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")
if resume is not None and (not isinstance(resume, dict) or len(raw) == MAX_ROUNDS):
raise ChartChoiceInputError("resume must leave room for the legacy choice")
lines_by_time: dict[datetime, Line] = {}
for line in find_lines(req, start, end):
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)
segment = (start, end)
rounds: list[dict] = []
normalized: list[dict] = []
events: 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)
result = {
**base,
"round": min(len(rounds) + 1, MAX_ROUNDS),
"max_rounds": MAX_ROUNDS,
"remaining_key_lines": len(ordered),
"ordered_lines": [_line_view(line, DOMAIN_ORDER) for line in ordered],
"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 len(rounds) == 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)
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]))
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],
) -> dict:
has_next = bool(lines and len(rounds) < MAX_ROUNDS and rule != "stopped")
return {
"saved_at": _saved_at(representative_time(segment, reported)),
"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,
**({"evidence_summary": interview.summarize(req, segment, reported, events)} if not has_next else {}),
"remaining_key_lines": len(lines),
"has_next": has_next,
"rule": rule,
}
def _evaluate(body: dict, *, deciding: bool) -> dict:
req, start, end, reported, known = _request(body)
multi = "resolved" in body or "resume" 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"):
raise ChartChoiceInputError("narrow the window before resolving lines")
return {**base, "status": "needs_narrowing", "narrowing": _narrowing(req, start, end)}
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)