kundali-chart-mcp 0.2.1

package/azure-function/python/kundali_lib/vedic/avasthas.py

@@ -0,0 +1,292 @@
+"""Planetary Avasthas: 9 states of planets in a birth chart."""
+
+# ---------------------------------------------------------------------------
+# Avastha reference data
+# ---------------------------------------------------------------------------
+
+AVASTHAS = {
+    "Deepta": {
+        "condition": "Exaltation sign",
+        "strength": 1.0,
+        "nature": "Highly auspicious",
+    },
+    "Swastha": {
+        "condition": "Own sign (including Moolatrikona)",
+        "strength": 0.875,
+        "nature": "Auspicious",
+    },
+    "Mudita": {"condition": "Friend's sign", "strength": 0.75, "nature": "Pleasing"},
+    "Santha": {"condition": "Neutral sign", "strength": 0.5, "nature": "Neutral"},
+    "Dina": {"condition": "Enemy's sign", "strength": 0.375, "nature": "Distressed"},
+    "Dukhita": {
+        "condition": "Combust (within combustion threshold of Sun)",
+        "strength": 0.25,
+        "nature": "Pained",
+    },
+    "Vikala": {
+        "condition": "Defeated in Graha Yuddha (within 1° of another planet)",
+        "strength": 0.125,
+        "nature": "Crippled",
+    },
+    "Khala": {
+        "condition": "Debilitation sign",
+        "strength": 0.0,
+        "nature": "Wicked/Weak",
+    },
+    "Bhadra": {
+        "condition": "Retrograde in exaltation or own sign",
+        "strength": 1.0,
+        "nature": "Fortunate (exception)",
+    },
+}
+
+EXALTATION_SIGNS = {
+    "Sun": "Aries",
+    "Moon": "Taurus",
+    "Mars": "Capricorn",
+    "Mercury": "Virgo",
+    "Jupiter": "Cancer",
+    "Venus": "Pisces",
+    "Saturn": "Libra",
+}
+
+DEBILITATION_SIGNS = {
+    "Sun": "Libra",
+    "Moon": "Scorpio",
+    "Mars": "Cancer",
+    "Mercury": "Pisces",
+    "Jupiter": "Capricorn",
+    "Venus": "Virgo",
+    "Saturn": "Aries",
+}
+
+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",
+}
+
+# Degrees within which a planet is considered combust by the Sun
+COMBUSTION_DEG = {
+    "Moon": 12,
+    "Mars": 17,
+    "Mercury": 14,
+    "Jupiter": 11,
+    "Venus": 10,
+    "Saturn": 15,
+}
+
+PLANET_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"],
+}
+
+PLANET_ENEMIES = {
+    "Sun": ["Venus", "Saturn"],
+    "Moon": [],
+    "Mars": ["Mercury"],
+    "Mercury": ["Moon"],
+    "Jupiter": ["Mercury", "Venus"],
+    "Venus": ["Sun", "Moon"],
+    "Saturn": ["Sun", "Moon", "Mars"],
+}
+
+# Planets for which we compute Avasthas (the 7 classical planets)
+_CLASSICAL_PLANETS = ["Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn"]
+
+# ---------------------------------------------------------------------------
+# Baladi Avastha (age-based state by degree within sign)
+# ---------------------------------------------------------------------------
+
+_BALADI_THRESHOLDS = [
+    (6, "Bala", 0.25),  # Infant  0–6°
+    (12, "Kumara", 0.50),  # Young   6–12°
+    (18, "Yuva", 1.00),  # Youth   12–18°  (peak)
+    (24, "Vriddha", 0.50),  # Old     18–24°
+    (30, "Mrita", 0.25),  # Dead    24–30°
+]
+
+
+def _get_baladi(degree_in_sign: float) -> tuple:
+    """Return (baladi_name, baladi_strength) for a degree within a sign (0–30)."""
+    for upper, name, strength in _BALADI_THRESHOLDS:
+        if degree_in_sign < upper:
+            return name, strength
+    return "Mrita", 0.25  # fallback for exactly 30°
+
+
+def _angular_diff(lon1: float, lon2: float) -> float:
+    """Shortest angular distance between two longitudes (0–180)."""
+    diff = abs(lon1 - lon2) % 360
+    return diff if diff <= 180 else 360 - diff
+
+
+# ---------------------------------------------------------------------------
+# Main function
+# ---------------------------------------------------------------------------
+
+
+def get_avasthas(planetary_positions: list, ascendant: dict) -> list:
+    """Compute the Avastha (planetary state) for each classical planet.
+
+    Parameters
+    ----------
+    planetary_positions : list
+        Each item is a dict with at least:
+        ``name``, ``longitude``, ``rashi``, ``degree`` (= degree within sign),
+        ``house``, ``is_retrograde``.
+    ascendant : dict
+        Must contain at least ``longitude`` and ``rashi``.
+
+    Returns
+    -------
+    list of dict
+        One entry per classical planet (Sun–Saturn) found in
+        *planetary_positions*, each with keys:
+        planet, rashi, house, avastha, strength_ratio, nature,
+        condition_met, is_retrograde, baladi_avastha, baladi_strength.
+    """
+    # Build quick lookup by name
+    planet_map = {p["name"]: p for p in planetary_positions}
+
+    sun = planet_map.get("Sun")
+    sun_lon = sun["longitude"] if sun else None
+
+    results = []
+
+    for name in _CLASSICAL_PLANETS:
+        p = planet_map.get(name)
+        if p is None:
+            continue
+
+        rashi = p["rashi"]
+        lon = p["longitude"]
+        house = p["house"]
+        is_retro = p.get("is_retrograde", False)
+        # degree_in_sign: prefer "degree" key, else compute from longitude
+        deg_in_sign = p.get("degree", lon % 30)
+
+        # ------------------------------------------------------------------
+        # Determine Avastha (priority order)
+        # ------------------------------------------------------------------
+        avastha = None
+        condition_met = ""
+
+        # 1. Bhadra: retrograde AND (exaltation OR own sign)
+        if is_retro and (
+            EXALTATION_SIGNS.get(name) == rashi
+            or rashi in OWN_SIGNS.get(name, [])
+            or MOOLATRIKONA.get(name) == rashi
+        ):
+            avastha = "Bhadra"
+            condition_met = "Retrograde in exaltation/own sign"
+
+        # 2. Deepta: exaltation sign
+        elif EXALTATION_SIGNS.get(name) == rashi:
+            avastha = "Deepta"
+            condition_met = f"Exalted in {rashi}"
+
+        # 3. Khala: debilitation sign
+        elif DEBILITATION_SIGNS.get(name) == rashi:
+            avastha = "Khala"
+            condition_met = f"Debilitated in {rashi}"
+
+        # 4. Dukhita: combust (only applicable to non-Sun planets)
+        elif name != "Sun" and sun_lon is not None and name in COMBUSTION_DEG:
+            diff = _angular_diff(lon, sun_lon)
+            if diff <= COMBUSTION_DEG[name]:
+                avastha = "Dukhita"
+                condition_met = (
+                    f"Combust — {diff:.1f}° from Sun "
+                    f"(threshold {COMBUSTION_DEG[name]}°)"
+                )
+
+        # 5. Vikala: within 1° of any other planet (exclude Sun/Moon from trigger)
+        if avastha is None:
+            for other_name in _CLASSICAL_PLANETS:
+                if other_name == name or other_name in ("Sun", "Moon"):
+                    continue
+                other = planet_map.get(other_name)
+                if other is None:
+                    continue
+                diff = _angular_diff(lon, other["longitude"])
+                if diff <= 1.0:
+                    avastha = "Vikala"
+                    condition_met = f"Within 1° of {other_name} ({diff:.2f}°)"
+                    break
+
+        if avastha is None:
+            # 6. Swastha: own sign or moolatrikona
+            if rashi in OWN_SIGNS.get(name, []) or MOOLATRIKONA.get(name) == rashi:
+                avastha = "Swastha"
+                condition_met = (
+                    "Moolatrikona sign"
+                    if MOOLATRIKONA.get(name) == rashi
+                    else "Own sign"
+                )
+
+            # 7. Mudita: friend's sign
+            elif rashi in [
+                EXALTATION_SIGNS.get(f, "") or "" for f in PLANET_FRIENDS.get(name, [])
+            ] or any(
+                rashi in OWN_SIGNS.get(friend, [])
+                for friend in PLANET_FRIENDS.get(name, [])
+            ):
+                avastha = "Mudita"
+                condition_met = "Placed in a friend's sign"
+
+            # 8. Dina: enemy's sign
+            elif any(
+                rashi in OWN_SIGNS.get(enemy, [])
+                for enemy in PLANET_ENEMIES.get(name, [])
+            ):
+                avastha = "Dina"
+                condition_met = "Placed in an enemy's sign"
+
+            # 9. Santha: neutral (default)
+            else:
+                avastha = "Santha"
+                condition_met = "Neutral sign"
+
+        meta = AVASTHAS[avastha]
+
+        # ------------------------------------------------------------------
+        # Baladi Avastha
+        # ------------------------------------------------------------------
+        baladi_name, baladi_strength = _get_baladi(deg_in_sign)
+
+        results.append(
+            {
+                "planet": name,
+                "rashi": rashi,
+                "house": house,
+                "avastha": avastha,
+                "strength_ratio": meta["strength"],
+                "nature": meta["nature"],
+                "condition_met": condition_met,
+                "is_retrograde": is_retro,
+                "baladi_avastha": baladi_name,
+                "baladi_strength": baladi_strength,
+            }
+        )
+
+    return results

