Files
Jyotisha/tests/test_chart_choice.py
T

700 lines
37 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.
"""Chart choice engine: dividing lines, readings, and the agreed decision rules."""
from __future__ import annotations
import sys
from datetime import datetime, timedelta
from pathlib import Path
import pytest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "scripts"))
from scripts.chart_choice.boundaries import ( # noqa: E402
ChartChoiceInputError,
ChartRequest,
LEGACY_DIVISIONS,
Line,
find_lines,
nearest_line,
representative_minute,
representative_time,
segment_around,
signature,
)
from scripts.chart_choice import adaptive, astrologer, chart_questions, interview # noqa: E402
from scripts.chart_choice.decision import decide, decide_with_evidence, reported_is_neutral # noqa: E402
from scripts.chart_choice.service import build_packet, decide_packet # noqa: E402
# Fictional reference input (not a user record): mid-latitude north China, early morning.
BODY = {
"lat": 36.42, "lon": 114.21, "tz": 8,
"start_at": "1997-08-08T04:45", "end_at": "1997-08-08T05:15", "reported_at": "1997-08-08T05:00",
}
REQ = ChartRequest("1997-08-08", 36.42, 114.21, 8.0)
def test_adaptive_question_ranking_and_answer_limit(monkeypatch):
start, end = datetime(1997, 8, 8, 5), datetime(1997, 8, 8, 5, 15)
boundary = start + timedelta(minutes=5)
lines = [Line(boundary, 0, {"D9": (1, 2), "D10": (1, 2)})]
def candidates(chart, choices, kind, count):
for index in range(count):
yield {"id": f"{chart}-{index}", "chart": chart, "kind": kind,
"prompt": "A", "possibilities": [choice.view() for choice in choices],
"options": [{"value": "first", "possibilities": [0]}, {"value": "unsure"}]}
monkeypatch.setattr(adaptive, "_event_questions", lambda req, domain, choices, birth, today:
candidates(adaptive.DOMAINS[domain][0], choices, "event", 6))
first = adaptive.replay(REQ, start, (start, end), lines, {}, stop=False)
assert first["next"]["chart"] == "D9"
monkeypatch.setattr(adaptive, "_next_question", lambda req, birth, today, remaining, atoms, asked, domains, health:
next((question | {"domain": "relationship"} for chart in ("D9", "D10")
for question in candidates(chart, remaining[chart], "event", 6)
if question["id"] not in asked), None))
answers = {}
for index in range(12):
result = adaptive.replay(REQ, start, (start, end), lines, answers, stop=False)
expected_chart = "D9" if index < 6 else "D10"
assert result["next"]["id"] == f"{expected_chart}-{index % 6}"
assert result["live"] == [(start, end)]
assert set(result["unsettled"]) == {"D9", "D10"}
answers[result["next"]["id"]] = {"choice": "unsure"}
capped = adaptive.replay(REQ, start, (start, end), lines, answers, stop=False)
assert capped["next"] is None
assert len(capped["asked"]) == 12
assert all(item["before"] == item["after"] for item in capped["asked"])
stopped = adaptive.replay(REQ, start, (start, end), lines, {}, stop=True)
assert stopped["next"] is None and stopped["asked"] == []
assert stopped["live"] == [(start, end)]
@pytest.mark.parametrize(("start", "end", "expected_count"), [("04:45", "05:15", 1), ("04:30", "05:30", 2)])
def test_adaptive_uses_live_engine_intervals_until_all_charts_settle(start, end, expected_count, monkeypatch):
monkeypatch.setattr(interview, "_today", lambda req: datetime(2026, 11, 14))
request = {**BODY, "start_at": f"1997-08-08T{start}", "end_at": f"1997-08-08T{end}"}
legacy = build_packet({**request, "questionnaire": True})
assert len(legacy["chart_questions"]) == 5
request["adaptive"] = True
packet = build_packet(request)
answers = {}
while packet["status"] == "questionnaire":
[question] = packet["chart_questions"]
assert question["id"] not in answers
option = min((item for item in question["options"] if "possibilities" in item),
key=lambda item: len(item["possibilities"]))
answers[question["id"]] = {"choice": option["value"], "date": str(1997 + option["ages"][0]),
"category": question["categories"][0]["id"]}
packet = decide_packet({**request, "chart_answers": answers})
assert len(answers) <= 12
decision = packet["decision"]
assert len(answers) == expected_count
assert decision["undetermined_charts"] == []
assert decision["conflict"] == []
assert decision["segment"]["start_at"] <= decision["saved_at"] <= decision["segment"]["end_at"]
assert all(item["before"] != item["after"] for item in decision["asked"])
default = decision["reported_choice"]
without_answers = decide_packet({**request, "chart_answers": {}, "stop": True})["decision"]["reported_choice"]
assert default == without_answers
assert default["saved_at"] == BODY["reported_at"]
assert default["segment"] == {"start_at": request["start_at"], "end_at": request["end_at"]}
assert len(default["key_charts"]) == 6
assert default["undetermined_charts"]
assert {row["chart"] for row in default["key_charts"] if row.get("flips_at")} == set(default["undetermined_charts"])
def test_adaptive_ignores_a_stale_tail_and_leaves_unsettled_charts(monkeypatch):
monkeypatch.setattr(interview, "_today", lambda req: datetime(2026, 11, 14))
request = {**BODY, "adaptive": True}
[first] = build_packet(request)["chart_questions"]
skipped = {first["id"]: {"choice": "unsure"}}
[second] = decide_packet({**request, "chart_answers": skipped})["chart_questions"]
assert first["id"] != second["id"]
option = next(item for item in first["options"] if item.get("ages"))
changed = {first["id"]: {"choice": option["value"], "date": str(1997 + option["ages"][0]),
"category": first["categories"][0]["id"]},
second["id"]: {"choice": "unsure"}}
repaired = decide_packet({**request, "chart_answers": changed})["decision"]
assert [item["question"] for item in repaired["conflict"]] == [second["id"]]
assert len(repaired["asked"]) == 1
neutral = {}
packet = build_packet(request)
while packet["status"] == "questionnaire":
[question] = packet["chart_questions"]
neutral[question["id"]] = {"marks": ["none"]} if question["kind"] == "birthmarks" else {"choice": "unsure"}
packet = decide_packet({**request, "chart_answers": neutral})
assert len(neutral) <= 12
assert packet["decision"]["stop_reason"] == "no_answer_can_improve_separation"
assert packet["decision"]["undetermined_charts"]
assert packet["decision"]["segment"] == {"start_at": BODY["start_at"] + ":00", "end_at": BODY["end_at"] + ":00"}
def test_adaptive_preserves_the_reported_clock_when_screening_excludes_it():
original = {"start_at": BODY["start_at"], "end_at": BODY["end_at"]}
packet = decide_packet({
**BODY, "start_at": "1997-08-08T05:05", "adaptive": True, "stop": True,
"reported_default_window": original,
})
assert packet["reported_known"] is False
default = packet["decision"]["reported_choice"]
assert default["reported_known"] is True
assert default["saved_at"] == BODY["reported_at"]
assert default["segment"] == original
assert default["undetermined_charts"]
def test_adaptive_range_only_saves_original_midpoint_after_screening():
original = {"start_at": BODY["start_at"], "end_at": BODY["end_at"]}
packet = decide_packet({
**{key: value for key, value in BODY.items() if key != "reported_at"},
"start_at": "1997-08-08T05:05", "adaptive": True, "stop": True,
"reported_default_window": original,
})
default = packet["decision"]["reported_choice"]
assert default["reported_known"] is False
assert default["saved_at"] == "1997-08-08T05:00"
assert default["segment"] == original
def test_adaptive_health_is_gated_and_excluded_from_public_event_evidence(monkeypatch):
start, end = datetime(1997, 8, 8, 4, 45), datetime(1997, 8, 8, 5, 15)
lines = [Line(start + timedelta(minutes=5), 0, {"D9": (1, 2)}),
Line(start + timedelta(minutes=10), 0, {"D10": (1, 2), "D30": (1, 2)})]
monkeypatch.setattr("scripts.chart_choice.service.find_lines", lambda *args: lines)
def candidates(req, domain, choices, birth, today):
chart, _, categories = adaptive.DOMAINS[domain]
if domain not in ("relationship", "health_pressure"):
return
yield {"id": f"{chart}-{categories[0]}-1", "chart": chart, "kind": "event", "prompt": "A",
"possibilities": [choice.view() for choice in choices],
"options": [{"value": "age-20-20", "ages": [20, 20], "possibilities": [0 if chart == "D30" else 1]},
{"value": "unsure"}],
"categories": adaptive.HEALTH_CATEGORIES if chart == "D30" else [{"id": "relationship", "value": "relationship"}]}
monkeypatch.setattr(adaptive, "_event_questions", candidates)
request = {**BODY, "adaptive": True}
[first] = build_packet(request)["chart_questions"]
assert first["chart"] == "D9"
first_answer = {first["id"]: {"choice": "age-20-20", "date": "2017", "category": "relationship"}}
[health] = decide_packet({**request, "chart_answers": first_answer})["chart_questions"]
assert health["chart"] == "D30"
skipped = decide_packet({**request, "chart_answers": {**first_answer, health["id"]: {"choice": "unsure"}}})["decision"]
assert skipped["asked"][-1]["before"] == skipped["asked"][-1]["after"]
assert skipped["asked"][-1]["answer"] == {}
answered = decide_packet({**request, "chart_answers": {**first_answer, health["id"]:
{"choice": "age-20-20", "date": "2017-10", "category": "surgery"}}})["decision"]
assert len([item for item in answered["asked"] if item["chart"] == "D30"]) == 1
assert answered["asked"][-1]["answer"] == {"date": "2017", "category": "surgery"}
assert all(item["category"] == "relationship" for item in answered["events"] + answered["events_detail"])
assert all(item["chart"] != "D30" for item in answered["key_charts"])
def test_adaptive_confidence_caps_a_disagreement_between_the_two_dashas(monkeypatch):
birth = datetime(1997, 8, 8, 5)
selected = (birth, birth + timedelta(minutes=4))
alternative = (birth + timedelta(minutes=5), birth + timedelta(minutes=9))
events = [{"category": category, "date": "2020"}
for category in ("education", "travel", "career", "finance_pos")]
disagreement = False
monkeypatch.setattr(adaptive, "_minute_row", lambda req, at: at)
def score(events, at, base):
chain = {"activates": {"md": True, "ad": True, "narayana_md": not disagreement, "narayana_ad": False}}
return {"total": 80 if at < alternative[0] else 60, "events": [{"chain": chain}]}
monkeypatch.setattr(astrologer, "score_minute", score)
assert adaptive.confidence(REQ, birth, selected, [selected, alternative], events) == "high"
assert adaptive.confidence(REQ, birth, selected, [selected, alternative], events[:3]) == "medium"
assert adaptive.confidence(REQ, birth, selected, [selected, alternative], events[:2]) == "tendency_only"
disagreement = True
assert adaptive.confidence(REQ, birth, selected, [selected, alternative], events) == "low"
def test_lines_are_exact_and_merge_charts_that_flip_together():
lines = find_lines(REQ, datetime(1997, 8, 8, 4, 45), datetime(1997, 8, 8, 5, 15), LEGACY_DIVISIONS)
fifteen = next(line for line in lines if line.degree == 15.0)
assert set(fifteen.flips) == {"D2", "D4", "D10", "D12", "D24"}
assert fifteen.at.strftime("%H:%M") == "04:59"
assert any("D9" in line.flips for line in lines), "D9 lines must not be lost to float rounding"
for line in lines:
before = signature((line.degree - 1e-4) + 90, LEGACY_DIVISIONS) # Cancer: sign index 3 → 90°
after = signature((line.degree + 1e-4) + 90, LEGACY_DIVISIONS)
assert {k for k in before if before[k] != after[k]} == set(line.flips)
def test_nearest_line_and_segments():
start, end = datetime(1997, 8, 8, 4, 45), datetime(1997, 8, 8, 5, 15)
lines = find_lines(REQ, start, end, LEGACY_DIVISIONS)
reported = datetime(1997, 8, 8, 5, 0)
line = nearest_line(lines, reported)
assert line.degree == 15.0
before, after = segment_around(lines, line, start, end)
assert before[1] == after[0] == line.at
assert representative_minute(after, reported) == reported
saved_before = representative_minute(before, reported)
assert before[0] < saved_before < before[1]
assert (before[1] - saved_before).total_seconds() >= 60
def test_packet_lists_only_charts_that_flip_and_unchanged_ones():
packet = build_packet(BODY)
assert packet["status"] == "choose"
assert packet["line"]["charts"] == ["D10", "D4", "D2", "D12", "D24"]
assert [u["chart"] for u in packet["unchanged"]] == ["D1", "D9"]
assert packet["reported_side"] == "after"
assert packet["reported_neutral"] is True
assert 1 <= len(packet["questions"]) <= 5
for question in packet["questions"]:
texts = [o["text"] for o in question["options"]]
assert texts[0] != texts[1] and texts[2] == "说不清"
def test_decision_majority_when_reported_time_is_neutral():
answers = {"career": "before", "home": "after", "money": "before", "parents": "before", "study": "after"}
result = decide_packet({**BODY, "answers": answers})["decision"]
assert result["chosen_side"] == "before"
assert result["rule"] == "majority"
assert result["both_versions_domains"] == ["home", "study"]
assert result["saved_at"] == "1997-08-08T04:56"
def test_decision_rules():
assert decide({"a": "before", "b": "after"}, reported_side="after", neutral=True)["rule"] == "tie_keeps_reported"
kept = decide({"a": "before", "b": "before", "c": "before", "d": "after"}, reported_side="after", neutral=False)
assert kept["chosen_side"] == "after" and kept["rule"] == "reported_kept"
flipped = decide({"a": "before", "b": "before", "c": "before", "d": "before", "e": "after"},
reported_side="after", neutral=False)
assert flipped["chosen_side"] == "before" and flipped["rule"] == "strong_override"
assert flipped["both_versions_domains"] == ["e"]
unsure = decide({"a": "unsure"}, reported_side="before", neutral=True)
assert unsure["chosen_side"] == "before" and unsure["both_versions_domains"] == []
def test_reported_neutral_rules():
line = datetime(1997, 8, 8, 5, 20, 30)
assert reported_is_neutral(datetime(1997, 8, 8, 5, 30), line, reported_known=True) # rounded
assert reported_is_neutral(datetime(1997, 8, 8, 5, 22), line, reported_known=True) # near line
assert not reported_is_neutral(datetime(1997, 8, 8, 5, 37), line, reported_known=True)
assert reported_is_neutral(datetime(1997, 8, 8, 5, 37), line, reported_known=False)
def test_override_and_read_both():
result = decide_packet({**BODY, "override_side": "before", "read_both_all": True})["decision"]
assert result["chosen_side"] == "before" and result["rule"] == "user_override"
assert set(result["both_versions_domains"]) == {"career", "home", "money", "parents", "study"}
def test_answers_for_unasked_domains_are_ignored():
result = decide_packet({**BODY, "answers": {"relationship": "before", "self": "before"}})
assert result["answers"] == {}
assert result["decision"]["chosen_side"] == "after"
def test_wide_window_asks_to_narrow_first():
packet = build_packet({**BODY, "start_at": "1997-08-08T03:00", "end_at": "1997-08-08T08:00"})
assert packet["status"] == "needs_narrowing"
options = packet["narrowing"]["options"]
assert options[0]["start_at"] == "1997-08-08T03:00" and options[1]["end_at"] == "1997-08-08T08:00"
assert options[0]["end_at"] == options[1]["start_at"]
assert packet["narrowing"]["anchor"] == "sunrise" # sunrise falls inside 03:00–08:00 here
def test_no_line_means_certain():
packet = build_packet({**BODY, "start_at": "1997-08-08T04:55", "end_at": "1997-08-08T04:58", "reported_at": "1997-08-08T04:56"})
assert packet["status"] == "certain" and packet["saved_at"] == "1997-08-08T04:56"
def test_reported_outside_window_falls_back_to_middle():
packet = build_packet({**BODY, "reported_at": "1997-08-08T06:00"})
assert packet["reported_known"] is False and packet["reported_at"] == "1997-08-08T05:00"
@pytest.mark.parametrize("patch", [
{"start_at": "1997-08-08T05:15", "end_at": "1997-08-08T04:45"},
{"lat": 120},
{"start_at": None},
{"start_at": "5pm"},
{"end_at": "1997-08-10T05:15"},
{"node_mode": "osculating"},
])
def test_bad_input(patch):
with pytest.raises(ChartChoiceInputError):
build_packet({**BODY, **patch})
def test_decide_requires_a_choice():
with pytest.raises(ChartChoiceInputError):
decide_packet({**BODY, "start_at": "1997-08-08T04:55", "end_at": "1997-08-08T04:58", "reported_at": "1997-08-08T04:56"})
def test_window_across_midnight():
packet = build_packet({**BODY, "start_at": "1997-08-07T23:40", "end_at": "1997-08-08T00:20",
"reported_at": "1997-08-08T00:00"})
assert packet["status"] in ("choose", "certain")
if packet["status"] == "choose":
assert packet["sides"]["before"]["from"] >= "1997-08-07T23:40"
def test_widest_quick_range_is_compared_without_narrowing():
# BUG-1649: 「前后 1 小时」 (121 minutes) must not be split, or the range saved back could miss the time.
packet = build_packet({**BODY, "start_at": "1997-08-08T04:00", "end_at": "1997-08-08T06:00"})
assert packet["status"] == "choose"
def test_each_side_carries_its_ascendant_sign_for_the_mini_chart():
packet = build_packet(BODY)
career = next(c for c in packet["comparisons"] if c["chart"] == "D10")
assert (career["before"]["ascendant_index"], career["after"]["ascendant_index"]) == (3, 4) # 巨蟹 → 狮子
def synthetic_scan(monkeypatch, *entries):
lines = [Line(datetime.fromisoformat(f"1997-08-08T{stamp}"), 0, {chart: (0, 1) for chart in charts})
for stamp, charts in entries]
monkeypatch.setattr("scripts.chart_choice.service.find_lines", lambda *_: lines)
monkeypatch.setattr("scripts.chart_choice.service._planets_and_asc", lambda *_: ({}, 0.0))
return [line.at.isoformat() for line in lines]
def test_v2_orders_key_lines_then_confirms_three_sides(monkeypatch):
first, second, third, _ = synthetic_scan(monkeypatch,
("04:59:42", ["D1", "D9"]), ("05:07:55", ["D9"]), ("05:14:30", ["D10"]), ("05:14:43", ["D24"]),
)
resolved = []
for n, (at, side) in enumerate([(first, "after"), (second, "after"), (third, "before")], 1):
packet = build_packet({**BODY, "resolved": resolved})
assert packet["round"] == n
assert packet["line"]["at"] == at
assert packet["remaining_key_lines"] == 4 - n
assert packet["ordered_lines"][0]["at"] == at
decision = decide_packet({**BODY, "resolved": resolved, "override_side": side})["decision"]
assert decision["rounds"][-1]["rule"] == "user_override"
resolved = decision["resolved"]
assert decision["segment"] == {"start_at": second, "end_at": "1997-08-08T05:14:29"}
assert decision["undetermined_charts"] == []
assert not decision["has_next"]
assert decision["events"] == []
assert [row["rule"] for row in decision["rounds"]] == ["user_override"] * 3
def test_v2_limits_rounds_and_stops_without_discarding_current_segment(monkeypatch):
first, second, third, fourth = synthetic_scan(monkeypatch,
("04:51:00", ["D1"]), ("04:54:00", ["D9"]), ("04:56:00", ["D10"]), ("05:02:00", ["D6", "D8"]),
)
resolved = [{"line_at": at, "side": "after"} for at in [first, second]]
stopped = decide_packet({**BODY, "resolved": resolved, "stop": True})
assert stopped["status"] == "complete"
assert stopped["decision"]["segment"]["start_at"] == second
assert stopped["decision"]["undetermined_charts"] == ["D10", "D6", "D8"]
assert not stopped["decision"]["has_next"]
last = decide_packet({**BODY, "resolved": resolved, "override_side": "after"})["decision"]
assert not last["has_next"]
assert last["undetermined_charts"] == ["D6", "D8"]
assert last["remaining_key_lines"] == 1
complete = build_packet({**BODY, "resolved": [*resolved, {"line_at": third, "side": "after"}]})
assert complete["status"] == "complete"
assert complete["ordered_lines"][0]["at"] == fourth
def test_v2_short_final_segment_uses_an_interior_whole_second(monkeypatch):
line, = synthetic_scan(monkeypatch, ("04:59:43", ["D1"]))
body = {**BODY, "end_at": "1997-08-08T05:00", "resolved": []}
result = decide_packet({**body, "override_side": "after"})["decision"]
assert result["segment"] == {"start_at": line, "end_at": "1997-08-08T05:00:00"}
assert result["saved_at"] == "1997-08-08T04:59:51"
assert line < result["saved_at"] < result["segment"]["end_at"]
assert representative_time((datetime.fromisoformat(line), datetime(1997, 8, 8, 5)), datetime(1997, 8, 8, 4, 59)).second == 51
def test_v2_detects_d6_d8_and_ignores_non_key_only_lines():
lines = find_lines(REQ, datetime(1997, 8, 8, 4, 45), datetime(1997, 8, 8, 5, 15))
assert any("D6" in line.flips for line in lines)
assert any("D8" in line.flips for line in lines)
packet = build_packet({**BODY, "resolved": []})
assert all(set(line["charts"]) & {"D1", "D2", "D6", "D8", "D9", "D10"} for line in packet["ordered_lines"])
assert packet["engine_version"] == "chart-choice-v2"
assert build_packet(BODY)["engine_version"] == "chart-choice-v1"
def test_v2_checks_resolution_order_and_timestamp_tolerance(monkeypatch):
first, second, third = synthetic_scan(monkeypatch,
("04:55:02", ["D1"]), ("04:55:03", ["D9"]), ("05:00:02", ["D10"]),
)
one_second_away = "1997-08-08T04:55:01"
packet = build_packet({**BODY, "resolved": [{"line_at": one_second_away, "side": "after"}]})
assert packet["resolved"][0]["line_at"] == first
assert packet["line"]["at"] == second
with pytest.raises(ChartChoiceInputError):
build_packet({**BODY, "resolved": [{"line_at": third, "side": "after"}]})
with pytest.raises(ChartChoiceInputError):
build_packet({**BODY, "resolved": [{"line_at": second, "side": "after"}]})
with pytest.raises(ChartChoiceInputError):
build_packet({**BODY, "resolved": [{"line_at": "1997-08-08T04:55:00", "side": "after"}]})
def test_v2_resume_a_saved_v1_side_and_continue(monkeypatch):
first, second = synthetic_scan(monkeypatch, ("04:59:42", ["D24"]), ("05:07:55", ["D9"]))
legacy = {"line_at": first, "side": "after", "reported_at": BODY["reported_at"]}
packet = build_packet({**BODY, "resume": legacy})
assert packet["remaining_key_lines"] == 1
assert packet["line"]["at"] == second
assert packet["round"] == 2
result = decide_packet({**BODY, "resume": legacy, "override_side": "after"})["decision"]
assert result["rounds"][0]["rule"] == "legacy_record"
assert result["undetermined_charts"] == []
def test_v2_resumes_saved_seconds_with_a_fresh_round_budget(monkeypatch):
first, second, third, fourth = synthetic_scan(monkeypatch,
("04:54:02", ["D1"]), ("04:56:03", ["D9"]), ("04:58:04", ["D10"]), ("05:02:05", ["D6"]),
)
segment = {"start_at": "1997-08-08T04:53:11", "end_at": "1997-08-08T05:05:39"}
previous_rounds = [{"line_at": f"1997-08-08T04:{minute}:00", "chosen_side": "after"} for minute in (47, 49, 51)]
events = [{"date": "2019", "category": "relationship"}]
monkeypatch.setattr("scripts.chart_choice.interview.summarize", lambda *args, **kwargs: {"event_count": len(args[-1])})
body = {**BODY, "resume_v2": {"segment": segment, "rounds": previous_rounds, "events": events}}
packet = build_packet(body)
assert (packet["round"], packet["segment"], packet["events"]) == (1, segment, events)
assert packet["remaining_key_lines"] == 4
resolved = []
for at in (first, second, third):
decision = decide_packet({**body, "resolved": resolved, "override_side": "after"})["decision"]
assert decision["resolved"][-1]["line_at"] == at
resolved = decision["resolved"]
assert not decision["has_next"]
assert decision["events"] == events
assert decision["rounds"][:3] == previous_rounds
assert [row["line_at"] for row in decision["rounds"][3:]] == [first, second, third]
assert decision["segment"] == {"start_at": third, "end_at": segment["end_at"]}
assert decision["remaining_key_lines"] == 1
assert build_packet({**body, "resolved": resolved})["ordered_lines"][0]["at"] == fourth
def test_v2_resume_rejects_a_saved_segment_outside_the_original_range():
segment = {"start_at": "1997-08-08T04:44:59", "end_at": "1997-08-08T05:05:39"}
with pytest.raises(ChartChoiceInputError, match="saved segment is outside its window"):
build_packet({**BODY, "resume_v2": {"segment": segment, "rounds": [], "events": []}})
def test_v2_non_key_only_window_is_certain_and_same_tier_uses_distance(monkeypatch):
synthetic_scan(monkeypatch, ("04:59:00", ["D4", "D12", "D24"]))
certain = build_packet({**BODY, "resolved": []})
assert certain["status"] == "certain"
assert certain["ordered_lines"] == []
assert certain["decision"]["undetermined_charts"] == []
first, second, third = synthetic_scan(monkeypatch,
("04:51:00", ["D2"]), ("04:57:00", ["D8"]), ("05:00:05", ["D6"]),
)
packet = build_packet({**BODY, "resolved": []})
assert [line["at"] for line in packet["ordered_lines"]] == [third, second, first]
def test_v2_display_fields_use_real_ascendant_scan_and_saved_time_score():
reported = datetime.fromisoformat(BODY["reported_at"])
req = {**BODY, "resolved": []}
packet = build_packet(req)
lines = find_lines(REQ, datetime.fromisoformat(BODY["start_at"]), datetime.fromisoformat(BODY["end_at"]))
minor = {"D4", "D12", "D24"}
assert packet["minor_lines"] == [
{"at": line.at.isoformat(), "charts": sorted(line.flips, key=lambda key: int(key[1:]))}
for line in lines if set(line.flips) <= minor
]
assert packet["minor_lines"]
assert len(packet["key_charts"]) == 6
events = [{"date": "2019", "category": "relationship"}, {"date": "2021", "category": "job_change"}]
stopped = decide_packet({**req, "stop": True, "resume_v2": {
"segment": packet["segment"], "rounds": [], "events": [*events, events[0]],
}})["decision"]
saved = datetime.fromisoformat(stopped["saved_at"])
row = astrologer._minute_row(REQ, saved)
scores = astrologer.score_minute(astrologer.parse_events(events, reported), row, astrologer._minute_row(REQ, reported))
assert stopped["events_detail"] == [
{**event, "matched": score["matched"]} for event, score in zip(events, scores["events"], strict=True)
]
assert stopped["evidence_summary"]["matched"] == scores["matched"]
from scripts.chart_choice.readings import SIGN_CN
signs = signature(row["chart"]["ascendant"]["lon"])
for item in stopped["key_charts"]:
key = item["chart"]
first = next((line.at.isoformat() for line in lines if key in line.flips), None)
assert item["sign"] == SIGN_CN[signs[key]]
assert item.get("flips_at") == first
assert item["decided_by"] is None
def test_v2_same_second_combines_flips_and_a_one_second_side_can_be_kept(monkeypatch):
at, _ = synthetic_scan(monkeypatch, ("05:00:00", ["D9"]), ("05:00:00", ["D10"]))
body = {**BODY, "end_at": "1997-08-08T05:00", "resolved": [], "override_side": "after"}
result = decide_packet(body)
assert result["line"]["charts"] == ["D9", "D10"]
assert result["decision"]["segment"] == {"start_at": at, "end_at": at}
assert result["decision"]["saved_at"] == "1997-08-08T05:00"
assert not result["decision"]["undetermined_charts"]
def test_v2_uses_supported_d9_age_windows_and_carries_dated_events(monkeypatch):
first, second = synthetic_scan(monkeypatch, ("04:59:00", ["D9"]), ("05:03:00", ["D6"]))
birth = datetime(1997, 8, 8, 5)
left_end, right_start, cutoff = (birth.replace(year=year, hour=0) for year in (2019, 2020, 2026))
monkeypatch.setattr(interview, "_today", lambda _: cutoff)
monkeypatch.setattr(interview, "_boundaries", lambda *_: {left_end, right_start})
monkeypatch.setattr(astrologer, "_minute_row", lambda req, at: {
"at": at, "timeline": [{"end": cutoff}], "before": at < datetime.fromisoformat(first),
})
monkeypatch.setattr(astrologer, "_varga_score", lambda *_: 0)
monkeypatch.setattr(astrologer, "_dasha_score", lambda event, row: (
6 if (row["before"] and event["at"] < left_end) or (not row["before"] and event["at"] >= right_start) else 0, {},
))
req = {**BODY, "resolved": []}
packet = build_packet(req)
question, = packet["event_questions"]
assert question["chart"] == "D9"
assert question["before_ages"] == (18, 21)
assert question["after_ages"] == (23, 28)
assert "18–21 岁" in question["prompt"] and "23–28 岁" in question["prompt"]
assert [o["value"] for o in question["options"]] == ["before", "after", "both", "neither", "unsure"]
assert len(question["follow_up"]["categories"]) == 3
event = {"date": "2022-06", "category": "relationship"}
answer = {"D9": {"choice": "after", "dates": {"after": event}}}
result = decide_packet({**req, "event_answers": answer})["decision"]
assert result["rule"] == "evidence" and result["chosen_side"] == "after"
assert result["events"] == [event]
continued = build_packet({**req, "resolved": result["resolved"]})
assert continued["events"] == [event]
assert continued["resolved"][0]["event_answers"] == answer
assert continued["line"]["at"] == second
assert continued["event_questions"] == []
for invalid_date in ("2015", "9999-12"):
with pytest.raises(ChartChoiceInputError, match="outside"):
decide_packet({**req, "event_answers": {"D9": {"choice": "after", "dates": {
"after": {"date": invalid_date, "category": "relationship"},
}}}})
def test_v2_equal_event_windows_are_omitted_and_only_d1_has_appearance_and_marks(monkeypatch):
d1, _ = synthetic_scan(monkeypatch, ("04:59:00", ["D1", "D9"]), ("05:03:00", ["D10"]))
monkeypatch.setattr(astrologer, "_minute_row", lambda req, at: {
"at": at, "timeline": [{"end": datetime(2026, 1, 1)}], "asc": int(at >= datetime.fromisoformat(d1)),
})
monkeypatch.setattr(interview, "_boundaries", lambda *_: set())
monkeypatch.setattr(astrologer, "_dasha_score", lambda *_: (6, {}))
monkeypatch.setattr(astrologer, "_varga_score", lambda *_: 0)
monkeypatch.setattr("scripts.chart_choice.service.build_question", lambda before, after: {"chart": before["chart"]})
first = build_packet({**BODY, "resolved": []})
assert first["event_questions"] == []
assert first["questions"] and all(q["optional"] for q in first["questions"])
assert [o["value"] for o in first["appearance_question"]["options"]] == ["before", "after", "unsure"]
assert first["birthmark_question"]["multiple"] and len(first["birthmark_question"]["options"]) == 14
next_packet = build_packet({**BODY, "resolved": [{"line_at": d1, "side": "after"}]})
assert next_packet["line"]["charts"] == ["D10"]
assert "appearance_question" not in next_packet and "birthmark_question" not in next_packet
def test_v2_evidence_scores_report_the_fallback_and_each_source():
evidence = [
{"kind": "event", "id": "D9", "choice": "after", "before": 0, "after": 2},
{"kind": "appearance", "choice": "before", "before": 1, "after": 0},
]
result = decide_with_evidence({"career": "before", "money": "before"}, evidence,
reported_side="after", neutral=True, override=None)
assert result["scores"] == {"before": 2, "after": 2}
assert result["rule"] == "majority" and result["chosen_side"] == "before"
assert result["decided_by"] == "supplement"
assert result["sources"][:2] == evidence
assert [(item["id"], item["before"]) for item in result["sources"][2:]] == [("career", 0.5), ("money", 0.5)]
def test_v2_d6_d8_can_be_decided_by_supplements(monkeypatch):
synthetic_scan(monkeypatch, ("04:59:00", ["D6", "D8"]))
monkeypatch.setattr("scripts.chart_choice.service.build_question", lambda before, after: {
"chart": before["chart"], "domain": before["domain"],
})
result = decide_packet({**BODY, "resolved": [], "answers": {"pressure": "before", "change": "before"}})
assert result["event_questions"] == []
assert all(q["optional"] for q in result["questions"])
decision = result["decision"]
assert decision["scores"] == {"before": 1, "after": 0}
assert decision["rounds"][0]["decided_by"] == "supplement"
assert set(decision["rounds"][0]["charts"]) == {"D6", "D8"}
def test_v2_final_evidence_scores_only_minutes_inside_the_selected_segment(monkeypatch):
seen = []
monkeypatch.setattr(astrologer, "_minute_row", lambda req, at: {"at": at})
def score(events, row, base):
seen.append(row["at"])
return {"matched": len(events), "total": 65 if row["at"].minute == 1 else 45}
monkeypatch.setattr(astrologer, "score_minute", score)
start, end = datetime(1997, 8, 8, 5, 0, 15), datetime(1997, 8, 8, 5, 2, 15)
events = [{"date": str(year), "category": "relationship"} for year in range(2020, 2024)]
two = interview.summarize(REQ, (start, end), datetime(1997, 8, 8, 5), events[:2])
four = interview.summarize(REQ, (start, end), datetime(1997, 8, 8, 5), events)
assert (two["event_count"], two["matched"], two["confidence"]) == (2, 2, "tendency_only")
assert (four["event_count"], four["matched"], four["confidence"]) == (4, 4, "medium")
assert four["caveat"] == astrologer.CAVEAT
assert seen == [start.replace(minute=minute, second=0) for minute in (1, 2, 1, 2)]
def test_questionnaire_merges_overlapping_age_options():
options = chart_questions.merge_age_options([((19, 21), 0), ((21, 23), 1), ((27, 27), 2)])
assert [(row["ages"], row["possibilities"]) for row in options] == [([19, 23], [0, 1]), ([27, 27], [2])]
def test_questionnaire_uses_supplement_when_age_options_do_not_distinguish(monkeypatch):
monkeypatch.setattr(chart_questions, "_event_options", lambda *_: [
{"value": "age-0", "text": "22 岁", "ages": [22, 22], "possibilities": [0]},
])
request = {**BODY, "questionnaire": True}
packet = build_packet(request)
assert next(q for q in packet["chart_questions"] if q["id"] == "D9")["kind"] == "supplement"
def test_questionnaire_drops_supplements_before_d1_and_reports_incompatible_events():
start = datetime.fromisoformat(BODY["start_at"])
at = lambda minute: start.replace(hour=5, minute=minute)
segment = (start, at(15))
event = chart_questions.Constraint("D9", "D9", "event", ((at(1), at(9)),))
wide_event = chart_questions.Constraint("D10", "D10", "event", ((at(10), at(15)),))
supplement = chart_questions.Constraint("D6", "D6", "supplement", ((at(10), at(11)),))
appearance = chart_questions.Constraint("D1", "D1", "appearance", ((at(1), at(3)),))
selected, retained, conflicts = chart_questions.select_segment(segment, at(2), [event, supplement, appearance])
assert selected == (at(1), at(3))
assert retained == [event, appearance]
assert [item["question"] for item in conflicts] == ["D6"]
wrong_appearance = chart_questions.Constraint("D1", "D1", "appearance", ((at(10), at(11)),))
selected, _, conflicts = chart_questions.select_segment(segment, at(2), [event, supplement, wrong_appearance])
assert selected == (at(1), at(9))
assert [item["question"] for item in conflicts] == ["D6", "D1"]
selected, retained, conflicts = chart_questions.select_segment(segment, at(2), [event, wide_event])
assert selected == (at(1), at(9))
assert retained == [event] and [item["question"] for item in conflicts] == ["D10"]
def test_questionnaire_reuses_saved_events_and_only_asks_unresolved_charts():
request = {**BODY, "questionnaire": True, "start_at": "1997-08-08T04:30", "end_at": "1997-08-08T05:30"}
packet = build_packet(request)
assert packet["remaining_key_lines"] == 11
assert 0 < len(packet["chart_questions"]) <= 8
question = next(q for q in packet["chart_questions"] if q["id"] == "D9")
option = next(o for o in question["options"] if o.get("ages"))
assert option["ages"][0] >= 18
category = question["categories"][0]["id"]
with pytest.raises(ChartChoiceInputError, match="outside the selected age window"):
decide_packet({**request, "chart_answers": {"D9": {"choice": option["value"], "date": "2010", "category": category}}})
date = str(1997 + option["ages"][0])
decision = decide_packet({**request, "chart_answers": {"D9": {"choice": option["value"], "date": date, "category": category}}})["decision"]
assert decision["events_detail"][0]["date"] == date
assert decision["segment"] in [
{key: question["possibilities"][i][key] for key in ("start_at", "end_at")}
for i in option["possibilities"]
]
resumed = build_packet({**request, "resume_v2": {
"segment": packet["segment"], "rounds": [], "undetermined_charts": ["D9"], "events": decision["events"],
}})
assert [q["chart"] for q in resumed["chart_questions"]] == ["D9"]
assert resumed["events"] == decision["events"]