kundali-chart-mcp 0.2.1

package/python/kundali_lib/vedic/yogas.py

@@ -0,0 +1,935 @@
+"""Identification of major Vedic astrological Yogas from a birth chart."""
+
+# ---------------------------------------------------------------------------
+# Reference data
+# ---------------------------------------------------------------------------
+
+RASHIS = [
+    "Aries",
+    "Taurus",
+    "Gemini",
+    "Cancer",
+    "Leo",
+    "Virgo",
+    "Libra",
+    "Scorpio",
+    "Sagittarius",
+    "Capricorn",
+    "Aquarius",
+    "Pisces",
+]
+
+RASHI_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 = {
+    "Sun": "Aries",
+    "Moon": "Taurus",
+    "Mars": "Capricorn",
+    "Mercury": "Virgo",
+    "Jupiter": "Cancer",
+    "Venus": "Pisces",
+    "Saturn": "Libra",
+}
+
+DEBILITATION = {
+    "Sun": "Libra",
+    "Moon": "Scorpio",
+    "Mars": "Cancer",
+    "Mercury": "Pisces",
+    "Jupiter": "Capricorn",
+    "Venus": "Virgo",
+    "Saturn": "Aries",
+}
+
+# Reverse map: which planet gets exalted in a given sign
+EXALTED_IN_SIGN = {v: k for k, v in EXALTATION.items()}
+
+KENDRA_HOUSES = {1, 4, 7, 10}
+TRIKONA_HOUSES = {1, 5, 9}
+DUSTHANA_HOUSES = {6, 8, 12}
+
+CLASSICAL_PLANETS = {"Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn"}
+BENEFIC_PLANETS = {"Moon", "Mercury", "Jupiter", "Venus"}
+NODES = {"Rahu", "Ketu"}
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_planet(positions: list, name: str) -> dict | None:
+    for p in positions:
+        if p["name"] == name:
+            return p
+    return None
+
+
+def _planet_house(positions: list, name: str) -> int | None:
+    p = _get_planet(positions, name)
+    return p["house"] if p else None
+
+
+def _planet_rashi(positions: list, name: str) -> str | None:
+    p = _get_planet(positions, name)
+    return p.get("rashi") if p else None
+
+
+def _house_lord(houses: dict, house_num: int) -> str:
+    """Return the planet that lords the given house number."""
+    rashi = houses.get(f"House_{house_num}")
+    if rashi:
+        return RASHI_LORDS.get(rashi, "")
+    return ""
+
+
+def _house_rashi(houses: dict, house_num: int) -> str:
+    return houses.get(f"House_{house_num}", "")
+
+
+def _nth_house_from(base: int, n: int) -> int:
+    """Return the house number that is n houses away from base (1-indexed)."""
+    return ((base - 1 + n - 1) % 12) + 1
+
+
+def _planets_in_house(positions: list, house_num: int) -> list:
+    return [p["name"] for p in positions if p["house"] == house_num]
+
+
+def _kendra_houses_from(base_house: int) -> set:
+    return {
+        _nth_house_from(base_house, 1),
+        _nth_house_from(base_house, 4),
+        _nth_house_from(base_house, 7),
+        _nth_house_from(base_house, 10),
+    }
+
+
+def _yoga_dict(
+    name: str,
+    yoga_type: str,
+    description: str,
+    planets: list,
+    present: bool,
+    strength: str,
+) -> dict:
+    return {
+        "name": name,
+        "type": yoga_type,
+        "description": description,
+        "planets_involved": planets,
+        "present": present,
+        "strength": strength,
+    }
+
+
+def _strength_from_flag(strong: bool, moderate: bool) -> str:
+    if strong:
+        return "Strong"
+    if moderate:
+        return "Moderate"
+    return "Weak"
+
+
+# ---------------------------------------------------------------------------
+# Pancha Mahapurusha Yogas
+# ---------------------------------------------------------------------------
+
+
+def _check_pancha_mahapurusha(
+    positions: list, planet_name: str, own_signs: set, exalt_sign: str | None
+) -> tuple:
+    """Return (present, strength)."""
+    p = _get_planet(positions, planet_name)
+    if not p:
+        return False, "Weak"
+    rashi = p.get("rashi", "")
+    house = p.get("house")
+    if house is None:
+        return False, "Weak"
+    in_own = rashi in own_signs
+    in_exalt = rashi == exalt_sign
+    in_kendra = house in KENDRA_HOUSES
+    present = (in_own or in_exalt) and in_kendra
+    if present:
+        strength = "Strong" if in_exalt else "Moderate"
+    else:
+        strength = "Weak"
+    return present, strength
+
+
+def _pancha_mahapurusha_yogas(positions: list) -> list:
+    yogas = []
+
+    configs = [
+        (
+            "Ruchaka",
+            "Mars",
+            {"Aries", "Scorpio"},
+            "Capricorn",
+            "Mars in own sign (Aries/Scorpio) or exaltation (Capricorn) in a kendra house.",
+        ),
+        (
+            "Bhadra",
+            "Mercury",
+            {"Gemini", "Virgo"},
+            "Virgo",
+            "Mercury in own sign (Gemini/Virgo) or exaltation (Virgo) in a kendra house.",
+        ),
+        (
+            "Hamsa",
+            "Jupiter",
+            {"Sagittarius", "Pisces"},
+            "Cancer",
+            "Jupiter in own sign (Sagittarius/Pisces) or exaltation (Cancer) in a kendra house.",
+        ),
+        (
+            "Malavya",
+            "Venus",
+            {"Taurus", "Libra"},
+            "Pisces",
+            "Venus in own sign (Taurus/Libra) or exaltation (Pisces) in a kendra house.",
+        ),
+        (
+            "Sasa",
+            "Saturn",
+            {"Capricorn", "Aquarius"},
+            "Libra",
+            "Saturn in own sign (Capricorn/Aquarius) or exaltation (Libra) in a kendra house.",
+        ),
+    ]
+
+    for yoga_name, planet, own_signs, exalt_sign, desc in configs:
+        present, strength = _check_pancha_mahapurusha(
+            positions, planet, own_signs, exalt_sign
+        )
+        yogas.append(
+            _yoga_dict(
+                yoga_name,
+                "Benefic",
+                desc,
+                [planet],
+                present,
+                strength if present else "Weak",
+            )
+        )
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Sun / Moon yogas
+# ---------------------------------------------------------------------------
+
+
+def _sun_moon_yogas(positions: list) -> list:
+    yogas = []
+
+    sun = _get_planet(positions, "Sun")
+    moon = _get_planet(positions, "Moon")
+    mercury = _get_planet(positions, "Mercury")
+    jupiter = _get_planet(positions, "Jupiter")
+    mars = _get_planet(positions, "Mars")
+
+    # Budha-Aditya Yoga
+    if sun and mercury:
+        present = sun["house"] == mercury["house"]
+        # Weaker if Mercury is combust (very close to Sun); rough proxy: combust if within 8°
+        combust = (
+            present and abs(sun.get("longitude", 0) - mercury.get("longitude", 0)) < 8
+        )
+        strength = "Moderate" if combust else ("Strong" if present else "Weak")
+        yogas.append(
+            _yoga_dict(
+                "Budha-Aditya Yoga",
+                "Benefic",
+                "Sun and Mercury conjunction. Confers intelligence and communication skills.",
+                ["Sun", "Mercury"],
+                present,
+                strength,
+            )
+        )
+
+    # Gaja Kesari Yoga
+    if moon and jupiter:
+        diff = (moon["house"] - jupiter["house"]) % 12
+        present = diff in {0, 3, 6, 9}
+        strength = "Strong" if diff == 0 else ("Moderate" if present else "Weak")
+        yogas.append(
+            _yoga_dict(
+                "Gaja Kesari Yoga",
+                "Benefic",
+                "Moon and Jupiter in kendra from each other. Bestows fame, wisdom, and prosperity.",
+                ["Moon", "Jupiter"],
+                present,
+                strength,
+            )
+        )
+
+    # Chandra-Mangala Yoga
+    if moon and mars:
+        present = moon["house"] == mars["house"]
+        yogas.append(
+            _yoga_dict(
+                "Chandra-Mangala Yoga",
+                "Benefic",
+                "Moon and Mars conjunction. Gives financial acumen and strong will.",
+                ["Moon", "Mars"],
+                present,
+                "Moderate" if present else "Weak",
+            )
+        )
+
+    # Sunapha / Anapha / Durudhura / Kemadruma (all require Moon)
+    if moon:
+        moon_house = moon["house"]
+        second_from_moon = _nth_house_from(moon_house, 2)
+        twelfth_from_moon = _nth_house_from(moon_house, 12)
+
+        # Planets in 2nd/12th from Moon (excluding Sun)
+        in_2nd = [
+            p["name"]
+            for p in positions
+            if p["house"] == second_from_moon and p["name"] != "Sun"
+        ]
+        in_12th = [
+            p["name"]
+            for p in positions
+            if p["house"] == twelfth_from_moon and p["name"] != "Sun"
+        ]
+
+        # Sunapha
+        present_sunapha = len(in_2nd) > 0
+        yogas.append(
+            _yoga_dict(
+                "Sunapha Yoga",
+                "Benefic",
+                "Planet (other than Sun) in 2nd house from Moon. Brings wealth and self-reliance.",
+                ["Moon"] + in_2nd,
+                present_sunapha,
+                "Moderate" if present_sunapha else "Weak",
+            )
+        )
+
+        # Anapha
+        present_anapha = len(in_12th) > 0
+        yogas.append(
+            _yoga_dict(
+                "Anapha Yoga",
+                "Benefic",
+                "Planet (other than Sun) in 12th house from Moon. Confers health and generosity.",
+                ["Moon"] + in_12th,
+                present_anapha,
+                "Moderate" if present_anapha else "Weak",
+            )
+        )
+
+        # Durudhura
+        present_duru = present_sunapha and present_anapha
+        yogas.append(
+            _yoga_dict(
+                "Durudhura Yoga",
+                "Benefic",
+                "Planets in both 2nd and 12th from Moon. Grants abundance and enjoyment of life.",
+                ["Moon"] + list(set(in_2nd + in_12th)),
+                present_duru,
+                "Strong" if present_duru else "Weak",
+            )
+        )
+
+        # Kemadruma (Malefic) — no planet in 2nd or 12th from Moon AND Moon not in kendra
+        moon_in_kendra = moon_house in KENDRA_HOUSES
+        present_kema = (
+            (not present_sunapha) and (not present_anapha) and (not moon_in_kendra)
+        )
+        yogas.append(
+            _yoga_dict(
+                "Kemadruma Yoga",
+                "Malefic",
+                "No planet in 2nd or 12th from Moon and Moon not in kendra. Weakens the Moon significantly.",
+                ["Moon"],
+                present_kema,
+                "Strong" if present_kema else "Weak",
+            )
+        )
+
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Wealth / Raj Yogas
+# ---------------------------------------------------------------------------
+
+
+def _raj_and_wealth_yogas(positions: list, houses: dict) -> list:
+    yogas = []
+
+    # --- Raj Yoga ---
+    kendra_houses = [1, 4, 7, 10]
+    trikona_houses_list = [1, 5, 9]
+    kendra_lord_map = {h: _house_lord(houses, h) for h in kendra_houses}
+    trikona_lord_map = {h: _house_lord(houses, h) for h in trikona_houses_list}
+
+    raj_pairs = []
+    for kh in kendra_houses:
+        kl = kendra_lord_map[kh]
+        if not kl:
+            continue
+        for th in trikona_houses_list:
+            if kh == th:
+                continue
+            tl = trikona_lord_map[th]
+            if not tl:
+                continue
+            if kl == tl:
+                # Same planet is yoga karaka (lords both kendra & trikona)
+                raj_pairs.append((kl, tl))
+                continue
+            kl_house = _planet_house(positions, kl)
+            tl_house = _planet_house(positions, tl)
+            # Conjunction
+            if kl_house is not None and tl_house is not None and kl_house == tl_house:
+                raj_pairs.append((kl, tl))
+                continue
+            # Exchange
+            kl_rashi = _planet_rashi(positions, kl)
+            tl_rashi = _planet_rashi(positions, tl)
+            if kl_rashi and tl_rashi:
+                if RASHI_LORDS.get(kl_rashi) == tl and RASHI_LORDS.get(tl_rashi) == kl:
+                    raj_pairs.append((kl, tl))
+
+    raj_present = len(raj_pairs) > 0
+    raj_planets = list({p for pair in raj_pairs for p in pair})
+    yogas.append(
+        _yoga_dict(
+            "Raj Yoga",
+            "Benefic",
+            "Lord of a kendra house (1,4,7,10) conjunct or exchange with lord of a trikona house (1,5,9). "
+            "Confers power, authority, and success.",
+            raj_planets,
+            raj_present,
+            "Strong" if len(raj_pairs) > 1 else ("Moderate" if raj_present else "Weak"),
+        )
+    )
+
+    # --- Dhana Yoga ---
+    lord_2 = _house_lord(houses, 2)
+    lord_11 = _house_lord(houses, 11)
+    dhana_present = False
+    if lord_2 and lord_11 and lord_2 != lord_11:
+        h2 = _planet_house(positions, lord_2)
+        h11 = _planet_house(positions, lord_11)
+        if h2 is not None and h11 is not None:
+            if h2 == h11:
+                dhana_present = True
+            else:
+                # Mutual kendra or trikona
+                diff = (h2 - h11) % 12
+                if diff in {0, 3, 6, 9}:
+                    dhana_present = True
+    elif lord_2 and lord_11 and lord_2 == lord_11:
+        dhana_present = True  # Same planet lords both 2nd and 11th
+    yogas.append(
+        _yoga_dict(
+            "Dhana Yoga",
+            "Benefic",
+            "Lords of 2nd and 11th conjoined or in mutual kendra/trikona. Brings great wealth.",
+            [lord_2, lord_11] if lord_2 and lord_11 else [],
+            dhana_present,
+            "Moderate" if dhana_present else "Weak",
+        )
+    )
+
+    # --- Lakshmi Yoga ---
+    lord_5 = _house_lord(houses, 5)
+    lord_9 = _house_lord(houses, 9)
+    venus = _get_planet(positions, "Venus")
+    lakshmi_present = False
+    lakshmi_strength = "Weak"
+    if venus:
+        venus_rashi = venus.get("rashi", "")
+        venus_house = venus.get("house")
+        venus_in_own = venus_rashi in {"Taurus", "Libra"}
+        venus_in_exalt = venus_rashi == "Pisces"
+        venus_in_kendra_or_trikona = venus_house in (KENDRA_HOUSES | TRIKONA_HOUSES)
+        venus_is_lord_5_or_9 = "Venus" in {lord_5, lord_9}
+        if (
+            venus_is_lord_5_or_9
+            and (venus_in_own or venus_in_exalt)
+            and venus_in_kendra_or_trikona
+        ):
+            lakshmi_present = True
+            lakshmi_strength = "Strong" if venus_in_exalt else "Moderate"
+    yogas.append(
+        _yoga_dict(
+            "Lakshmi Yoga",
+            "Benefic",
+            "Venus (lord of 5th or 9th) in own/exaltation sign in kendra or trikona. "
+            "Blesses with beauty, luxury, and spiritual grace.",
+            ["Venus"],
+            lakshmi_present,
+            lakshmi_strength,
+        )
+    )
+
+    # --- Saraswati Yoga ---
+    saraswati_houses = KENDRA_HOUSES | TRIKONA_HOUSES | {2, 11}
+    sj = _planet_house(positions, "Jupiter")
+    sv = _planet_house(positions, "Venus")
+    sm = _planet_house(positions, "Mercury")
+    saraswati_present = (
+        sj in saraswati_houses and sv in saraswati_houses and sm in saraswati_houses
+    )
+    yogas.append(
+        _yoga_dict(
+            "Saraswati Yoga",
+            "Benefic",
+            "Jupiter, Venus, and Mercury all in kendra or trikona (including 2nd/11th). "
+            "Confers great learning, eloquence, and artistic talent.",
+            ["Jupiter", "Venus", "Mercury"],
+            saraswati_present,
+            "Strong" if saraswati_present else "Weak",
+        )
+    )
+
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Benefic Yogas (Vesi / Voshi / Obhayachari / Amala / Pancha-Mahabhuta)
+# ---------------------------------------------------------------------------
+
+
+def _benefic_yogas(positions: list, houses: dict) -> list:
+    yogas = []
+
+    sun = _get_planet(positions, "Sun")
+
+    # Vesi / Voshi / Obhayachari
+    if sun:
+        sun_house = sun["house"]
+        second_from_sun = _nth_house_from(sun_house, 2)
+        twelfth_from_sun = _nth_house_from(sun_house, 12)
+
+        in_2nd_sun = [
+            p["name"]
+            for p in positions
+            if p["house"] == second_from_sun and p["name"] != "Moon"
+        ]
+        in_12th_sun = [
+            p["name"]
+            for p in positions
+            if p["house"] == twelfth_from_sun and p["name"] != "Moon"
+        ]
+
+        present_vesi = len(in_2nd_sun) > 0
+        yogas.append(
+            _yoga_dict(
+                "Vesi Yoga",
+                "Benefic",
+                "Planet (other than Moon) in 2nd house from Sun. Grants wealth and political success.",
+                ["Sun"] + in_2nd_sun,
+                present_vesi,
+                "Moderate" if present_vesi else "Weak",
+            )
+        )
+
+        present_voshi = len(in_12th_sun) > 0
+        yogas.append(
+            _yoga_dict(
+                "Voshi Yoga",
+                "Benefic",
+                "Planet (other than Moon) in 12th house from Sun. Brings fame and noble character.",
+                ["Sun"] + in_12th_sun,
+                present_voshi,
+                "Moderate" if present_voshi else "Weak",
+            )
+        )
+
+        present_obhaya = present_vesi and present_voshi
+        yogas.append(
+            _yoga_dict(
+                "Obhayachari Yoga",
+                "Benefic",
+                "Planets in both 2nd and 12th from Sun. Bestows kingly attributes and leadership.",
+                ["Sun"] + list(set(in_2nd_sun + in_12th_sun)),
+                present_obhaya,
+                "Strong" if present_obhaya else "Weak",
+            )
+        )
+
+    # Amala Yoga — only benefics in 10th from Lagna or Moon
+    tenth_from_lagna = 10
+    planets_in_10th = _planets_in_house(positions, tenth_from_lagna)
+    amala_lagna = len(planets_in_10th) > 0 and all(
+        p in BENEFIC_PLANETS for p in planets_in_10th
+    )
+
+    moon = _get_planet(positions, "Moon")
+    amala_moon = False
+    if moon:
+        tenth_from_moon = _nth_house_from(moon["house"], 10)
+        planets_in_10th_moon = _planets_in_house(positions, tenth_from_moon)
+        amala_moon = len(planets_in_10th_moon) > 0 and all(
+            p in BENEFIC_PLANETS for p in planets_in_10th_moon
+        )
+    amala_present = amala_lagna or amala_moon
+    yogas.append(
+        _yoga_dict(
+            "Amala Yoga",
+            "Benefic",
+            "Only benefic planets (Moon, Mercury, Jupiter, Venus) occupy the 10th from Lagna or Moon. "
+            "Ensures a spotless reputation and virtuous career.",
+            list(set(planets_in_10th)),
+            amala_present,
+            "Strong" if amala_present else "Weak",
+        )
+    )
+
+    # Pancha-Mahabhuta Yoga — all kendras occupied
+    kendra_occupied = all(
+        len(_planets_in_house(positions, h)) > 0 for h in KENDRA_HOUSES
+    )
+    all_kendra_planets = [
+        p for h in KENDRA_HOUSES for p in _planets_in_house(positions, h)
+    ]
+    yogas.append(
+        _yoga_dict(
+            "Pancha-Mahabhuta Yoga",
+            "Benefic",
+            "All kendra houses (1,4,7,10) are occupied by planets, representing all 5 elements. "
+            "Bestows a well-rounded, powerful personality.",
+            all_kendra_planets,
+            kendra_occupied,
+            "Strong" if kendra_occupied else "Weak",
+        )
+    )
+
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Malefic Yogas
+# ---------------------------------------------------------------------------
+
+
+def _malefic_yogas(positions: list, houses: dict) -> list:
+    yogas = []
+
+    # --- Daridra Yoga ---
+    good_houses = [1, 2, 4, 5, 7, 9, 10, 11]
+    dusthana_lords = {
+        _house_lord(houses, h) for h in [6, 8, 12] if _house_lord(houses, h)
+    }
+    good_lords = {_house_lord(houses, h) for h in good_houses if _house_lord(houses, h)}
+    daridra_planets = []
+    for dl in dusthana_lords:
+        for gl in good_lords:
+            if dl == gl:
+                continue
+            dl_house = _planet_house(positions, dl)
+            gl_house = _planet_house(positions, gl)
+            if dl_house is not None and gl_house is not None and dl_house == gl_house:
+                daridra_planets.extend([dl, gl])
+    daridra_present = len(daridra_planets) > 0
+    yogas.append(
+        _yoga_dict(
+            "Daridra Yoga",
+            "Malefic",
+            "Lords of dusthana houses (6th, 8th, 12th) conjunct with lords of good houses. "
+            "Can bring poverty, debts, and misfortune.",
+            list(set(daridra_planets)),
+            daridra_present,
+            "Strong" if daridra_present else "Weak",
+        )
+    )
+
+    # --- Shakata Yoga ---
+    moon = _get_planet(positions, "Moon")
+    jupiter = _get_planet(positions, "Jupiter")
+    shakata_present = False
+    if moon and jupiter:
+        diff_from_moon = (jupiter["house"] - moon["house"]) % 12 + 1
+        shakata_present = diff_from_moon in {6, 8, 12}
+    yogas.append(
+        _yoga_dict(
+            "Shakata Yoga",
+            "Malefic",
+            "Jupiter in 6th, 8th, or 12th house from Moon. Causes fluctuating fortune and obstacles.",
+            ["Moon", "Jupiter"],
+            shakata_present,
+            "Strong" if shakata_present else "Weak",
+        )
+    )
+
+    # --- Guru Chandal Yoga ---
+    rahu = _get_planet(positions, "Rahu")
+    ketu = _get_planet(positions, "Ketu")
+    guru_chandal_planets = ["Jupiter"]
+    guru_chandal = False
+    if jupiter:
+        if rahu and rahu["house"] == jupiter["house"]:
+            guru_chandal = True
+            guru_chandal_planets.append("Rahu")
+        if ketu and ketu["house"] == jupiter["house"]:
+            guru_chandal = True
+            guru_chandal_planets.append("Ketu")
+    yogas.append(
+        _yoga_dict(
+            "Guru Chandal Yoga",
+            "Malefic",
+            "Jupiter conjunct Rahu or Ketu. Can corrupt Jupiter's wisdom and cause ethical confusion.",
+            guru_chandal_planets,
+            guru_chandal,
+            "Strong" if guru_chandal else "Weak",
+        )
+    )
+
+    # --- Grahan Yoga ---
+    sun = _get_planet(positions, "Sun")
+    moon_p = _get_planet(positions, "Moon")
+    grahan_planets = []
+    if sun and rahu and sun["house"] == rahu["house"]:
+        grahan_planets.extend(["Sun", "Rahu"])
+    if sun and ketu and sun["house"] == ketu["house"]:
+        grahan_planets.extend(["Sun", "Ketu"])
+    if moon_p and rahu and moon_p["house"] == rahu["house"]:
+        grahan_planets.extend(["Moon", "Rahu"])
+    if moon_p and ketu and moon_p["house"] == ketu["house"]:
+        grahan_planets.extend(["Moon", "Ketu"])
+    grahan_present = len(grahan_planets) > 0
+    yogas.append(
+        _yoga_dict(
+            "Grahan Yoga",
+            "Malefic",
+            "Sun or Moon conjunct Rahu or Ketu (eclipse yoga). Afflicts the luminaries and causes setbacks.",
+            list(set(grahan_planets)),
+            grahan_present,
+            "Strong" if grahan_present else "Weak",
+        )
+    )
+
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Other Notable Yogas
+# ---------------------------------------------------------------------------
+
+
+def _other_yogas(positions: list, houses: dict) -> list:
+    yogas = []
+
+    moon = _get_planet(positions, "Moon")
+
+    # --- Neecha Bhanga Raj Yoga ---
+    neecha_bhanga_planets = []
+    for planet, debil_sign in DEBILITATION.items():
+        p = _get_planet(positions, planet)
+        if not p:
+            continue
+        if p.get("rashi") != debil_sign:
+            continue
+        # Planet is debilitated; check cancellation conditions
+        # Condition 1: Lord of the debilitation sign is in kendra from Lagna
+        debil_lord = RASHI_LORDS.get(debil_sign, "")
+        debil_lord_house = _planet_house(positions, debil_lord)
+        lord_in_kendra = (
+            debil_lord_house in KENDRA_HOUSES if debil_lord_house else False
+        )
+
+        # Condition 2: Planet exalted in the same sign is in kendra from Lagna or Moon
+        exalt_planet = EXALTED_IN_SIGN.get(debil_sign, "")
+        exalt_planet_house = (
+            _planet_house(positions, exalt_planet) if exalt_planet else None
+        )
+        exalt_in_kendra_lagna = (
+            (exalt_planet_house in KENDRA_HOUSES) if exalt_planet_house else False
+        )
+        exalt_in_kendra_moon = False
+        if moon and exalt_planet_house:
+            moon_kendras = _kendra_houses_from(moon["house"])
+            exalt_in_kendra_moon = exalt_planet_house in moon_kendras
+
+        if lord_in_kendra or exalt_in_kendra_lagna or exalt_in_kendra_moon:
+            neecha_bhanga_planets.append(planet)
+
+    nbr_present = len(neecha_bhanga_planets) > 0
+    yogas.append(
+        _yoga_dict(
+            "Neecha Bhanga Raj Yoga",
+            "Benefic",
+            "Debilitated planet's weakness is cancelled by the lord of debilitation sign or the "
+            "exaltation ruler being in kendra. Turns weakness into a source of strength.",
+            neecha_bhanga_planets,
+            nbr_present,
+            "Strong"
+            if len(neecha_bhanga_planets) > 1
+            else ("Moderate" if nbr_present else "Weak"),
+        )
+    )
+
+    # --- Viparita Raj Yoga ---
+    lord_6 = _house_lord(houses, 6)
+    lord_8 = _house_lord(houses, 8)
+    lord_12 = _house_lord(houses, 12)
+    l6h = _planet_house(positions, lord_6) if lord_6 else None
+    l8h = _planet_house(positions, lord_8) if lord_8 else None
+    l12h = _planet_house(positions, lord_12) if lord_12 else None
+
+    viparita_conditions = [
+        l6h in {8, 12} if l6h else False,
+        l8h in {6, 12} if l8h else False,
+        l12h in {6, 8} if l12h else False,
+    ]
+    vip_count = sum(viparita_conditions)
+    vip_present = vip_count > 0
+    vip_planets = []
+    if viparita_conditions[0] and lord_6:
+        vip_planets.append(lord_6)
+    if viparita_conditions[1] and lord_8:
+        vip_planets.append(lord_8)
+    if viparita_conditions[2] and lord_12:
+        vip_planets.append(lord_12)
+    yogas.append(
+        _yoga_dict(
+            "Viparita Raj Yoga",
+            "Benefic",
+            "Lord of 6th in 8th/12th, lord of 8th in 6th/12th, or lord of 12th in 6th/8th. "
+            "Adversity ultimately turns into power and success.",
+            vip_planets,
+            vip_present,
+            "Strong" if vip_count >= 2 else ("Moderate" if vip_present else "Weak"),
+        )
+    )
+
+    # --- Parivartana Yoga (Exchange) ---
+    planet_data = {p["name"]: p for p in positions if p["name"] in CLASSICAL_PLANETS}
+    sorted_names = sorted(planet_data.keys())
+    parivartana_yogas = []
+
+    for i, name1 in enumerate(sorted_names):
+        for name2 in sorted_names[i + 1 :]:
+            p1 = planet_data[name1]
+            p2 = planet_data[name2]
+            p1_rashi = p1.get("rashi", "")
+            p2_rashi = p2.get("rashi", "")
+            # Check mutual exchange
+            if (
+                RASHI_LORDS.get(p1_rashi) == name2
+                and RASHI_LORDS.get(p2_rashi) == name1
+            ):
+                h1 = p1["house"]
+                h2 = p2["house"]
+                is_kendra_1 = h1 in KENDRA_HOUSES
+                is_kendra_2 = h2 in KENDRA_HOUSES
+                is_trikona_1 = h1 in TRIKONA_HOUSES
+                is_trikona_2 = h2 in TRIKONA_HOUSES
+                is_dusthana_1 = h1 in DUSTHANA_HOUSES
+                is_dusthana_2 = h2 in DUSTHANA_HOUSES
+
+                if (
+                    (is_kendra_1 and is_kendra_2)
+                    or (is_kendra_1 and is_trikona_2)
+                    or (is_trikona_1 and is_kendra_2)
+                ):
+                    subtype = "Maha Parivartana Yoga"
+                    ytype = "Benefic"
+                elif (is_kendra_1 and is_dusthana_2) or (is_dusthana_1 and is_kendra_2):
+                    subtype = "Kahala Parivartana Yoga"
+                    ytype = "Neutral"
+                elif is_dusthana_1 or is_dusthana_2:
+                    subtype = "Dainya Parivartana Yoga"
+                    ytype = "Malefic"
+                else:
+                    subtype = "Parivartana Yoga"
+                    ytype = "Neutral"
+
+                parivartana_yogas.append(
+                    _yoga_dict(
+                        subtype,
+                        ytype,
+                        f"Exchange between {name1} (house {h1}) and {name2} (house {h2}). "
+                        "Planets act as if in each other's signs, amplifying their combined energy.",
+                        [name1, name2],
+                        True,
+                        "Moderate",
+                    )
+                )
+
+    yogas.extend(parivartana_yogas)
+    return yogas
+
+
+# ---------------------------------------------------------------------------
+# Main public function
+# ---------------------------------------------------------------------------
+
+
+def get_yogas(base_chart: dict) -> dict:
+    """
+    Identify major Vedic astrological Yogas from a birth chart.
+
+    Args:
+        base_chart: Full chart dict with keys:
+            planetary_positions, ascendant, houses, moon_sign, sun_sign
+
+    Returns:
+        dict with benefic_yogas, malefic_yogas, and summary.
+    """
+    positions = base_chart.get("planetary_positions", [])
+    houses = base_chart.get("houses", {})
+
+    all_yogas: list[dict] = []
+    all_yogas.extend(_pancha_mahapurusha_yogas(positions))
+    all_yogas.extend(_sun_moon_yogas(positions))
+    all_yogas.extend(_raj_and_wealth_yogas(positions, houses))
+    all_yogas.extend(_benefic_yogas(positions, houses))
+    all_yogas.extend(_malefic_yogas(positions, houses))
+    all_yogas.extend(_other_yogas(positions, houses))
+
+    benefic_yogas = [y for y in all_yogas if y["type"] == "Benefic" and y["present"]]
+    malefic_yogas = [y for y in all_yogas if y["type"] == "Malefic" and y["present"]]
+    neutral_present = [y for y in all_yogas if y["type"] == "Neutral" and y["present"]]
+
+    total_present = len(benefic_yogas) + len(malefic_yogas) + len(neutral_present)
+
+    if len(benefic_yogas) > len(malefic_yogas) * 2:
+        quality = "highly auspicious"
+    elif len(benefic_yogas) > len(malefic_yogas):
+        quality = "largely auspicious"
+    elif len(malefic_yogas) > len(benefic_yogas):
+        quality = "challenging with notable malefic influences"
+    else:
+        quality = "mixed"
+
+    strong_benefic = [y["name"] for y in benefic_yogas if y["strength"] == "Strong"]
+    strong_malefic = [y["name"] for y in malefic_yogas if y["strength"] == "Strong"]
+
+    summary_parts = [
+        f"Found {total_present} active yoga(s): "
+        f"{len(benefic_yogas)} benefic, {len(malefic_yogas)} malefic, "
+        f"{len(neutral_present)} neutral. The overall chart is {quality}."
+    ]
+    if strong_benefic:
+        summary_parts.append(f"Strong benefic yogas: {', '.join(strong_benefic)}.")
+    if strong_malefic:
+        summary_parts.append(f"Strong malefic yogas: {', '.join(strong_malefic)}.")
+
+    return {
+        "benefic_yogas": benefic_yogas,
+        "malefic_yogas": malefic_yogas,
+        "summary": " ".join(summary_parts),
+    }