700 lines
37 KiB
Python
700 lines
37 KiB
Python
"""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"]
|