Files
Jyotisha/scripts/report_render/conditional_dasha_applicability.py
T
ClaudeandClaude Opus 5.5 5816572009
Independent Staging Quality Gate / validate-frontend (push) Successful in 6m11s
Independent Staging Quality Gate / validate-python (push) Successful in 7m39s
Independent Staging Quality Gate / publish (push) Successful in 3m16s
fix(report): computed facts reach the report: equatorial declination, Ishta/Kashta, year-lord candidates, conditional dasha reasons, both Narayana readings, Sade Sati dates, cancellation witnesses, Tithi lord; dosha and functional tables in reader words; one yoga page per instance (BUG-2088, BUG-2089)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DbBXp2Vp62Ur3C7yRWQdSq
2026-11-20 20:36:22 +08:00

236 lines
11 KiB
Python

"""What each conditional dasha's applicability test actually tested (BUG-2088).
Astrologer reply 2026-11-20, B10: "table generated" and "condition applies"
are two different facts. The report used to print a name and one word. The
dasha modules already return the rule family and the inputs they tested
(e.g. ``panchottari_dasha.panchottari_applicability``); this module collects
them per family for the report:
* ``condition``: True / False / None. None means not determined, never "no".
* ``inputs``: the values the gate looked at. They come from
- ``engine``: the fields the module returned (the reference copy under
``conditional_dasha_reference`` keeps them when the gate fails, and the
Ashtottari family carries its gate results);
- ``recomputed``: when the gate passed, the public packet keeps only the
period table. For gates that read nothing but D1 positions the module's
own gate function is called again on the packet's longitudes, and the
result is used only if it agrees with the engine's verdict;
- ``None``: not carried and not safely recomputable. It stays unknown.
* ``table``: ``condition_met`` (a table from the met condition),
``reference_only`` (the table was generated although the condition is not
met, for comparison), ``none``, or ``None`` when unknown.
No alternative reading (PVR's Panchottari D12-only, Dwisaptati sama variant)
is computed here; the report only says such readings exist.
"""
from __future__ import annotations
from typing import Any, Dict, List, Optional
try:
from chaturshitisama_dasha import chaturshitisama_applicability
from dwisaptatisama_dasha import dwisaptatisama_applicability
from panchottari_dasha import panchottari_applicability
from shastihayani_dasha import shastihayani_applicability
from shodashottari_dasha import shodashottari_applicability
except ImportError: # pragma: no cover - package import
from scripts.chaturshitisama_dasha import chaturshitisama_applicability
from scripts.dwisaptatisama_dasha import dwisaptatisama_applicability
from scripts.panchottari_dasha import panchottari_applicability
from scripts.shastihayani_dasha import shastihayani_applicability
from scripts.shodashottari_dasha import shodashottari_applicability
FAMILY_ORDER = (
"ashtottari", "tribhagi", "tribhagi_40", "shodashottari", "dwadashottari", "dwisaptatisama",
"shattrimshatsama", "panchottari", "satabdika", "chaturshitisama", "shastihayani",
)
UNCONDITIONAL = ("tribhagi", "tribhagi_40")
# The seven-planet sign lords the engine uses for these gates (jyotish_engine.SIGN_LORDS).
_SIGN_LORDS = ("Mars", "Venus", "Mercury", "Moon", "Sun", "Mercury", "Venus", "Mars",
"Jupiter", "Saturn", "Saturn", "Jupiter")
# Input fields each rule family returns.
_INPUT_FIELDS = {
"bphs_shodashottari_hora_paksha": ("hora_lord", "paksha"),
"bphs_dwadashottari_navamsa_lagna_venus_signs": ("navamsa_ascendant_sign_index",),
"bphs_dwisaptatisama_lagna_lord_in_first_or_seventh": ("ascendant_sign_index", "lagna_lord_sign_index", "lagna_lord_house"),
"bphs_shattrimshatsama_day_sun_hora_or_night_moon_hora": ("birth_is_daytime", "ascendant_hora_lord"),
"bphs_panchottari_cancer_rasi_and_d12": ("ascendant_rasi_sign_index", "ascendant_d12_sign_index"),
"bphs_satabdika_vargottama_lagna": ("ascendant_rasi_sign_index", "ascendant_navamsa_sign_index"),
"bphs_chaturshitisama_tenth_lord_in_tenth": ("ascendant_sign_index", "tenth_house_sign_index", "tenth_lord_sign_index"),
"bphs_shastihayani_sun_in_lagna": ("ascendant_sign_index", "sun_sign_index"),
}
_DEFAULT_RULE = {
"shodashottari": "bphs_shodashottari_hora_paksha",
"dwadashottari": "bphs_dwadashottari_navamsa_lagna_venus_signs",
"dwisaptatisama": "bphs_dwisaptatisama_lagna_lord_in_first_or_seventh",
"shattrimshatsama": "bphs_shattrimshatsama_day_sun_hora_or_night_moon_hora",
"panchottari": "bphs_panchottari_cancer_rasi_and_d12",
"satabdika": "bphs_satabdika_vargottama_lagna",
"chaturshitisama": "bphs_chaturshitisama_tenth_lord_in_tenth",
"shastihayani": "bphs_shastihayani_sun_in_lagna",
}
def _dict(value: Any) -> Dict[str, Any]:
return value if isinstance(value, dict) else {}
def _number(value: Any) -> Optional[float]:
if isinstance(value, bool) or not isinstance(value, (int, float)):
return None
return float(value)
def _longitudes(chart: Dict[str, Any]) -> Dict[str, float]:
"""Ascendant and planet longitudes from ``core_chart``; only real numbers are kept."""
out: Dict[str, float] = {}
ascendant = _dict(chart.get("ascendant"))
for key in ("lon", "degree_raw"):
value = _number(ascendant.get(key))
if value is not None:
out["Ascendant"] = value % 360.0
break
for name, row in _dict(chart.get("planets")).items():
row = _dict(row)
for key in ("lon", "degree_raw", "degree"):
value = _number(row.get(key))
if value is not None:
out[str(name)] = value % 360.0
break
return out
def _recompute(key: str, lons: Dict[str, float]) -> Optional[Dict[str, Any]]:
"""The module's own gate on the packet's D1 positions; None when an input is missing."""
asc = lons.get("Ascendant")
if asc is None:
return None
asc_sign = int(asc // 30) % 12
try:
if key == "shodashottari" and "Sun" in lons and "Moon" in lons:
return shodashottari_applicability(ascendant_longitude=asc, sun_longitude=lons["Sun"], moon_longitude=lons["Moon"])
if key == "panchottari":
return panchottari_applicability(ascendant_longitude=asc)
if key == "dwisaptatisama" and _SIGN_LORDS[asc_sign] in lons:
return dwisaptatisama_applicability(
ascendant_longitude=asc, lagna_lord_sign_index=int(lons[_SIGN_LORDS[asc_sign]] // 30) % 12)
if key == "chaturshitisama":
tenth_lord = _SIGN_LORDS[(asc_sign + 9) % 12]
if tenth_lord in lons:
return chaturshitisama_applicability(
ascendant_longitude=asc, tenth_lord_sign_index=int(lons[tenth_lord] // 30) % 12)
if key == "shastihayani" and "Sun" in lons:
return shastihayani_applicability(ascendant_longitude=asc, sun_longitude=lons["Sun"])
except (TypeError, ValueError):
return None
return None
def _has_periods(item: Dict[str, Any]) -> bool:
return any(isinstance(item.get(key), list) and item.get(key) for key in ("periods", "major"))
def _verdict(family: Dict[str, Any], reference: Dict[str, Any]) -> Optional[bool]:
if reference.get("classical_applicable") is False:
return False
status = str(family.get("execution_status") or family.get("status") or "")
if family.get("applicable") is True or status == "executed":
return True
if family.get("applicable") is False or status == "not_applicable":
return False
return None
def _ashtottari_row(family: Dict[str, Any], module: Dict[str, Any]) -> Dict[str, Any]:
gate_pack = _dict(family.get("applicability")) or _dict(module.get("applicability"))
gates = _dict(gate_pack.get("gates"))
source = family or module
status = str(source.get("execution_status") or source.get("status") or "")
verdict: Optional[bool]
if gate_pack.get("status") == "applicable" or source.get("applicable") is True or status == "executed":
verdict = True
elif gate_pack.get("status") == "not_applicable" or source.get("applicable") is False or status == "not_applicable":
verdict = False
else:
verdict = None
inputs: Dict[str, Any] = {}
decides = _dict(gates.get("rahu_from_lagna_lord"))
for field in ("position_from_lagna_lord", "rahu_in_lagna"):
if decides.get(field) is not None:
inputs[field] = decides[field]
recorded = _dict(gates.get("paksha_day_night"))
for field in ("birth_is_daytime", "is_shukla_paksha"):
if recorded.get(field) is not None:
inputs[field] = recorded[field]
if recorded.get("status") in ("pass", "fail"):
inputs["recorded_gate_met"] = recorded["status"] == "pass"
generated = _has_periods(family) or _has_periods(module)
return {
"key": "ashtottari",
"rule": str(gate_pack.get("rule_family") or source.get("applicability_rule_family") or "") or None,
"condition": verdict,
"inputs": inputs,
"inputs_source": "engine" if inputs else None,
"table": _table_state(verdict, generated, family or module),
}
def _table_state(verdict: Optional[bool], generated: bool, known: Any) -> Optional[str]:
if generated:
return "condition_met" if verdict is True else "reference_only" if verdict is False else "generated"
if not known:
return None
return "none"
def applicability_rows(families: Any, reference: Any, chart: Any, ashtottari_module: Any = None) -> List[Dict[str, Any]]:
"""One row per conditional dasha family.
``families``: ``dasha_master_pack.families``; ``reference``:
``conditional_dasha_reference``; ``chart``: ``core_chart``;
``ashtottari_module``: the ``ashtottari_dasha`` module (fallback).
"""
families, reference, chart = _dict(families), _dict(reference), _dict(chart)
lons = _longitudes(chart)
rows: List[Dict[str, Any]] = []
for key in FAMILY_ORDER:
family = _dict(families.get(key))
if key == "ashtottari":
rows.append(_ashtottari_row(family, _dict(ashtottari_module)))
continue
ref = _dict(reference.get(f"{key}_dasha"))
if ref.get("error"):
ref = {}
verdict = _verdict(family, ref)
generated = _has_periods(family) or _has_periods(ref)
if key in UNCONDITIONAL:
rows.append({"key": key, "rule": "unconditional", "condition": None, "inputs": {},
"inputs_source": None, "table": "generated" if generated else ("none" if family else None)})
continue
rule = str(ref.get("rule_family") or family.get("rule_family") or "") or None
inputs: Dict[str, Any] = {}
source = None
carrier = ref if ref.get("rule_family") else family if family.get("rule_family") else {}
if carrier:
for field in _INPUT_FIELDS.get(str(carrier.get("rule_family")), ()):
if carrier.get(field) is not None:
inputs[field] = carrier[field]
source = "engine" if inputs else None
if not inputs and verdict is not None:
again = _recompute(key, lons)
if again and bool(again.get("applicable")) == verdict and (rule is None or again.get("rule_family") == rule):
rule = rule or again.get("rule_family")
inputs = {field: again[field] for field in _INPUT_FIELDS.get(str(again.get("rule_family")), ())
if again.get(field) is not None}
source = "recomputed" if inputs else None
rows.append({
"key": key,
"rule": rule or _DEFAULT_RULE.get(key),
"condition": verdict,
"inputs": inputs,
"inputs_source": source,
"table": _table_state(verdict, generated, family or ref),
})
return rows