kundali-chart-mcp 0.2.1

package/python/kundali_lib/vedic/shadbala.py

@@ -0,0 +1,500 @@
+"""Shadbala: six-fold planetary strength calculation."""
+
+import math
+
+# ---------------------------------------------------------------------------
+# Constant tables
+# ---------------------------------------------------------------------------
+
+PLANETS = ["Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn"]
+
+# Absolute sidereal longitudes for exaltation / debilitation
+EXALTATION_DEG = {
+    "Sun": 10,
+    "Moon": 33,
+    "Mars": 298,
+    "Mercury": 165,
+    "Jupiter": 95,
+    "Venus": 357,
+    "Saturn": 200,
+}
+DEBILITATION_DEG = {
+    "Sun": 190,
+    "Moon": 213,
+    "Mars": 118,
+    "Mercury": 345,
+    "Jupiter": 275,
+    "Venus": 177,
+    "Saturn": 20,
+}
+
+OWN_SIGNS = {
+    "Sun": ["Leo"],
+    "Moon": ["Cancer"],
+    "Mars": ["Aries", "Scorpio"],
+    "Mercury": ["Gemini", "Virgo"],
+    "Jupiter": ["Sagittarius", "Pisces"],
+    "Venus": ["Taurus", "Libra"],
+    "Saturn": ["Capricorn", "Aquarius"],
+}
+
+MOOLATRIKONA = {
+    "Sun": "Leo",
+    "Moon": "Taurus",
+    "Mars": "Aries",
+    "Mercury": "Virgo",
+    "Jupiter": "Sagittarius",
+    "Venus": "Libra",
+    "Saturn": "Aquarius",
+}
+
+# Rashi index → name
+RASHIS = [
+    "Aries",
+    "Taurus",
+    "Gemini",
+    "Cancer",
+    "Leo",
+    "Virgo",
+    "Libra",
+    "Scorpio",
+    "Sagittarius",
+    "Capricorn",
+    "Aquarius",
+    "Pisces",
+]
+
+# Navamsha sign lookup: given absolute longitude, return D9 rashi name
+# Each rashi (30°) is divided into 9 navamshas of 3°20' each.
+# The 108 navamshas cycle through the 12 rashis starting from Aries for
+# fire signs, Cancer for earth, Libra for air, Capricorn for water.
+_NAVAMSHA_START = {
+    0: 0,
+    1: 9,
+    2: 6,
+    3: 3,
+    4: 0,
+    5: 9,
+    6: 6,
+    7: 3,
+    8: 0,
+    9: 9,
+    10: 6,
+    11: 3,
+}
+
+
+def _navamsha_rashi(lon: float) -> str:
+    """Return navamsha (D9) sign for a given sidereal longitude."""
+    lon = lon % 360
+    rashi_idx = int(lon / 30)
+    degree_in_sign = lon - rashi_idx * 30
+    navamsha_num = int(degree_in_sign / (10 / 3))  # 0-8
+    navamsha_num = min(navamsha_num, 8)
+    start = _NAVAMSHA_START[rashi_idx]
+    d9_rashi_idx = (start + navamsha_num) % 12
+    return RASHIS[d9_rashi_idx]
+
+
+# Planetary relationships (for saptavargaja — simplified to friend/enemy/neutral)
+FRIENDS = {
+    "Sun": ["Moon", "Mars", "Jupiter"],
+    "Moon": ["Sun", "Mercury"],
+    "Mars": ["Sun", "Moon", "Jupiter"],
+    "Mercury": ["Sun", "Venus"],
+    "Jupiter": ["Sun", "Moon", "Mars"],
+    "Venus": ["Mercury", "Saturn"],
+    "Saturn": ["Mercury", "Venus"],
+}
+ENEMIES = {
+    "Sun": ["Venus", "Saturn"],
+    "Moon": ["None"],
+    "Mars": ["Mercury"],
+    "Mercury": ["Moon"],
+    "Jupiter": ["Mercury", "Venus"],
+    "Venus": ["Sun", "Moon"],
+    "Saturn": ["Sun", "Moon", "Mars"],
+}
+
+# Sign rulerships (lord → sign index list)
+_SIGN_LORDS = {
+    "Aries": "Mars",
+    "Taurus": "Venus",
+    "Gemini": "Mercury",
+    "Cancer": "Moon",
+    "Leo": "Sun",
+    "Virgo": "Mercury",
+    "Libra": "Venus",
+    "Scorpio": "Mars",
+    "Sagittarius": "Jupiter",
+    "Capricorn": "Saturn",
+    "Aquarius": "Saturn",
+    "Pisces": "Jupiter",
+}
+
+# Exaltation sign names
+_EXALT_SIGN = {p: RASHIS[int(EXALTATION_DEG[p] / 30)] for p in PLANETS}
+
+# Best house for Dig Bala
+DIG_BALA_BEST_HOUSE = {
+    "Sun": 10,
+    "Moon": 4,
+    "Mars": 10,
+    "Mercury": 1,
+    "Jupiter": 1,
+    "Venus": 4,
+    "Saturn": 7,
+}
+
+# Natural (Naisargika) Bala in Shashtiamsas
+NAISARGIKA_BALA = {
+    "Sun": 60.0,
+    "Moon": 51.43,
+    "Mars": 17.14,
+    "Mercury": 25.71,
+    "Jupiter": 34.29,
+    "Venus": 42.86,
+    "Saturn": 8.57,
+}
+
+# Mean daily motion in degrees
+MEAN_MOTION = {
+    "Sun": 1.0,
+    "Moon": 13.0,
+    "Mars": 0.524,
+    "Mercury": 1.383,
+    "Jupiter": 0.083,
+    "Venus": 1.2,
+    "Saturn": 0.033,
+}
+
+# Required Rupas (minimum for "Strong" classification)
+REQUIRED_RUPAS = {
+    "Sun": 6.5,
+    "Moon": 6.0,
+    "Mars": 5.0,
+    "Mercury": 7.0,
+    "Jupiter": 6.5,
+    "Venus": 5.5,
+    "Saturn": 5.0,
+}
+
+# Natural benefics / malefics
+NATURAL_BENEFICS = {"Moon", "Mercury", "Jupiter", "Venus"}
+NATURAL_MALEFICS = {"Sun", "Mars", "Saturn", "Rahu", "Ketu"}
+
+# ---------------------------------------------------------------------------
+# Sthana Bala components
+# ---------------------------------------------------------------------------
+
+
+def _uchcha_bala(planet: str, lon: float) -> float:
+    """Exaltation strength (0-60 Shashtiamsas)."""
+    debil = DEBILITATION_DEG[planet]
+    diff = abs(lon - debil) % 360
+    if diff > 180:
+        diff = 360 - diff
+    return min(60.0, diff / 3.0)
+
+
+def _saptavargaja_bala(planet: str, lon: float) -> float:
+    """
+    Simplified Saptavargaja Bala using D1 and D9 only.
+    Returns combined score (max ~40 per chart = 80 total).
+    """
+    total = 0.0
+    for rashi in [RASHIS[int(lon / 30) % 12], _navamsha_rashi(lon)]:
+        lord = _SIGN_LORDS.get(rashi, "")
+        exalt_sign = _EXALT_SIGN.get(planet, "")
+        if rashi == exalt_sign:
+            total += 20.0
+        elif rashi in OWN_SIGNS.get(planet, []):
+            total += 15.0
+        elif rashi == MOOLATRIKONA.get(planet, ""):
+            total += 15.0
+        elif lord in FRIENDS.get(planet, []):
+            total += 10.0
+        elif lord in ENEMIES.get(planet, []):
+            total += 3.75
+        else:
+            total += 7.5
+    return total
+
+
+def _ojhayugma_bala(planet: str, lon: float) -> float:
+    """Odd/Even sign strength (0 or 15 Shashtiamsas)."""
+    rashi_idx = int(lon / 30) % 12
+    is_odd = rashi_idx % 2 == 0  # Aries=0 is odd, Taurus=1 is even, etc.
+    male_planets = {"Sun", "Mars", "Jupiter"}
+    female_planets = {"Moon", "Venus"}
+    if planet in male_planets and is_odd:
+        return 15.0
+    if planet in female_planets and not is_odd:
+        return 15.0
+    if planet == "Saturn":
+        return 15.0  # simplified
+    return 0.0
+
+
+def _kendradi_bala(house: int) -> float:
+    """Angular/succedent/cadent house strength."""
+    if house in (1, 4, 7, 10):
+        return 60.0
+    if house in (2, 5, 8, 11):
+        return 30.0
+    return 15.0
+
+
+def _drekkana_bala(planet: str, lon: float) -> float:
+    """Decanate (drekkana) strength (0 or 15 Shashtiamsas)."""
+    degree_in_sign = lon % 30
+    male_planets = {"Sun", "Mars", "Jupiter"}
+    female_planets = {"Moon", "Venus"}
+    if planet in male_planets and degree_in_sign < 10:
+        return 15.0
+    if planet in female_planets and degree_in_sign >= 20:
+        return 15.0
+    if planet == "Mercury" and 10 <= degree_in_sign < 20:
+        return 15.0
+    return 0.0
+
+
+def _sthana_bala(planet: str, lon: float, house: int) -> float:
+    """Total positional strength."""
+    return (
+        _uchcha_bala(planet, lon)
+        + _saptavargaja_bala(planet, lon)
+        + _ojhayugma_bala(planet, lon)
+        + _kendradi_bala(house)
+        + _drekkana_bala(planet, lon)
+    )
+
+
+# ---------------------------------------------------------------------------
+# Dig Bala
+# ---------------------------------------------------------------------------
+
+
+def _dig_bala(planet: str, house: int) -> float:
+    """Directional strength (0-60 Shashtiamsas)."""
+    best = DIG_BALA_BEST_HOUSE[planet]
+    # Minimum circular distance in houses (1-12 circle)
+    dist = abs(house - best)
+    dist = min(dist, 12 - dist)
+    # Convert house distance to degrees (1 house = 30°), normalize to 0-60
+    angular_dist_deg = dist * 30  # 0-180
+    return max(0.0, 60.0 - (angular_dist_deg * 60.0 / 180.0))
+
+
+# ---------------------------------------------------------------------------
+# Kala Bala (temporal strength)
+# ---------------------------------------------------------------------------
+
+
+def _nathonnatha_bala(planet: str, jd: float) -> float:
+    """Day/night strength based on Julian Day fraction."""
+    # JD fraction: 0.5 = noon UT; <0.5 or >0.5 used to approximate day/night.
+    # Simplified: treat JD fraction 0.25–0.75 as daytime.
+    frac = jd % 1.0
+    is_daytime = 0.25 <= frac < 0.75
+    diurnal = {"Sun", "Venus", "Jupiter"}
+    nocturnal = {"Moon", "Mars", "Saturn"}
+    if planet == "Mercury":
+        return 30.0
+    if planet in diurnal:
+        return 30.0 if is_daytime else 0.0
+    if planet in nocturnal:
+        return 30.0 if not is_daytime else 0.0
+    return 15.0
+
+
+def _paksha_bala(planet: str, sun_lon: float, moon_lon: float) -> float:
+    """Lunar phase (Paksha) strength."""
+    diff = (moon_lon - sun_lon) % 360
+    benefics = {"Moon", "Mercury", "Jupiter", "Venus"}
+    if planet in benefics:
+        return min(60.0, diff / 6.0)
+    else:
+        return min(60.0, (360.0 - diff) / 6.0)
+
+
+def _kala_bala(planet: str, jd: float, sun_lon: float, moon_lon: float) -> float:
+    """Combined temporal strength (Nathonnatha + Paksha)."""
+    return _nathonnatha_bala(planet, jd) + _paksha_bala(planet, sun_lon, moon_lon)
+
+
+# ---------------------------------------------------------------------------
+# Chesta Bala (motional strength)
+# ---------------------------------------------------------------------------
+
+
+def _chesta_bala(planet: str, speed: float) -> float:
+    """Motional strength based on longitudinal speed."""
+    if planet == "Moon":
+        # Moon chesta bala = similar to paksha bala for simplicity; return 30
+        return 30.0
+    mean = MEAN_MOTION.get(planet, 1.0)
+    if speed < 0:  # retrograde
+        return 60.0
+    if speed == 0:
+        return 60.0
+    if speed <= mean:
+        # Slower than mean → stronger (approaching retrogression)
+        ratio = speed / mean
+        return max(0.0, 60.0 * (1.0 - ratio * 0.5))
+    else:
+        # Faster than mean
+        return 45.0
+
+
+# ---------------------------------------------------------------------------
+# Drik Bala (aspectual strength)
+# ---------------------------------------------------------------------------
+
+
+def _drik_bala(planet: str, all_positions: list) -> float:
+    """
+    Simplified aspectual strength.
+    Full aspect = planets in 7th house from each other (opposition).
+    Conjunction = same house.
+    Each benefic aspect: +15, each malefic aspect: -15. Cap at ±60.
+    """
+    target = next((p for p in all_positions if p["name"] == planet), None)
+    if target is None:
+        return 0.0
+
+    target_house = target["house"]
+    score = 0.0
+
+    for p in all_positions:
+        if p["name"] == planet:
+            continue
+        p_name = p["name"]
+        p_house = p["house"]
+
+        # Check if p aspects target: conjunction or 7th house opposition
+        diff = abs(p_house - target_house)
+        is_aspecting = (diff == 0) or (diff == 6)
+
+        if is_aspecting:
+            if p_name in NATURAL_BENEFICS:
+                score += 15.0
+            elif p_name in NATURAL_MALEFICS:
+                score -= 15.0
+
+    return max(-60.0, min(60.0, score))
+
+
+# ---------------------------------------------------------------------------
+# Ishta / Kashta Phala
+# ---------------------------------------------------------------------------
+
+
+def _ishta_kashta(chesta: float, uchcha: float) -> tuple:
+    """
+    Ishta Phala (benefic strength) and Kashta Phala (malefic strength).
+    Ishta = sqrt(uchcha_bala * chesta_bala)
+    Kashta = sqrt((60 - uchcha_bala) * (60 - chesta_bala))
+    """
+    uchcha_norm = min(60.0, max(0.0, uchcha))
+    chesta_norm = min(60.0, max(0.0, chesta))
+    ishta = math.sqrt(uchcha_norm * chesta_norm)
+    kashta = math.sqrt((60.0 - uchcha_norm) * (60.0 - chesta_norm))
+    return round(ishta, 2), round(kashta, 2)
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+
+def get_shadbala(base_chart: dict) -> dict:
+    """
+    Calculate Shadbala (six-fold planetary strength) for all seven classical planets.
+
+    Parameters
+    ----------
+    base_chart : dict
+        Output of ``build_chart()``.  Must contain:
+        - ``planetary_positions``: list of planet dicts (see module docstring).
+        - ``julian_day``: float  (JD at birth moment).
+
+    Returns
+    -------
+    dict
+        ``planets`` mapping each planet name to its strength breakdown,
+        plus a ``summary`` string.
+    """
+    positions: list = base_chart.get("planetary_positions", [])
+    jd: float = base_chart.get("julian_day", 0.0)
+
+    # Build quick lookup
+    pos_map = {p["name"]: p for p in positions}
+
+    sun_lon = pos_map.get("Sun", {}).get("longitude", 0.0)
+    moon_lon = pos_map.get("Moon", {}).get("longitude", 0.0)
+
+    results = {}
+
+    for planet in PLANETS:
+        p = pos_map.get(planet)
+        if p is None:
+            continue
+
+        lon = p["longitude"]
+        house = p["house"]
+        speed = p.get("speed_longitude", 0.0)
+        is_retro = p.get("is_retrograde", False)
+        if is_retro:
+            speed = -abs(speed)
+
+        # --- Six strengths ---
+        sthana = _sthana_bala(planet, lon, house)
+        dig = _dig_bala(planet, house)
+        kala = _kala_bala(planet, jd, sun_lon, moon_lon)
+        chesta = _chesta_bala(planet, speed)
+        naisargika = NAISARGIKA_BALA[planet]
+        drik = _drik_bala(planet, positions)
+
+        total = sthana + dig + kala + chesta + naisargika + drik
+        total_rupas = round(total / 60.0, 3)
+        required = REQUIRED_RUPAS[planet]
+
+        uchcha = _uchcha_bala(planet, lon)
+        ishta, kashta = _ishta_kashta(chesta, uchcha)
+
+        if total_rupas >= required * 1.2:
+            grade = "Strong"
+        elif total_rupas >= required * 0.8:
+            grade = "Average"
+        else:
+            grade = "Weak"
+
+        results[planet] = {
+            "sthana_bala": round(sthana, 2),
+            "dig_bala": round(dig, 2),
+            "kala_bala": round(kala, 2),
+            "chesta_bala": round(chesta, 2),
+            "naisargika_bala": round(naisargika, 2),
+            "drik_bala": round(drik, 2),
+            "total_shadbala": round(total, 2),
+            "total_rupas": total_rupas,
+            "required_rupas": required,
+            "ishta_phala": ishta,
+            "kashta_phala": kashta,
+            "strength_grade": grade,
+        }
+
+    # Build summary
+    strong = [p for p, v in results.items() if v["strength_grade"] == "Strong"]
+    weak = [p for p, v in results.items() if v["strength_grade"] == "Weak"]
+    summary_parts = []
+    if strong:
+        summary_parts.append(f"Strong planets: {', '.join(strong)}.")
+    if weak:
+        summary_parts.append(f"Weak planets: {', '.join(weak)}.")
+    if not summary_parts:
+        summary_parts.append("All planets are of average strength.")
+    summary = " ".join(summary_parts)
+
+    return {"planets": results, "summary": summary}