kundali-chart-mcp 0.2.1

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

@@ -0,0 +1,439 @@
+"""Additional Dasha systems: Ashtottari, Sookshma (4th level), Prana (5th level)."""
+
+from datetime import datetime, timedelta
+
+from kundali_lib.vedic.dasha_extended import (
+    NAKSHATRA_TO_DASHA_LORD,
+    VIMSHOTTARI_SEQUENCE,
+    VIMSHOTTARI_TOTAL,
+    VIMSHOTTARI_YEARS,
+)
+
+# ── Ashtottari constants ─────────────────────────────────────────────────────
+
+ASHTOTTARI_SEQUENCE = [
+    "Sun",
+    "Moon",
+    "Mars",
+    "Mercury",
+    "Saturn",
+    "Jupiter",
+    "Rahu",
+    "Venus",
+]
+ASHTOTTARI_YEARS: dict[str, int] = {
+    "Sun": 6,
+    "Moon": 15,
+    "Mars": 8,
+    "Mercury": 17,
+    "Saturn": 10,
+    "Jupiter": 19,
+    "Rahu": 12,
+    "Venus": 21,
+}
+ASHTOTTARI_TOTAL = 108
+
+# Birth nakshatra → Ashtottari starting dasha
+NAKSHATRA_ASHTOTTARI: dict[str, str] = {
+    "Ashwini": "Sun",
+    "Bharani": "Moon",
+    "Krittika": "Mars",
+    "Rohini": "Mercury",
+    "Mrigashira": "Saturn",
+    "Ardra": "Jupiter",
+    "Punarvasu": "Rahu",
+    "Pushya": "Venus",
+    "Ashlesha": "Sun",
+    "Magha": "Moon",
+    "Purva Phalguni": "Mars",
+    "Uttara Phalguni": "Mercury",
+    "Hasta": "Saturn",
+    "Chitra": "Jupiter",
+    "Swati": "Rahu",
+    "Vishakha": "Venus",
+    "Anuradha": "Sun",
+    "Jyeshtha": "Moon",
+    "Mula": "Mars",
+    "Purva Ashadha": "Mercury",
+    "Uttara Ashadha": "Saturn",
+    "Shravana": "Jupiter",
+    "Dhanishta": "Rahu",
+    "Shatabhisha": "Venus",
+    "Purva Bhadrapada": "Sun",
+    "Uttara Bhadrapada": "Moon",
+    "Revati": "Mars",
+}
+
+_NAKSHATRA_SPAN = 360.0 / 27.0
+
+
+# ── Private helpers ──────────────────────────────────────────────────────────
+
+
+def _rotated(seq: list, start: str) -> list:
+    """Return seq rotated so it begins at start."""
+    idx = seq.index(start)
+    return seq[idx:] + seq[:idx]
+
+
+def _iter_pds(ad_lord: str, ad_start: datetime, ad_years: float):
+    """Yield (pd_lord, pd_start, pd_years) for each of the 9 PDs in one AD."""
+    pd_cursor = ad_start
+    for pd_lord in _rotated(VIMSHOTTARI_SEQUENCE, ad_lord):
+        pd_y = (VIMSHOTTARI_YEARS[pd_lord] / VIMSHOTTARI_TOTAL) * ad_years
+        pd_end = pd_cursor + timedelta(days=pd_y * 365.25)
+        yield pd_lord, pd_cursor, pd_y
+        pd_cursor = pd_end
+
+
+def _iter_sds(pd_lord: str, pd_start: datetime, pd_years: float):
+    """Yield (sd_lord, sd_start, sd_end) for each of the 9 SDs in one PD.
+
+    SD duration = (sd_years / 120) * pd_duration_years.
+    """
+    sd_cursor = pd_start
+    for sd_lord in _rotated(VIMSHOTTARI_SEQUENCE, pd_lord):
+        sd_y = (VIMSHOTTARI_YEARS[sd_lord] / VIMSHOTTARI_TOTAL) * pd_years
+        sd_days = sd_y * 365.25
+        sd_end = sd_cursor + timedelta(days=sd_days)
+        yield sd_lord, sd_cursor, sd_end, sd_y
+        sd_cursor = sd_end
+
+
+def _iter_prds(sd_lord: str, sd_start: datetime, sd_years: float):
+    """Yield (prd_lord, prd_start, prd_end, prd_days) for each PRD in one SD.
+
+    PRD duration = (prd_years / 120) * sd_duration_years.
+    """
+    prd_cursor = sd_start
+    for prd_lord in _rotated(VIMSHOTTARI_SEQUENCE, sd_lord):
+        prd_y = (VIMSHOTTARI_YEARS[prd_lord] / VIMSHOTTARI_TOTAL) * sd_years
+        prd_days = prd_y * 365.25
+        prd_end = prd_cursor + timedelta(days=prd_days)
+        yield prd_lord, prd_cursor, prd_end, prd_days
+        prd_cursor = prd_end
+
+
+def _find_periods(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+    now: datetime,
+) -> dict | None:
+    """Drill down MD → AD → PD and return context for current periods.
+
+    Returns a dict with keys: md_lord, ad_lord, ad_start, ad_years,
+    pd_lord, pd_start, pd_years — or None if not found within the 120-year span.
+    """
+    birth_dasha_lord = NAKSHATRA_TO_DASHA_LORD[moon_nakshatra]
+    fraction_elapsed = (moon_longitude % _NAKSHATRA_SPAN) / _NAKSHATRA_SPAN
+
+    md0_years = VIMSHOTTARI_YEARS[birth_dasha_lord]
+    md_cursor = birth_dt - timedelta(days=fraction_elapsed * md0_years * 365.25)
+
+    for md_lord in _rotated(VIMSHOTTARI_SEQUENCE, birth_dasha_lord):
+        md_years = VIMSHOTTARI_YEARS[md_lord]
+        md_start = md_cursor
+        md_end = md_start + timedelta(days=md_years * 365.25)
+        md_cursor = md_end
+
+        if not (md_start <= now < md_end):
+            continue
+
+        # Found the current MD — drill into ADs
+        ad_cursor = md_start
+        for ad_lord in _rotated(VIMSHOTTARI_SEQUENCE, md_lord):
+            ad_years = (VIMSHOTTARI_YEARS[ad_lord] / VIMSHOTTARI_TOTAL) * md_years
+            ad_start = ad_cursor
+            ad_end = ad_start + timedelta(days=ad_years * 365.25)
+            ad_cursor = ad_end
+
+            if not (ad_start <= now < ad_end):
+                continue
+
+            # Found the current AD — drill into PDs
+            pd_cursor = ad_start
+            for pd_lord in _rotated(VIMSHOTTARI_SEQUENCE, ad_lord):
+                pd_years = (VIMSHOTTARI_YEARS[pd_lord] / VIMSHOTTARI_TOTAL) * ad_years
+                pd_start = pd_cursor
+                pd_end = pd_start + timedelta(days=pd_years * 365.25)
+                pd_cursor = pd_end
+
+                if pd_start <= now < pd_end:
+                    return {
+                        "md_lord": md_lord,
+                        "ad_lord": ad_lord,
+                        "ad_start": ad_start,
+                        "ad_years": ad_years,
+                        "pd_lord": pd_lord,
+                        "pd_start": pd_start,
+                        "pd_years": pd_years,
+                    }
+
+    return None
+
+
+# ── Ashtottari Dasha ─────────────────────────────────────────────────────────
+
+
+def get_ashtottari_dasha(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+) -> dict:
+    """Calculate Ashtottari Dasha (108-year cycle).
+
+    Applicable when Rahu occupies certain positions; can be calculated for all charts.
+    Antardasha duration = (ad_years / 108) * md_years.
+
+    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 ``system``, ``total_years``, ``birth_dasha_lord``, and ``mahadashas``.
+    """
+    birth_dasha_lord = NAKSHATRA_ASHTOTTARI[moon_nakshatra]
+    fraction_elapsed = (moon_longitude % _NAKSHATRA_SPAN) / _NAKSHATRA_SPAN
+
+    result_mds: dict = {}
+    md_cursor: datetime | None = None
+
+    for i, md_lord in enumerate(_rotated(ASHTOTTARI_SEQUENCE, birth_dasha_lord)):
+        md_full_years = ASHTOTTARI_YEARS[md_lord]
+        md_full_days = md_full_years * 365.25
+
+        if i == 0:
+            elapsed_days = fraction_elapsed * md_full_days
+            md_start = birth_dt - timedelta(days=elapsed_days)
+            display_duration = round((1.0 - fraction_elapsed) * md_full_years, 4)
+        else:
+            md_start = md_cursor  # type: ignore[assignment]
+            display_duration = float(md_full_years)
+
+        md_end = md_start + timedelta(days=md_full_days)
+        md_cursor = md_end
+
+        # ── Antardasha sequence starts from this MD lord ─────────────────
+        result_ads: dict = {}
+        ad_cursor = md_start
+
+        for ad_lord in _rotated(ASHTOTTARI_SEQUENCE, md_lord):
+            ad_years = (ASHTOTTARI_YEARS[ad_lord] / ASHTOTTARI_TOTAL) * md_full_years
+            ad_days = ad_years * 365.25
+            ad_end = ad_cursor + timedelta(days=ad_days)
+
+            result_ads[ad_lord] = {
+                "start": ad_cursor.strftime("%d-%m-%Y"),
+                "end": ad_end.strftime("%d-%m-%Y"),
+                "duration_days": round(ad_days, 2),
+            }
+            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 {
+        "system": "Ashtottari",
+        "total_years": ASHTOTTARI_TOTAL,
+        "birth_dasha_lord": birth_dasha_lord,
+        "mahadashas": result_mds,
+    }
+
+
+# ── Sookshma Dasha (4th level) ────────────────────────────────────────────────
+
+
+def get_sookshma_dasha(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+) -> dict:
+    """Generate 4 levels of Vimshottari (MD → AD → PD → SD) and return the current state.
+
+    Finds the running period at all 4 levels (as of now) and returns the current
+    Sookshma Dasha plus the next 5 upcoming Sookshma periods.
+
+    SD duration = (sd_planet_years / 120) * pd_duration_years.
+
+    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 current MD/AD/PD/SD labels, current SD start/end, and
+        ``upcoming_sookshma`` (list of next 5 SD periods).
+    """
+    now = datetime.now()
+    ctx = _find_periods(birth_dt, moon_longitude, moon_nakshatra, now)
+
+    if ctx is None:
+        return {"error": "Could not determine current dasha period."}
+
+    current_sd_lord: str | None = None
+    current_sd_start: datetime | None = None
+    current_sd_end: datetime | None = None
+    upcoming: list = []
+    found = False
+
+    for pd_lord, pd_start, pd_years in _iter_pds(
+        ctx["ad_lord"], ctx["ad_start"], ctx["ad_years"]
+    ):
+        # Skip PDs that ended before the current PD began
+        pd_end = pd_start + timedelta(days=pd_years * 365.25)
+        if pd_end <= ctx["pd_start"]:
+            continue
+
+        for sd_lord, sd_start, sd_end, _sd_y in _iter_sds(pd_lord, pd_start, pd_years):
+            if sd_start <= now < sd_end:
+                current_sd_lord = sd_lord
+                current_sd_start = sd_start
+                current_sd_end = sd_end
+                found = True
+            elif found and len(upcoming) < 5:
+                upcoming.append(
+                    {
+                        "planet": sd_lord,
+                        "start": sd_start.strftime("%d-%m-%Y"),
+                        "end": sd_end.strftime("%d-%m-%Y"),
+                    }
+                )
+
+        if found and len(upcoming) >= 5:
+            break
+
+    return {
+        "current_mahadasha": ctx["md_lord"],
+        "current_antardasha": ctx["ad_lord"],
+        "current_pratyantar": ctx["pd_lord"],
+        "current_sookshma": current_sd_lord or "Unknown",
+        "current_sookshma_start": (
+            current_sd_start.strftime("%d-%m-%Y") if current_sd_start else ""
+        ),
+        "current_sookshma_end": (
+            current_sd_end.strftime("%d-%m-%Y") if current_sd_end else ""
+        ),
+        "upcoming_sookshma": upcoming,
+    }
+
+
+# ── Prana Dasha (5th level) ───────────────────────────────────────────────────
+
+
+def get_prana_dasha(
+    birth_dt: datetime,
+    moon_longitude: float,
+    moon_nakshatra: str,
+) -> dict:
+    """Generate 5 levels of Vimshottari (MD → AD → PD → SD → PRD) and return the current state.
+
+    Finds the running period at all 5 levels (as of now) and returns the current
+    Prana Dasha plus the next 5 upcoming Prana periods.
+
+    PRD duration = (prd_planet_years / 120) * sd_duration_years.
+
+    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 current MD/AD/PD/SD/PRD labels, current PRD start/end/duration_days,
+        and ``upcoming_prana`` (list of next 5 PRD periods).
+    """
+    now = datetime.now()
+    ctx = _find_periods(birth_dt, moon_longitude, moon_nakshatra, now)
+
+    if ctx is None:
+        return {"error": "Could not determine current dasha period."}
+
+    current_sd_lord: str | None = None
+    current_prd_lord: str | None = None
+    current_prd_start: datetime | None = None
+    current_prd_end: datetime | None = None
+    current_prd_days: float | None = None
+    upcoming: list = []
+    found_sd = False
+    found_prd = False
+
+    for pd_lord, pd_start, pd_years in _iter_pds(
+        ctx["ad_lord"], ctx["ad_start"], ctx["ad_years"]
+    ):
+        pd_end = pd_start + timedelta(days=pd_years * 365.25)
+        if pd_end <= ctx["pd_start"]:
+            continue
+
+        for sd_lord, sd_start, sd_end, sd_y in _iter_sds(pd_lord, pd_start, pd_years):
+            # Skip SDs that ended before the current PD began
+            if sd_end <= ctx["pd_start"]:
+                continue
+
+            if sd_start <= now < sd_end and not found_sd:
+                current_sd_lord = sd_lord
+                found_sd = True
+
+                # Drill into PRDs within this SD
+                for prd_lord, prd_start, prd_end, prd_days in _iter_prds(
+                    sd_lord, sd_start, sd_y
+                ):
+                    if prd_start <= now < prd_end:
+                        current_prd_lord = prd_lord
+                        current_prd_start = prd_start
+                        current_prd_end = prd_end
+                        current_prd_days = prd_days
+                        found_prd = True
+                    elif found_prd and len(upcoming) < 5:
+                        upcoming.append(
+                            {
+                                "planet": prd_lord,
+                                "start": prd_start.strftime("%d-%m-%Y"),
+                                "end": prd_end.strftime("%d-%m-%Y"),
+                            }
+                        )
+                    if found_prd and len(upcoming) >= 5:
+                        break
+
+            elif found_prd and len(upcoming) < 5:
+                # Collect PRDs from subsequent SDs to fill up upcoming list
+                for prd_lord, prd_start, prd_end, _prd_days in _iter_prds(
+                    sd_lord, sd_start, sd_y
+                ):
+                    upcoming.append(
+                        {
+                            "planet": prd_lord,
+                            "start": prd_start.strftime("%d-%m-%Y"),
+                            "end": prd_end.strftime("%d-%m-%Y"),
+                        }
+                    )
+                    if len(upcoming) >= 5:
+                        break
+
+            if found_prd and len(upcoming) >= 5:
+                break
+
+        if found_prd and len(upcoming) >= 5:
+            break
+
+    return {
+        "current_mahadasha": ctx["md_lord"],
+        "current_antardasha": ctx["ad_lord"],
+        "current_pratyantar": ctx["pd_lord"],
+        "current_sookshma": current_sd_lord or "Unknown",
+        "current_prana": current_prd_lord or "Unknown",
+        "current_prana_start": (
+            current_prd_start.strftime("%d-%m-%Y") if current_prd_start else ""
+        ),
+        "current_prana_end": (
+            current_prd_end.strftime("%d-%m-%Y") if current_prd_end else ""
+        ),
+        "current_prana_duration_days": round(current_prd_days, 2)
+        if current_prd_days
+        else 0.0,
+        "upcoming_prana": upcoming,
+    }