Files
Jyotisha/scripts/report_render/evidence_grade.py
T
jesse-ux f914571ed6
Independent Staging Quality Gate / validate-python (pull_request) Successful in 10m19s
Independent Staging Quality Gate / validate-frontend (pull_request) Successful in 18m3s
Independent Staging Quality Gate / publish (pull_request) Skipped
Independent Staging Quality Gate / validate-python (push) Successful in 16m57s
Independent Staging Quality Gate / validate-frontend (push) Failing after 28m43s
Independent Staging Quality Gate / publish (push) Skipped
Clarify default birth time trials in reports (#280)
2026-11-15 13:29:05 +08:00

319 lines
15 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.
"""Per-claim evidence-grade caps for the report reading (`report_evidence_grade_v1`).
Astrologer 2026-11-12 (her repo 8aaf6099, handoff/2026-11-12/preset_q3 §1.3–1.4
and §5.2): the backend fixes each conclusion's required dependencies by route
and claim type, computes a grade ceiling from a six-axis evidence ledger, and the
model may only write at or below it. Grades are not probabilities.
| Grade | Meaning in this contract |
|---|---|
| A | strongly and independently validated on a defined case set (never reached here) |
| B | matching cases plus several independent methods agree (never reached here) |
| C | sourced and computable, but not calibrated on matching cases |
| D | a dependency the conclusion needs is missing, undecidable or in open conflict |
No conclusion in a report has matching external cases (event calibration is
`not_done` everywhere), so the ceiling is C at best. A conclusion falls to D when
a *required* layer of its route is missing, failed, withheld, or sits within the
birth-time tolerance of an ascendant change in a varga it needs. A missing layer
that only the route's checklist names (``checked``) is recorded in the ledger and
must be disclosed; it does not by itself make the conclusion D, because an
unrelated missing technique must not drag valid conclusions down (§5.2).
Dependencies follow her `references/strict-workflow-router.md` §2–§7 mandatory
modules. The split into ``required`` and ``checked`` is the product's v1 reading
of that list and is listed for her review.
"""
from __future__ import annotations
import re
from typing import Any
from .birth_precision_window import (
CONFIRMED_TOLERANCE_MINUTES, DEFAULT_WINDOW_SCENARIO, DEFAULT_WINDOW_SOURCE,
WINDOW_POLICY, crosses_birth_window, report_birth_window,
)
try:
from scripts.consult_card_domain_facts import PRECISION_VARGA
except ModuleNotFoundError: # pragma: no cover - direct scripts/ execution path
from consult_card_domain_facts import PRECISION_VARGA
GRADE_CONTRACT = "report_evidence_grade_v1"
GRADE_ORDER = ("A", "B", "C", "D")
# Keep the minute-confirmed policy and ledger shape for existing reports.
PRECISION_POLICY = "birth_record_minute_v1"
MISSING_STATES = {"blocked", "withheld", "missing", "calculation_failed", "missing_input", "not_computed"}
# Dependency kinds:
# ("p", domain, id) domain participation row
# ("s", id) shared technique row
# ("v", code) varga ascendant boundary relative to the birth-time tolerance
# ("t", key) timing / transit / annual block present
# Each claim type: route (her router section), section ids it may appear in,
# required deps (missing -> D) and checked deps (missing -> disclosed only).
CLAIM_TYPES: dict[str, dict[str, Any]] = {
"character_structure": {
"route": "full-reading-strict §2",
"sections": ("overview", "character"),
"required": [("v", "D1"), ("s", "functional")],
"checked": [("s", "d9"), ("v", "D9"), ("s", "shadbala"), ("s", "avastha"), ("s", "dispositor_chain")],
},
"career_promise": {
"route": "career-timing-strict §3",
"sections": ("overview", "career"),
"required": [("v", "D1"), ("s", "functional"), ("p", "career", "D10"), ("v", "D10")],
"checked": [("s", "d9"), ("p", "career", "AmK"), ("p", "career", "AK"), ("p", "career", "Karakamsha"),
("p", "career", "A10"), ("p", "career", "AL"), ("s", "shadbala"), ("s", "ashtakavarga"),
("s", "dispositor_chain"), ("p", "career", "D1_D9_D10"), ("s", "argala")],
},
"wealth_earning": {
"route": "finance-timing-strict §5",
"sections": ("overview", "wealth"),
"required": [("v", "D1"), ("s", "functional"), ("p", "wealth", "D2"), ("v", "D2")],
"checked": [("p", "wealth", "D11"), ("p", "wealth", "A2"), ("p", "wealth", "A11"), ("p", "wealth", "D10"),
("p", "wealth", "A10"), ("s", "shadbala"), ("s", "ashtakavarga"), ("s", "argala")],
},
"wealth_retention": {
"route": "finance-timing-strict §5",
"sections": ("overview", "wealth"),
"required": [("v", "D1"), ("s", "functional"), ("p", "wealth", "D2"), ("v", "D2")],
"checked": [("p", "wealth", "A2"), ("s", "shadbala"), ("s", "ashtakavarga"), ("s", "argala")],
},
"relationship_structure": {
"route": "relationship-timing-strict §4",
"sections": ("overview", "love"),
"required": [("v", "D1"), ("s", "functional"), ("p", "marriage", "D9_7"), ("v", "D9")],
"checked": [("p", "marriage", "UL"), ("p", "marriage", "A7"), ("p", "marriage", "DK"),
("p", "marriage", "Vivah"), ("s", "shadbala")],
},
"health_pressure": {
"route": "health-timing-strict §7",
"sections": ("overview", "health"),
"required": [("v", "D1"), ("s", "functional"), ("p", "health", "D6"), ("v", "D6")],
"checked": [("p", "health", "D8"), ("v", "D8"), ("p", "health", "D30"), ("v", "D30"),
("p", "health", "drekkana22"), ("s", "shadbala")],
},
"health_obstruction": {
"route": "health-timing-strict §7 + badhaka-obstacle-planet-guide.md §二",
"sections": ("health",),
"required": [("v", "D1"), ("p", "health", "Badhaka")],
"checked": [],
},
"timing_window": {
"route": "event-timing-strict §6",
"sections": ("overview", "career", "wealth", "love", "health", "now"),
"required": [("s", "vimshottari"), ("s", "narayana"), ("t", "transits")],
"checked": [("t", "annual"), ("t", "double_transit"), ("s", "yogini"), ("s", "kp")],
},
}
GRADED_SECTIONS = ("character", "career", "wealth", "love", "health", "now")
DEPENDENCY_ALIASES = {
"s:functional": ("功能吉凶",), "s:d9": ("九分盘尊贵度", "九分盘", "Navamsha", "D9"),
"s:shadbala": ("Shadbala", "六力"),
"s:avastha": ("Avastha", "星曜状态"), "s:dispositor_chain": ("定位星链",),
"s:ashtakavarga": ("Ashtakavarga", "八分法", "SAV"), "s:argala": ("Argala",),
"s:vimshottari": ("Vimshottari", "大运", "小运", "次小运"),
"s:narayana": ("Narayana", "纳拉亚纳"), "s:yogini": ("Yogini",), "s:kp": ("KP", "KP 判宫"),
"t:transits": ("过境", "行运"), "t:annual": ("年盘",),
"t:double_transit": ("Double Transit", "双行运", "双重行运", "双星过境"),
"p:career:AmK": ("AmK",), "p:career:AK": ("AK",), "p:career:Karakamsha": ("Karakamsha",),
"p:career:A10": ("A10",), "p:career:AL": ("AL",),
"p:wealth:A2": ("A2",), "p:wealth:A11": ("A11",), "p:wealth:A10": ("A10",),
"p:marriage:D9_7": ("九分盘第七宫", "九分盘", "Navamsha", "D9"),
"p:marriage:UL": ("UL",), "p:marriage:A7": ("A7",),
"p:marriage:DK": ("DK",), "p:marriage:Vivah": ("Vivah",),
"p:health:drekkana22": ("第22个Drekkana", "第22个三分盘"),
"p:health:Badhaka": ("Badhaka", "阻碍宫", "阻碍宫主"),
"v:D1": ("D1", "本命盘"), "v:D2": ("D2", "财富分盘"),
"v:D6": ("D6", "健康分盘"), "v:D9": ("D9", "九分盘", "Navamsha"),
"v:D10": ("D10", "事业分盘"),
}
_VARGA_CODE = re.compile(r"D(?:[1-9]|[1-5]\d|60)\Z")
def _dep_id(dep: tuple) -> str:
return ":".join(str(part) for part in dep)
def _participation(facts: dict, domain: str, item_id: str) -> str:
rows = ((facts.get("domains") or {}).get(domain) or {}).get("participation") or []
for row in rows:
if isinstance(row, dict) and row.get("id") == item_id:
return str(row.get("state") or "missing")
return "missing"
def _shared(facts: dict, item_id: str) -> str:
for row in facts.get("shared_techniques") or []:
if isinstance(row, dict) and row.get("id") == item_id:
return str(row.get("state") or "missing")
return "missing"
def _varga_boundary(facts: dict, code: str) -> tuple[str, dict[str, Any]]:
precision = facts.get("birth_precision") or {}
margin = (precision.get("ascendant_margins") or {}).get(code)
if not facts.get("minute_confirmed"):
window = report_birth_window(precision.get("window"), minute_confirmed=False)
detail = {"policy": WINDOW_POLICY, **window}
if code in PRECISION_VARGA:
return "not_evaluated", {**detail, "reason": "birth time not confirmed to the minute"}
if not isinstance(margin, dict) or any(margin.get(side) is None for side in ("before_minutes", "after_minutes")):
return "missing", {**detail, "reason": "no ascendant margin for this varga"}
before = float(margin["before_minutes"])
after = float(margin["after_minutes"])
detail.update(before_change_minutes=before, after_change_minutes=after, nearest_change_minutes=min(before, after))
crosses = crosses_birth_window(before, after, window)
return ("boundary_sensitive" if crosses else "clear_at_tolerance"), detail
if not isinstance(margin, dict):
return "missing", {"policy": PRECISION_POLICY, "reason": "no ascendant margin for this varga"}
nearest = min(float(margin.get("before_minutes", 0)), float(margin.get("after_minutes", 0)))
detail = {"policy": PRECISION_POLICY, "nearest_change_minutes": nearest,
"tolerance_minutes": CONFIRMED_TOLERANCE_MINUTES}
return ("clear_at_tolerance" if nearest > CONFIRMED_TOLERANCE_MINUTES else "boundary_sensitive"), detail
def _block_state(facts: dict, key: str) -> str:
if key == "transits":
return "executed" if (facts.get("transits") or {}).get("planets") else "missing"
if key == "annual":
annual = facts.get("annual") or {}
return "missing" if annual.get("status") == "blocked" or not annual else "executed"
if key == "double_transit":
double = (facts.get("transits") or {}).get("double_transit") or {}
return "executed" if double.get("checked_houses") else "missing"
return "missing"
def _parameter_sensitive(facts: dict) -> set[str]:
listed = (facts.get("blocked_states") or {}).get("parameter_sensitive") or []
out = {str(item) for item in listed}
narayana_status = ((facts.get("timing") or {}).get("narayana") or {}).get("status")
if narayana_status in {"partial", "partial_verified", "parameter_sensitive", "conditional"}:
out.add("narayana")
return out
def _evaluate(facts: dict, dep: tuple, sensitive: set[str]) -> dict[str, Any]:
kind = dep[0]
detail: dict[str, Any] = {}
if kind == "p":
state = _participation(facts, dep[1], dep[2])
elif kind == "s":
state = _shared(facts, dep[1])
if dep[1] in sensitive and state == "executed":
state = "parameter_sensitive"
elif kind == "v":
state, detail = _varga_boundary(facts, dep[1])
else:
state = _block_state(facts, dep[1])
return {"id": _dep_id(dep), "state": state, **({"detail": detail} if detail else {})}
def _is_missing(row: dict) -> bool:
return row["state"] in MISSING_STATES or row["state"] == "boundary_sensitive"
def _contradictions(facts: dict) -> list[dict[str, Any]]:
functional = facts.get("functional") or {}
return [row for row in functional.get("natural_vs_functional_conflicts") or [] if isinstance(row, dict)]
def claim_grade(facts: dict, claim_type: str) -> dict[str, Any]:
spec = CLAIM_TYPES[claim_type]
sensitive = _parameter_sensitive(facts)
required = [_evaluate(facts, dep, sensitive) for dep in spec["required"]]
checked = [_evaluate(facts, dep, sensitive) for dep in spec["checked"]]
missing_required = [row["id"] for row in required if _is_missing(row)]
must_disclose = [row["id"] for row in checked if _is_missing(row)]
sensitive_rows = [row["id"] for row in required + checked if row["state"] == "parameter_sensitive"]
boundary_rows = []
for row in required + checked:
if row["id"].startswith("v:"):
details = {key: value for key, value in row["detail"].items() if key != "policy"}
state = "clear" if row["state"] == "clear_at_tolerance" else row["state"]
boundary_rows.append({"id": row["id"], "state": state, **details})
precision = facts.get("birth_precision") or {}
purpose = precision.get("purpose_stability") or "not_evaluated"
if (precision.get("window") or {}).get("source") == DEFAULT_WINDOW_SOURCE:
purpose = DEFAULT_WINDOW_SCENARIO
must_disclose.append(DEFAULT_WINDOW_SCENARIO)
else:
if claim_type == "timing_window" and purpose == "stable":
purpose = "not_evaluated"
if purpose != "stable":
must_disclose.append("purpose_stability_not_evaluated")
cap = "D" if missing_required else "C"
reasons = (
[f"required dependency unavailable: {item}" for item in missing_required]
or ["no matching external cases: event calibration not done"]
)
return {
"route": spec["route"],
"sections": list(spec["sections"]),
"cap": cap,
"reasons": reasons,
"required": required,
"checked": checked,
"must_disclose": must_disclose,
"parameter_sensitive": sensitive_rows,
# Six axes (§5.2) plus the local boundary check.
"ledger": {
"case_fit": "none",
"method_maturity": "source_bounded" if not missing_required else "dependency_missing",
"independent_agreement": "not_assessed",
"purpose_stability": purpose,
"boundary_check": {"policy": _precision_policy(facts), "rows": boundary_rows},
"external_calculation_check": "not_done",
"contradiction": [f"{row.get('planet')}: natural {row.get('natural')} / functional {row.get('functional')}"
for row in _contradictions(facts)],
},
}
def _precision_policy(facts: dict) -> str:
return PRECISION_POLICY if facts.get("minute_confirmed") else WINDOW_POLICY
def _dependency_catalog(facts: dict) -> dict[str, dict[str, Any]]:
deps = {dep for spec in CLAIM_TYPES.values() for field in ("required", "checked") for dep in spec[field]}
for domain, row in (facts.get("domains") or {}).items():
if not isinstance(row, dict) or not isinstance(charts := row.get("varga_charts"), dict):
continue
for code, chart in charts.items():
if isinstance(code, str) and _VARGA_CODE.fullmatch(code) and isinstance(chart, dict):
deps.add(("v", code))
if _participation(facts, domain, code) != "missing":
deps.add(("p", domain, code))
sensitive = _parameter_sensitive(facts)
catalog = {}
for dep in sorted(deps):
row = _evaluate(facts, dep, sensitive)
code = dep[-1]
varga_alias = (code,) if dep[0] == "v" or (dep[0] == "p" and code != "D1" and _VARGA_CODE.fullmatch(code)) else ()
aliases = DEPENDENCY_ALIASES.get(row["id"], varga_alias)
catalog[row["id"]] = {"state": row["state"], "aliases": list(aliases)}
return catalog
def evidence_grades(facts: dict) -> dict[str, Any]:
"""The per-claim ceilings the reading must respect."""
return {
"contract": GRADE_CONTRACT,
"precision_policy": _precision_policy(facts),
"grade_order": list(GRADE_ORDER),
"graded_sections": list(GRADED_SECTIONS),
"claims": {name: claim_grade(facts, name) for name in CLAIM_TYPES},
"dependency_catalog": _dependency_catalog(facts),
}
def grade_allowed(grade: str, cap: str) -> bool:
"""A grade may equal its ceiling or be weaker (later in GRADE_ORDER)."""
return GRADE_ORDER.index(grade) >= GRADE_ORDER.index(cap)