kundali-chart-mcp 0.2.1

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

@@ -0,0 +1,319 @@
+"""Special planetary conditions: Vargottama, Jaimini Karakas, Dig Bala, Pushkara Navamsha."""
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+RASHIS = [
+    "Aries",
+    "Taurus",
+    "Gemini",
+    "Cancer",
+    "Leo",
+    "Virgo",
+    "Libra",
+    "Scorpio",
+    "Sagittarius",
+    "Capricorn",
+    "Aquarius",
+    "Pisces",
+]
+
+# Jaimini Chara Karaka planets (Rahu included as 8th)
+KARAKA_PLANETS = [
+    "Sun",
+    "Moon",
+    "Mars",
+    "Mercury",
+    "Jupiter",
+    "Venus",
+    "Saturn",
+    "Rahu",
+]
+
+KARAKA_NAMES = [
+    "Atmakaraka",  # AK  — highest degree
+    "Amatyakaraka",  # AmK
+    "Bhratrukaraka",  # BK
+    "Matrukaraka",  # MK
+    "Putrakaraka",  # PK
+    "Gnatikaraka",  # GK
+    "Darakaraka",  # DK — lowest degree (7th)
+]
+
+# Dig Bala: planet → best house (1-based)
+DIG_BALA_BEST = {
+    "Sun": 10,
+    "Mars": 10,
+    "Moon": 4,
+    "Venus": 4,
+    "Mercury": 1,
+    "Jupiter": 1,
+    "Saturn": 7,
+}
+
+KENDRA_HOUSES = {1, 4, 7, 10}
+
+# Pushkara Navamsha degree ranges per rashi  (inclusive lower, exclusive upper)
+# Source: classical texts — the benefic Navamsha within each sign
+PUSHKARA_RANGES: dict[str, tuple[float, float]] = {
+    "Aries": (21.0, 23.2),
+    "Taurus": (10.0, 13.3),
+    "Gemini": (28.0, 30.0),
+    "Cancer": (25.0, 27.2),
+    "Leo": (22.0, 24.4),
+    "Virgo": (19.0, 21.7),
+    "Libra": (16.0, 18.9),
+    "Scorpio": (13.0, 16.0),
+    "Sagittarius": (10.0, 13.3),
+    "Capricorn": (7.0, 10.6),
+    "Aquarius": (4.0, 7.8),
+    "Pisces": (1.0, 4.4),
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_planet(positions: list, name: str) -> dict | None:
+    for p in positions:
+        if p.get("name", "").lower() == name.lower():
+            return p
+    return None
+
+
+def _degree_in_sign(longitude: float) -> float:
+    """Return the degrees elapsed within the current sign (0-30)."""
+    return longitude % 30
+
+
+def _rashi_from_lon(lon: float) -> str:
+    return RASHIS[int(lon % 360 / 30)]
+
+
+# ---------------------------------------------------------------------------
+# 1. Vargottama
+# ---------------------------------------------------------------------------
+
+
+def check_vargottama(planetary_positions: list, d9_positions: list) -> list:
+    """Identify Vargottama planets (same rashi in D1 and D9).
+
+    Parameters
+    ----------
+    planetary_positions : list
+        D1 (natal/rashi) planet dicts from build_chart().
+    d9_positions : list
+        D9 (Navamsa) planet dicts.  Must contain at least ``name`` and
+        ``rashi`` (or ``longitude``) fields.
+
+    Returns
+    -------
+    list of dict
+        Each entry: planet, d1_rashi, d9_rashi, is_vargottama.
+    """
+    results: list[dict] = []
+    all_planet_names = {p["name"] for p in planetary_positions if "name" in p}
+
+    for pname in all_planet_names:
+        d1 = _get_planet(planetary_positions, pname)
+        d9 = _get_planet(d9_positions, pname)
+
+        d1_rashi = d1.get("rashi") if d1 else None
+        if d9 is not None:
+            d9_rashi = d9.get("rashi") or (
+                _rashi_from_lon(d9["longitude"]) if "longitude" in d9 else None
+            )
+        else:
+            d9_rashi = None
+
+        is_vargottama = (
+            d1_rashi is not None and d9_rashi is not None and d1_rashi == d9_rashi
+        )
+
+        results.append(
+            {
+                "planet": pname,
+                "d1_rashi": d1_rashi,
+                "d9_rashi": d9_rashi,
+                "is_vargottama": is_vargottama,
+            }
+        )
+
+    # Stable ordering
+    results.sort(key=lambda x: x["planet"])
+    return results
+
+
+# ---------------------------------------------------------------------------
+# 2. Jaimini Chara Karakas
+# ---------------------------------------------------------------------------
+
+
+def get_jaimini_karakas(planetary_positions: list) -> dict:
+    """Calculate the 7 Jaimini Chara Karakas from 8 significator planets.
+
+    Rahu's degree is reversed: effective_degree = 30 - degree_in_sign.
+    All 8 planets are sorted by effective degree (descending); the top 7
+    receive Karaka titles from Atmakaraka down to Darakaraka.
+
+    Parameters
+    ----------
+    planetary_positions : list
+        List of planet dicts from build_chart().
+
+    Returns
+    -------
+    dict
+        Keys are Karaka names (Atmakaraka … Darakaraka); values are dicts
+        with ``planet``, ``degree_in_sign``, ``rashi``.
+    """
+    planet_data: list[tuple[float, str, float, str]] = []
+    # (effective_degree, name, raw_degree_in_sign, rashi)
+
+    for pname in KARAKA_PLANETS:
+        p = _get_planet(planetary_positions, pname)
+        if p is None:
+            continue
+
+        raw_deg = p.get("degree", None)
+        if raw_deg is None:
+            lon = p.get("longitude", 0.0)
+            raw_deg = _degree_in_sign(lon)
+
+        rashi = p.get("rashi") or _rashi_from_lon(p.get("longitude", 0.0))
+
+        if pname == "Rahu":
+            effective = 30.0 - (raw_deg % 30)
+        else:
+            effective = raw_deg % 30
+
+        planet_data.append((effective, pname, raw_deg % 30, rashi))
+
+    # Sort descending by effective degree; secondary sort by name for stability
+    planet_data.sort(key=lambda x: (-x[0], x[1]))
+
+    result: dict = {}
+    for rank, karaka_name in enumerate(KARAKA_NAMES):
+        if rank < len(planet_data):
+            eff, pname, raw_deg, rashi = planet_data[rank]
+            result[karaka_name] = {
+                "planet": pname,
+                "degree_in_sign": round(raw_deg, 4),
+                "rashi": rashi,
+            }
+        else:
+            result[karaka_name] = None
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# 3. Dig Bala
+# ---------------------------------------------------------------------------
+
+
+def get_dig_bala(planetary_positions: list) -> list:
+    """Assess directional strength (Dig Bala) for each planet.
+
+    Parameters
+    ----------
+    planetary_positions : list
+        List of planet dicts from build_chart().
+
+    Returns
+    -------
+    list of dict
+        Each entry: planet, house, best_house, dig_bala_strength.
+        Strength: "Full" (in best house), "Half" (any other kendra), "Weak" (other).
+    """
+    results: list[dict] = []
+
+    for pname, best_house in DIG_BALA_BEST.items():
+        p = _get_planet(planetary_positions, pname)
+        if p is None:
+            continue
+
+        house = p.get("house")
+        if house is None:
+            strength = "Unknown"
+        elif house == best_house:
+            strength = "Full"
+        elif house in KENDRA_HOUSES:
+            strength = "Half"
+        else:
+            strength = "Weak"
+
+        results.append(
+            {
+                "planet": pname,
+                "house": house,
+                "best_house": best_house,
+                "dig_bala_strength": strength,
+            }
+        )
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# 4. Pushkara Navamsha
+# ---------------------------------------------------------------------------
+
+
+def check_pushkara_navamsha(planetary_positions: list) -> list:
+    """Identify planets occupying a Pushkara Navamsha degree.
+
+    Parameters
+    ----------
+    planetary_positions : list
+        List of planet dicts from build_chart().
+
+    Returns
+    -------
+    list of dict
+        Each entry: planet, rashi, degree_in_sign, is_pushkara.
+    """
+    results: list[dict] = []
+
+    for p in planetary_positions:
+        pname = p.get("name", "Unknown")
+        rashi = p.get("rashi")
+
+        lon = p.get("longitude", None)
+        raw_deg = p.get("degree", None)
+
+        if raw_deg is None and lon is not None:
+            raw_deg = _degree_in_sign(float(lon))
+        elif raw_deg is not None:
+            raw_deg = float(raw_deg) % 30  # ensure within sign
+
+        if rashi is None and lon is not None:
+            rashi = _rashi_from_lon(float(lon))
+
+        if rashi is None or raw_deg is None:
+            results.append(
+                {
+                    "planet": pname,
+                    "rashi": rashi,
+                    "degree_in_sign": raw_deg,
+                    "is_pushkara": False,
+                }
+            )
+            continue
+
+        lo, hi = PUSHKARA_RANGES.get(rashi, (0.0, 0.0))
+        is_pushkara = lo <= raw_deg < hi
+
+        results.append(
+            {
+                "planet": pname,
+                "rashi": rashi,
+                "degree_in_sign": round(raw_deg, 4),
+                "is_pushkara": is_pushkara,
+            }
+        )
+
+    return results

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

@@ -0,0 +1,232 @@
+"""Sudarshana Chakra: Triple chart analysis from Lagna, Moon, and Sun simultaneously."""
+
+from datetime import datetime
+
+from kundali_lib.vedic.constants import RASHIS
+
+# Houses considered auspicious / inauspicious in classical Vedic astrology
+_TRIKONA = [1, 5, 9]  # Trine houses — dharma, prosperity
+_KENDRA = [1, 4, 7, 10]  # Angular houses — strength, visibility
+_DUSTHANA = [6, 8, 12]  # Dusthana — suffering, obstacles, loss
+_UPACHAYA = [3, 6, 10, 11]  # Growth houses
+
+
+def _house_from_reference(planet_rashi: str, reference_rashi: str) -> int:
+    """Return the 1-based house number of planet_rashi counted from reference_rashi."""
+    ref_i = RASHIS.index(reference_rashi)
+    pla_i = RASHIS.index(planet_rashi)
+    return (pla_i - ref_i) % 12 + 1
+
+
+def _build_view(
+    reference_label: str,
+    reference_rashi: str,
+    planetary_positions: list[dict],
+) -> dict:
+    """Build one of the three Sudarshana views (Lagna, Chandra, or Surya).
+
+    Args:
+        reference_label:   Human-readable label, e.g. ``"Lagna in Leo"``.
+        reference_rashi:   The sign that acts as House 1 for this view.
+        planetary_positions: From ``base_chart["planetary_positions"]``.
+    """
+    positions: list[dict] = []
+    for p in planetary_positions:
+        house = _house_from_reference(p["rashi"], reference_rashi)
+        positions.append(
+            {
+                "planet": p["name"],
+                "rashi": p["rashi"],
+                "house_from_reference": house,
+            }
+        )
+
+    return {
+        "reference": reference_label,
+        "reference_rashi": reference_rashi,
+        "planetary_positions": positions,
+        "key_houses": {
+            "trikona": _TRIKONA,
+            "kendra": _KENDRA,
+            "dusthana": _DUSTHANA,
+        },
+    }
+
+
+def _score_house(house: int) -> int:
+    """Simple scoring: trikona/kendra positive, dusthana negative, rest neutral."""
+    if house in _TRIKONA or house in _KENDRA:
+        return 1
+    if house in _DUSTHANA:
+        return -1
+    return 0
+
+
+def _consolidated_analysis(
+    lagna_view: dict,
+    chandra_view: dict,
+    surya_view: dict,
+) -> dict:
+    """Derive cross-view insights from all three Sudarshana perspectives."""
+
+    # Build per-house strength score across all three views
+    house_scores: dict[int, int] = {h: 0 for h in range(1, 13)}
+
+    for view in (lagna_view, chandra_view, surya_view):
+        for pos in view["planetary_positions"]:
+            h = pos["house_from_reference"]
+            house_scores[h] += _score_house(h)
+
+    strongest_house = max(house_scores, key=lambda h: house_scores[h])
+    weakest_house = min(house_scores, key=lambda h: house_scores[h])
+
+    # Per-planet consistency check
+    planet_scores: dict[str, int] = {}
+    for view in (lagna_view, chandra_view, surya_view):
+        for pos in view["planetary_positions"]:
+            pname = pos["planet"]
+            score = _score_house(pos["house_from_reference"])
+            planet_scores[pname] = planet_scores.get(pname, 0) + score
+
+    # Consistently well-placed: positive score in all 3 views (score == 3)
+    well_placed = [p for p, s in planet_scores.items() if s == 3]
+    # Consistently afflicted: negative score in all 3 views (score == -3)
+    afflicted = [p for p, s in planet_scores.items() if s == -3]
+
+    if well_placed and not afflicted:
+        summary = (
+            f"The Sudarshana Chakra shows strong harmony. "
+            f"{', '.join(well_placed)} "
+            f"{'are' if len(well_placed) > 1 else 'is'} well-placed across all three "
+            f"perspectives (Lagna, Moon, Sun), indicating consistent support in the "
+            f"significations of house {strongest_house}."
+        )
+    elif afflicted and not well_placed:
+        summary = (
+            f"Significant challenges indicated. "
+            f"{', '.join(afflicted)} "
+            f"{'are' if len(afflicted) > 1 else 'is'} afflicted across all three "
+            f"perspectives, requiring careful attention and remedial measures."
+        )
+    elif well_placed and afflicted:
+        summary = (
+            f"Mixed Sudarshana pattern. {', '.join(well_placed)} consistently strong; "
+            f"{', '.join(afflicted)} consistently under stress. Balance strengths against "
+            f"weaknesses in decision-making."
+        )
+    else:
+        summary = (
+            "Balanced Sudarshana Chakra — no planet dominates strongly or weakly across "
+            "all three views. Results depend on active dashas and Gochara."
+        )
+
+    return {
+        "strongest_house": strongest_house,
+        "weakest_house": weakest_house,
+        "planets_consistently_well_placed": well_placed,
+        "planets_consistently_afflicted": afflicted,
+        "summary": summary,
+    }
+
+
+def _sudarshana_year_analysis(
+    birth_year: int,
+    current_year: int,
+    lagna_view: dict,
+    chandra_view: dict,
+    surya_view: dict,
+) -> dict:
+    """Compute the Sudarshana year and activated houses for each view.
+
+    The Sudarshana year cycles through the 12 houses annually.
+    Year 1 of life → House 1, Year 2 → House 2, etc. (cycles every 12 years).
+    """
+    age = current_year - birth_year
+    if age < 0:
+        age = 0
+    year_house = (age % 12) + 1  # 1-based
+
+    def _planets_in_house(view: dict, house: int) -> list[str]:
+        return [
+            pos["planet"]
+            for pos in view["planetary_positions"]
+            if pos["house_from_reference"] == house
+        ]
+
+    return {
+        "age": age,
+        "sudarshana_year_number": age + 1,
+        "activated_house": year_house,
+        "lagna_view_activated_planets": _planets_in_house(lagna_view, year_house),
+        "chandra_view_activated_planets": _planets_in_house(chandra_view, year_house),
+        "surya_view_activated_planets": _planets_in_house(surya_view, year_house),
+        "note": (
+            f"Currently in Sudarshana year {age + 1} (House {year_house} activated). "
+            "The themes of this house are emphasised across all three chart perspectives."
+        ),
+    }
+
+
+def get_sudarshana_chakra(
+    base_chart: dict,
+    current_year: int | None = None,
+) -> dict:
+    """Generate the full Sudarshana Chakra analysis.
+
+    Args:
+        base_chart:    Output of ``build_chart()``.  Must contain
+                       ``planetary_positions``, ``ascendant``, ``moon_sign``,
+                       ``sun_sign``, and ``birth_details``.
+        current_year:  The Gregorian year to use for the Sudarshana year
+                       calculation.  Defaults to the current year if omitted.
+
+    Returns:
+        A dict with ``lagna_view``, ``chandra_view``, ``surya_view``,
+        ``consolidated_analysis``, and ``sudarshana_year``.
+    """
+    if current_year is None:
+        current_year = datetime.utcnow().year
+
+    planetary_positions: list[dict] = base_chart["planetary_positions"]
+    lagna_rashi: str = base_chart["ascendant"]["rashi"]
+    moon_rashi: str = base_chart["moon_sign"]
+    sun_rashi: str = base_chart["sun_sign"]
+
+    # --- Three Views ---
+    lagna_view = _build_view(
+        reference_label=f"Lagna in {lagna_rashi}",
+        reference_rashi=lagna_rashi,
+        planetary_positions=planetary_positions,
+    )
+    chandra_view = _build_view(
+        reference_label=f"Chandra (Moon) in {moon_rashi}",
+        reference_rashi=moon_rashi,
+        planetary_positions=planetary_positions,
+    )
+    surya_view = _build_view(
+        reference_label=f"Surya (Sun) in {sun_rashi}",
+        reference_rashi=sun_rashi,
+        planetary_positions=planetary_positions,
+    )
+
+    # --- Consolidated Analysis ---
+    consolidated = _consolidated_analysis(lagna_view, chandra_view, surya_view)
+
+    # --- Sudarshana Year ---
+    birth_year_str = base_chart.get("birth_details", {}).get("datetime", "")
+    try:
+        birth_year = int(birth_year_str[:4])
+    except (ValueError, TypeError):
+        birth_year = current_year
+
+    sudarshana_year = _sudarshana_year_analysis(
+        birth_year, current_year, lagna_view, chandra_view, surya_view
+    )
+
+    return {
+        "lagna_view": lagna_view,
+        "chandra_view": chandra_view,
+        "surya_view": surya_view,
+        "consolidated_analysis": consolidated,
+        "sudarshana_year": sudarshana_year,
+    }