package/azure-function/python/kundali_lib/vedic/ayanamsa.py

@@ -0,0 +1,106 @@
+"""Ayanamsa modes and house systems from Swiss Ephemeris."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import swisseph as swe
+
+# Expose all predefined sidereal modes (ayanamsas) from Swiss Ephemeris.
+AYANAMSA_MODES: dict[str, dict[str, Any]] = {}
+
+# Map readable names to swisseph constants.
+_SIDM_MAP = {
+    "lahiri": swe.SIDM_LAHIRI,
+    "raman": swe.SIDM_RAMAN,
+    "krishnamurti": swe.SIDM_KRISHNAMURTI,
+    "yukteshwar": swe.SIDM_YUKTESHWAR,
+    "fagan_bradley": swe.SIDM_FAGAN_BRADLEY,
+    "galactic_0sag": swe.SIDM_GALCENT_0SAG,
+    "galactic_mula": swe.SIDM_GALEQU_MULA,
+    "true_chitra": swe.SIDM_TRUE_CITRA,
+    "true_revati": swe.SIDM_TRUE_REVATI,
+    "true_pushya": swe.SIDM_TRUE_PUSHYA,
+    "b1950": swe.SIDM_B1950,
+    "j1900": swe.SIDM_J1900,
+    "j2000": swe.SIDM_J2000,
+    "aryabhata": swe.SIDM_ARYABHATA,
+    "aryabhata_522": swe.SIDM_ARYABHATA_522,
+    "suryasiddhanta": swe.SIDM_SURYASIDDHANTA,
+    "suryasiddhanta_msun": swe.SIDM_SURYASIDDHANTA_MSUN,
+    "galactic_iau1958": swe.SIDM_GALEQU_IAU1958,
+    "galactic_true": swe.SIDM_GALEQU_TRUE,
+    "galactic_fiorenza": swe.SIDM_GALEQU_FIORENZA,
+    "deluce": swe.SIDM_DELUCE,
+    "djwhal_khul": swe.SIDM_DJWHAL_KHUL,
+    "babyl_kugler1": swe.SIDM_BABYL_KUGLER1,
+    "babyl_kugler2": swe.SIDM_BABYL_KUGLER2,
+    "babyl_kugler3": swe.SIDM_BABYL_KUGLER3,
+    "babyl_huber": swe.SIDM_BABYL_HUBER,
+    "babyl_etpsc": swe.SIDM_BABYL_ETPSC,
+    "babyl_britton": swe.SIDM_BABYL_BRITTON,
+    "aldebaran_15tau": swe.SIDM_ALDEBARAN_15TAU,
+    "ss_citra": swe.SIDM_SS_CITRA,
+    "ss_revati": swe.SIDM_SS_REVATI,
+    "valems_moon": swe.SIDM_VALENS_MOON,
+    "hipparchos": swe.SIDM_HIPPARCHOS,
+    "galalign_mardyks": swe.SIDM_GALALIGN_MARDYKS,
+    "galcent_cochrane": swe.SIDM_GALCENT_COCHRANE,
+    "galcent_mula_wilhelm": swe.SIDM_GALCENT_MULA_WILHELM,
+    "galcent_rgibrand": swe.SIDM_GALCENT_RGILBRAND,
+    "true_sheoran": swe.SIDM_TRUE_SHEORAN,
+    "ushashashi": swe.SIDM_USHASHASHI,
+    "lahiri_1940": swe.SIDM_LAHIRI_1940,
+    "lahiri_icrc": swe.SIDM_LAHIRI_ICRC,
+    "lahiri_vp285": swe.SIDM_LAHIRI_VP285,
+    "krishnamurti_vp291": swe.SIDM_KRISHNAMURTI_VP291,
+}
+
+for name, const in _SIDM_MAP.items():
+    try:
+        label = swe.get_ayanamsa_name(const) or name.replace("_", " ").title()
+    except Exception:
+        label = name.replace("_", " ").title()
+    AYANAMSA_MODES[name] = {
+        "id": const,
+        "label": label,
+        "description": f"Swiss Ephemeris sidereal mode {name}.",
+    }
+
+DEFAULT_AYANAMSA = "lahiri"
+
+# House systems supported by Swiss Ephemeris.
+HOUSE_SYSTEMS: dict[str, dict[str, Any]] = {
+    "P": {"name": "Placidus", "description": "Placidus house system (default)."},
+    "K": {"name": "Koch", "description": "Koch house system."},
+    "O": {"name": "Porphyrius", "description": "Porphyrius house system."},
+    "R": {"name": "Regiomontanus", "description": "Regiomontanus house system."},
+    "C": {"name": "Campanus", "description": "Campanus house system."},
+    "A": {"name": "Equal (0° Aries)", "description": "Equal houses from 0° Aries."},
+    "E": {"name": "Equal (Ascendant)", "description": "Equal houses from Ascendant."},
+    "V": {"name": "Vehlow", "description": "Vehlow equal houses."},
+    "X": {"name": "Axial/Aequalis", "description": "Axial system."},
+    "H": {"name": "Horizon", "description": "Horizon houses."},
+    "N": {"name": "Natural/Whole Sign", "description": "Whole sign houses."},
+    "B": {"name": "Pullen SD", "description": "Pullen sinodal delta."},
+    "G": {"name": "Gauquelin Sectors", "description": "Gauquelin sectors."},
+    "M": {"name": "Morinus", "description": "Morinus house system."},
+    "U": {"name": "Uranus/Krueger", "description": "Krugeian/Uranus houses."},
+    "T": {"name": "Topocentric", "description": "Topocentric house system."},
+}
+
+DEFAULT_HOUSE_SYSTEM = "P"
+
+
+def list_ayanamsa_modes() -> dict[str, Any]:
+    return {
+        "default": DEFAULT_AYANAMSA,
+        "modes": AYANAMSA_MODES,
+    }
+
+
+def list_house_systems() -> dict[str, Any]:
+    return {
+        "default": DEFAULT_HOUSE_SYSTEM,
+        "systems": HOUSE_SYSTEMS,
+    }

package/azure-function/python/kundali_lib/vedic/bhava_chalit.py

@@ -0,0 +1,137 @@
+"""Bhava Chalit Chart: house positions based on equal divisions from house cusps."""
+
+from kundali_lib.vedic.constants import RASHIS
+
+# Absolute longitude where each rashi begins (sidereal 0°)
+RASHI_START: dict[str, float] = {rashi: i * 30.0 for i, rashi in enumerate(RASHIS)}
+
+
+def _normalize(lon: float) -> float:
+    """Bring longitude into [0, 360)."""
+    return lon % 360.0
+
+
+def _angular_distance(a: float, b: float) -> float:
+    """Shortest signed arc from a to b along the zodiac circle, result in (-180, 180]."""
+    diff = (b - a) % 360.0
+    if diff > 180.0:
+        diff -= 360.0
+    return diff
+
+
+def _reconstruct_cusp_longitudes(base_chart: dict) -> list[float]:
+    """Convert (rashi, degree-within-sign) cusp data back to absolute longitudes.
+
+    ``base_chart["houses"]`` maps ``"House_1"`` … ``"House_12"`` to rashi names.
+    ``base_chart["house_cusp_degrees"]`` is a 12-element list of degrees-within-sign
+    (0–30) for each cusp, as produced by ``houses_dict_and_degrees()``.
+    """
+    houses: dict[str, str] = base_chart["houses"]
+    cusp_degrees: list[float] = base_chart["house_cusp_degrees"]
+    cusps_abs: list[float] = []
+    for i in range(12):
+        rashi = houses[f"House_{i + 1}"]
+        deg = cusp_degrees[i]
+        cusps_abs.append(_normalize(RASHI_START[rashi] + deg))
+    return cusps_abs
+
+
+def _build_bhava_boundaries(cusps_abs: list[float]) -> list[tuple[float, float]]:
+    """Return 12 (start, end) boundary pairs using the midpoint method.
+
+    The boundary between house N and house N+1 is the midpoint of cusp_N and cusp_{N+1}
+    along the zodiac circle (handling wrap-around correctly).
+    """
+    boundaries: list[tuple[float, float]] = []
+    midpoints: list[float] = []
+    for i in range(12):
+        c_this = cusps_abs[i]
+        c_next = cusps_abs[(i + 1) % 12]
+        # Arc from c_this → c_next (forward along zodiac)
+        arc = (c_next - c_this) % 360.0
+        mid = _normalize(c_this + arc / 2.0)
+        midpoints.append(mid)
+
+    for i in range(12):
+        start = midpoints[(i - 1) % 12]
+        end = midpoints[i]
+        boundaries.append((start, end))
+
+    return boundaries
+
+
+def _planet_bhava(planet_lon: float, boundaries: list[tuple[float, float]]) -> int:
+    """Return 1-based Bhava Chalit house number for a given planet longitude."""
+    for i, (start, end) in enumerate(boundaries):
+        # The span from start → end going forward along the zodiac
+        if start <= end:
+            if start <= planet_lon < end:
+                return i + 1
+        else:
+            # Wrap-around case (crosses 0°/360°)
+            if planet_lon >= start or planet_lon < end:
+                return i + 1
+    # Fallback — should not reach here with a well-formed chart
+    return 1
+
+
+def get_bhava_chalit(base_chart: dict) -> dict:
+    """Compute the Bhava Chalit (Equal House from Cusps) chart.
+
+    Args:
+        base_chart: Output of ``build_chart()``.  Must contain ``planetary_positions``,
+                    ``houses``, ``house_cusp_degrees``, and ``ascendant``.
+
+    Returns:
+        A dict with absolute cusp longitudes, bhava boundaries, per-planet bhava
+        positions, and a list of planets whose house changed from the rashi chart.
+    """
+    cusps_abs = _reconstruct_cusp_longitudes(base_chart)
+    boundaries = _build_bhava_boundaries(cusps_abs)
+
+    # Build output for house cusps
+    house_cusps_absolute: dict[str, float] = {
+        f"House_{i + 1}": round(cusps_abs[i], 4) for i in range(12)
+    }
+
+    bhava_boundaries: dict[str, dict] = {}
+    for i, (start, end) in enumerate(boundaries):
+        bhava_boundaries[f"House_{i + 1}"] = {
+            "start": round(start, 4),
+            "end": round(end, 4),
+        }
+
+    planetary_bhava_positions: list[dict] = []
+    planets_that_changed: list[str] = []
+
+    for planet in base_chart["planetary_positions"]:
+        pname = planet["name"]
+        lon = planet["longitude"]
+        regular_house: int = planet["house"]
+        bhava_house = _planet_bhava(_normalize(lon), boundaries)
+        changed = bhava_house != regular_house
+
+        planetary_bhava_positions.append(
+            {
+                "planet": pname,
+                "longitude": round(lon, 4),
+                "regular_house": regular_house,
+                "bhava_chalit_house": bhava_house,
+                "house_changed": changed,
+                "rashi": planet["rashi"],
+            }
+        )
+
+        if changed:
+            planets_that_changed.append(pname)
+
+    return {
+        "house_cusps_absolute": house_cusps_absolute,
+        "bhava_boundaries": bhava_boundaries,
+        "planetary_bhava_positions": planetary_bhava_positions,
+        "ascendant_bhava": 1,
+        "planets_that_changed_house": planets_that_changed,
+        "note": (
+            "Bhava Chalit shows actual house influence. Use alongside Rashi chart."
+        ),
+    }