kundali-chart-mcp 0.2.1

package/python/kundali_lib/vedic/constants.py

@@ -0,0 +1,108 @@
+"""Vedic chart constants: planets, rashis, nakshatras."""
+
+import swisseph as swe
+
+PLANET_IDS = {
+    "Sun": swe.SUN,
+    "Moon": swe.MOON,
+    "Mars": swe.MARS,
+    "Mercury": swe.MERCURY,
+    "Jupiter": swe.JUPITER,
+    "Venus": swe.VENUS,
+    "Saturn": swe.SATURN,
+    "Rahu": swe.MEAN_NODE,
+    "Ketu": None,
+}
+
+RASHIS = [
+    "Aries",
+    "Taurus",
+    "Gemini",
+    "Cancer",
+    "Leo",
+    "Virgo",
+    "Libra",
+    "Scorpio",
+    "Sagittarius",
+    "Capricorn",
+    "Aquarius",
+    "Pisces",
+]
+
+RASHI_LORDS = [
+    "Mars",
+    "Venus",
+    "Mercury",
+    "Moon",
+    "Sun",
+    "Mercury",
+    "Venus",
+    "Mars",
+    "Jupiter",
+    "Saturn",
+    "Saturn",
+    "Jupiter",
+]
+
+NAKSHATRAS = [
+    "Ashwini",
+    "Bharani",
+    "Krittika",
+    "Rohini",
+    "Mrigashira",
+    "Ardra",
+    "Punarvasu",
+    "Pushya",
+    "Ashlesha",
+    "Magha",
+    "Purva Phalguni",
+    "Uttara Phalguni",
+    "Hasta",
+    "Chitra",
+    "Swati",
+    "Vishakha",
+    "Anuradha",
+    "Jyeshtha",
+    "Mula",
+    "Purva Ashadha",
+    "Uttara Ashadha",
+    "Shravana",
+    "Dhanishta",
+    "Shatabhisha",
+    "Purva Bhadrapada",
+    "Uttara Bhadrapada",
+    "Revati",
+]
+
+NAKSHATRA_LORDS = [
+    "Ketu",
+    "Venus",
+    "Sun",
+    "Moon",
+    "Mars",
+    "Rahu",
+    "Jupiter",
+    "Saturn",
+    "Mercury",
+    "Ketu",
+    "Venus",
+    "Sun",
+    "Moon",
+    "Mars",
+    "Rahu",
+    "Jupiter",
+    "Saturn",
+    "Mercury",
+    "Ketu",
+    "Venus",
+    "Sun",
+    "Moon",
+    "Mars",
+    "Rahu",
+    "Jupiter",
+    "Saturn",
+    "Mercury",
+]
+
+# Legacy constants for backward compatibility; new code should use ayanamsa.py defaults.
+CALC_FLAGS = swe.FLG_SWIEPH | swe.FLG_SPEED | swe.FLG_SIDEREAL

package/python/kundali_lib/vedic/dasha_extended.py

