Files
Jyotisha/tests/test_chart_choice.py
T
jesse-ux 42b9f44963
Independent Staging Quality Gate / validate-python (pull_request) Successful in 6m55s
Independent Staging Quality Gate / validate-frontend (pull_request) Successful in 7m38s
Independent Staging Quality Gate / publish (pull_request) Skipped
Reject out-of-range event dates and record validation
Refs #241, BUG-1875
2026-11-13 14:44:05 +08:00

396 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.
"""Chart choice engine: dividing lines, readings, and the agreed decision rules."""
from __future__ import annotations
import sys
from datetime import datetime
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 astrologer, 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_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_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_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"] == (15, 21)
assert question["after_ages"] == (23, 28)
assert "15–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)]