Files
Jyotisha/scripts/report_render/equatorial_declination.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

147 lines
6.2 KiB
Python

"""Equatorial declination of the natal planets (BUG-2088, astrologer reply B2).
The report used to print ``shadbala.kala_bala.declination`` under the heading
"Declination". That number is the intermediate angle of the Ayana-bala table
(BPHS seven-point interpolation), not a coordinate. This module gives the real
one: the declination of each body in the equator of date, read straight from
the Swiss Ephemeris with ``FLG_EQUATORIAL``.
* unit: degrees, north positive, south negative;
* frame: equator and equinox of date, geocentric; ``apparent`` keeps nutation,
``mean`` drops it (the same two frames the natal longitudes use);
* declination does not depend on the ayanamsa;
* Rahu follows the chart's node mode; Ketu is the opposite point, so its
declination is Rahu's with the sign reversed.
The upstream skill's ``kranti_producer`` also keeps "declination minus ecliptic
latitude" as an observation-only candidate. That value is returned here as
``ecliptic_point_declination`` for comparison and is not printed.
Nothing is rounded for display here and nothing is guessed: a missing Julian
day or a failed ephemeris call returns ``status: unavailable`` with no rows.
"""
from __future__ import annotations
import logging
from typing import Any, Dict, Optional
logger = logging.getLogger(__name__)
try:
import swisseph as swe
except ImportError: # pragma: no cover - environments without the ephemeris
swe = None
try:
from ayanamsa_utils import configure_ephemeris_path
except ImportError: # pragma: no cover - package import
from scripts.ayanamsa_utils import configure_ephemeris_path
SCHEMA = "jyotish.equatorial_declination.v1"
PLANETS = ("Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn", "Rahu", "Ketu")
POSITION_MODES = ("apparent", "mean")
def _unavailable(reason: str) -> Dict[str, Any]:
return {"schema": SCHEMA, "status": "unavailable", "reason": reason, "planets": {}}
def planet_declinations(jd_ut: Any, *, node_mode: Any = "mean", position_mode: Any = "apparent") -> Dict[str, Any]:
"""Declination (degrees, north positive) of the nine grahas at ``jd_ut``.
Returns ``{"status": "computed", "planets": {name: {"declination": float,
"ecliptic_latitude": float, "ecliptic_point_declination": float}}, ...}``.
"""
if swe is None:
return _unavailable("ephemeris_unavailable")
if isinstance(jd_ut, bool) or not isinstance(jd_ut, (int, float)):
return _unavailable("julian_day_missing")
jd = float(jd_ut)
node = "true" if str(node_mode or "mean").lower() == "true" else "mean"
mode = str(position_mode or "apparent").lower()
mode = "mean" if mode == "mean" else "apparent" # ``legacy`` is the apparent frame (BUG-1275)
ids = {
"Sun": swe.SUN, "Moon": swe.MOON, "Mars": swe.MARS, "Mercury": swe.MERCURY,
"Jupiter": swe.JUPITER, "Venus": swe.VENUS, "Saturn": swe.SATURN,
"Rahu": swe.TRUE_NODE if node == "true" else swe.MEAN_NODE,
}
configure_ephemeris_path(swe)
flags = swe.FLG_SWIEPH | (swe.FLG_NONUT if mode == "mean" else 0)
rows: Dict[str, Dict[str, float]] = {}
for name, body in ids.items():
try:
equatorial, equatorial_flag = swe.calc_ut(jd, body, flags | swe.FLG_EQUATORIAL)
ecliptic, ecliptic_flag = swe.calc_ut(jd, body, flags)
except swe.Error as exc: # a date outside the ephemeris range
logger.warning("declination of %s unavailable: %s", name, exc)
continue
if equatorial_flag < 0 or ecliptic_flag < 0:
continue
declination = float(equatorial[1])
latitude = float(ecliptic[1])
rows[name] = {
"declination": declination,
"ecliptic_latitude": latitude,
"ecliptic_point_declination": declination - latitude,
}
if "Rahu" in rows:
rahu = rows["Rahu"]
rows["Ketu"] = {key: -value for key, value in rahu.items()}
if not rows:
return _unavailable("ephemeris_call_failed")
return {
"schema": SCHEMA,
"status": "computed",
"unit": "degrees_north_positive",
"frame": "equator_of_date_geocentric",
"position_mode": mode,
"node_mode": node,
"julian_day_ut": jd,
"source": "Swiss Ephemeris calc_ut with FLG_EQUATORIAL",
"planets": rows,
}
def _dict(value: Any) -> Dict[str, Any]:
return value if isinstance(value, dict) else {}
def birth_julian_day(packet: Any) -> Optional[float]:
"""The birth Julian day (UT) the report packet already carries, or None."""
packet = _dict(packet)
for birth in (
_dict(_dict(_dict(packet.get("core_chart")).get("chart")).get("birth_info")),
_dict(packet.get("birth_info")),
):
value = birth.get("julian_day")
if isinstance(value, (int, float)) and not isinstance(value, bool):
return float(value)
return None
def declinations_for_packet(packet: Any) -> Dict[str, Any]:
"""Declinations for a report packet, from the Julian day it carries.
Reads ``core_chart.chart.birth_info.julian_day`` (falls back to
``birth_info.julian_day``), the node mode from ``birth_info`` and the
position mode from ``calculation_profile``. No planet longitude is
recomputed; only the equatorial coordinate is asked of the ephemeris.
"""
packet = _dict(packet)
jd = birth_julian_day(packet)
if jd is None:
return _unavailable("julian_day_missing")
birth = _dict(packet.get("birth_info")) or _dict(_dict(_dict(packet.get("core_chart")).get("chart")).get("birth_info"))
profile = _dict(packet.get("calculation_profile"))
settings = _dict(profile.get("effective_settings"))
node_mode = birth.get("node_mode") or settings.get("node_mode") or profile.get("node_mode") or "mean"
position_mode = settings.get("position_mode") or profile.get("position_mode") or "apparent"
return planet_declinations(jd, node_mode=node_mode, position_mode=position_mode)
def declination_degrees(packet: Any) -> Dict[str, float]:
"""``{planet: declination}`` for a packet; empty when it cannot be computed."""
found = declinations_for_packet(packet)
return {name: row["declination"] for name, row in _dict(found.get("planets")).items()}