@@ -0,0 +1,262 @@
+"""Extended Dasha calculations: Pratyantar Dasha (3rd level) and Yogini Dasha."""
+
+from datetime import datetime, timedelta
+
+from kundali_lib.vedic.constants import NAKSHATRAS
+
+# ── Vimshottari base data ────────────────────────────────────────────────────
+
+VIMSHOTTARI_SEQUENCE = [
+    "Ketu",
+    "Venus",
+    "Sun",
+    "Moon",
+    "Mars",
+    "Rahu",
+    "Jupiter",
+    "Saturn",
+    "Mercury",
+]
+VIMSHOTTARI_YEARS: dict[str, int] = {
+    "Ketu": 7,
+    "Venus": 20,
+    "Sun": 6,
+    "Moon": 10,
+    "Mars": 7,
+    "Rahu": 18,
+    "Jupiter": 16,
+    "Saturn": 19,
+    "Mercury": 17,
+}
+VIMSHOTTARI_TOTAL = 120  # years
+
+NAKSHATRA_TO_DASHA_LORD: dict[str, str] = {
+    "Ashwini": "Ketu",
+    "Magha": "Ketu",
+    "Mula": "Ketu",
+    "Bharani": "Venus",
+    "Purva Phalguni": "Venus",
+    "Purva Ashadha": "Venus",
+    "Krittika": "Sun",
+    "Uttara Phalguni": "Sun",
+    "Uttara Ashadha": "Sun",
+    "Rohini": "Moon",
+    "Hasta": "Moon",
+    "Shravana": "Moon",
+    "Mrigashira": "Mars",
+    "Chitra": "Mars",
+    "Dhanishta": "Mars",
+    "Ardra": "Rahu",
+    "Swati": "Rahu",
+    "Shatabhisha": "Rahu",
+    "Punarvasu": "Jupiter",
+    "Vishakha": "Jupiter",
+    "Purva Bhadrapada": "Jupiter",
+    "Pushya": "Saturn",
+    "Anuradha": "Saturn",
+    "Uttara Bhadrapada": "Saturn",
+    "Ashlesha": "Mercury",
+    "Jyeshtha": "Mercury",
+    "Revati": "Mercury",
+}
+
+# ── Yogini Dasha data ────────────────────────────────────────────────────────
+
+YOGINI_SEQUENCE = [
+    "Mangala",
+    "Pingala",
+    "Dhanya",
+    "Bhramari",
+    "Bhadrika",
+    "Ulka",
+    "Siddha",
+    "Sankata",
+]
+YOGINI_PLANETS: dict[str, str] = {
+    "Mangala": "Moon",
+    "Pingala": "Sun",
+    "Dhanya": "Jupiter",
+    "Bhramari": "Mars",
+    "Bhadrika": "Mercury",
+    "Ulka": "Saturn",
+    "Siddha": "Venus",
+    "Sankata": "Rahu",
+}
+YOGINI_YEARS: dict[str, int] = {
+    "Mangala": 1,
+    "Pingala": 2,
+    "Dhanya": 3,
+    "Bhramari": 4,
+    "Bhadrika": 5,
+    "Ulka": 6,
+    "Siddha": 7,
+    "Sankata": 8,
+}
+YOGINI_TOTAL = 36  # years
+
+_NAKSHATRA_SPAN = 360.0 / 27.0
+
+
+# ── Private helpers ──────────────────────────────────────────────────────────
+
+
+def _rotated(seq: list[str], start: str) -> list[str]:
+    """Return seq rotated so it begins at start."""
+    idx = seq.index(start)
+    return seq[idx:] + seq[:idx]
+
+
+def _compute_pratyantars(
+    ad_start: datetime,
+    ad_lord: str,
+    ad_duration_years: float,
+) -> dict:
+    """Compute Pratyantar Dashas (3rd level) within one Antardasha.
+
+    PD sequence starts from the AD lord; PD duration = (pd_years/120) * ad_duration_years.
+    """
+    result: dict = {}
+    pd_cursor = ad_start
+
+    for pd_lord in _rotated(VIMSHOTTARI_SEQUENCE, ad_lord):
+        pd_years = (VIMSHOTTARI_YEARS[pd_lord] / VIMSHOTTARI_TOTAL) * ad_duration_years
+        pd_days = pd_years * 365.25
+        pd_end = pd_cursor + timedelta(days=pd_days)
+
+        result[pd_lord] = {
+            "start": pd_cursor.strftime("%d-%m-%Y"),
+            "end": pd_end.strftime("%d-%m-%Y"),
+            "duration_days": round(pd_days, 2),
+        }
+        pd_cursor = pd_end
+
+    return result
+
+
+# ── Public functions ─────────────────────────────────────────────────────────
+
+
+def get_pratyantar_dasha(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+) -> dict:
+    """Calculate 3 levels of Vimshottari Dasha: Mahadasha → Antardasha → Pratyantar Dasha.
+
+    The first Mahadasha started before birth; its start date is computed by
+    extrapolating back by the elapsed fraction of the birth nakshatra.
+
+    Args:
+        birth_dt: Naive local birth datetime.
+        moon_longitude: Sidereal Moon longitude in degrees (0–360).
+        moon_nakshatra: Name of the birth nakshatra (e.g. "Ashwini").
+
+    Returns:
+        dict with keys ``birth_dasha_lord`` and ``mahadashas`` (fully nested).
+    """
+    birth_dasha_lord = NAKSHATRA_TO_DASHA_LORD[moon_nakshatra]
+
+    # Fraction of birth nakshatra already elapsed at the moment of birth
+    fraction_elapsed = (moon_longitude % _NAKSHATRA_SPAN) / _NAKSHATRA_SPAN
+
+    result_mds: dict = {}
+    current_md_end: datetime = birth_dt  # running cursor; overwritten in loop
+
+    for i, md_lord in enumerate(_rotated(VIMSHOTTARI_SEQUENCE, birth_dasha_lord)):
+        md_full_years = VIMSHOTTARI_YEARS[md_lord]
+        md_full_days = md_full_years * 365.25
+
+        if i == 0:
+            # First MD started (fraction_elapsed * full_years) before birth
+            elapsed_days = fraction_elapsed * md_full_days
+            md_start = birth_dt - timedelta(days=elapsed_days)
+            # Duration available from birth onward
+            display_duration = round((1.0 - fraction_elapsed) * md_full_years, 4)
+        else:
+            md_start = current_md_end
+            display_duration = float(md_full_years)
+
+        md_end = md_start + timedelta(days=md_full_days)
+        current_md_end = md_end
+
+        # ── Antardasha sequence starts from this MD lord ──────────────────
+        result_ads: dict = {}
+        ad_cursor = md_start
+
+        for ad_lord in _rotated(VIMSHOTTARI_SEQUENCE, md_lord):
+            ad_full_years = (
+                VIMSHOTTARI_YEARS[ad_lord] / VIMSHOTTARI_TOTAL
+            ) * md_full_years
+            ad_full_days = ad_full_years * 365.25
+            ad_end = ad_cursor + timedelta(days=ad_full_days)
+
+            result_ads[ad_lord] = {
+                "start": ad_cursor.strftime("%d-%m-%Y"),
+                "end": ad_end.strftime("%d-%m-%Y"),
+                "duration_days": round(ad_full_days, 2),
+                "pratyantars": _compute_pratyantars(ad_cursor, ad_lord, ad_full_years),
+            }
+            ad_cursor = ad_end
+
+        result_mds[md_lord] = {
+            "start": md_start.strftime("%d-%m-%Y"),
+            "end": md_end.strftime("%d-%m-%Y"),
+            "duration_years": display_duration,
+            "antardashas": result_ads,
+        }
+
+    return {
+        "birth_dasha_lord": birth_dasha_lord,
+        "mahadashas": result_mds,
+    }
+
+
+def get_yogini_dasha(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+) -> dict:
+    """Calculate Yogini Dasha — an 8-planet, 36-year Vedic cycle.
+
+    The 27 nakshatras are grouped in sets of 3 (cycling through 8 yoginis).
+    The fraction elapsed in the birth nakshatra gives the remaining time in
+    the birth yogini period.
+
+    Args:
+        birth_dt: Naive local birth datetime.
+        moon_longitude: Sidereal Moon longitude in degrees (0–360).
+        moon_nakshatra: Name of the birth nakshatra.
+
+    Returns:
+        dict with keys ``birth_yogini`` and ``yogini_dashas``.
+    """
+    nak_idx = NAKSHATRAS.index(moon_nakshatra)
+    yogini_idx = (nak_idx // 3) % 8
+    birth_yogini = YOGINI_SEQUENCE[yogini_idx]
+
+    fraction_elapsed = (moon_longitude % _NAKSHATRA_SPAN) / _NAKSHATRA_SPAN
+    remaining_years = (1.0 - fraction_elapsed) * YOGINI_YEARS[birth_yogini]
+
+    result_dashas: dict = {}
+    current_date = birth_dt
+
+    for i in range(8):
+        j = (yogini_idx + i) % 8
+        yogini = YOGINI_SEQUENCE[j]
+        duration = remaining_years if i == 0 else float(YOGINI_YEARS[yogini])
+        end_date = current_date + timedelta(days=duration * 365.25)
+
+        result_dashas[yogini] = {
+            "yogini": yogini,
+            "planet": YOGINI_PLANETS[yogini],
+            "start": current_date.strftime("%d-%m-%Y"),
+            "end": end_date.strftime("%d-%m-%Y"),
+            # Remaining years for birth period, full int years for the rest
+            "duration_years": round(duration, 4) if i == 0 else YOGINI_YEARS[yogini],
+        }
+        current_date = end_date
+
+    return {
+        "birth_yogini": birth_yogini,
+        "yogini_dashas": result_dashas,
+    }