396 lines
20 KiB
Python
396 lines
20 KiB
Python
"""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)]
|