kundali-chart-mcp 0.2.1

package/python/kundali_lib/vedic/char_dasha.py

@@ -0,0 +1,308 @@
+"""Char Dasha (Jaimini): Sign-based dasha system — one of the most important in Jaimini astrology."""
+
+from datetime import datetime, timedelta
+
+from kundali_lib.vedic.constants import RASHIS
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+
+MOVABLE_SIGNS = ["Aries", "Cancer", "Libra", "Capricorn"]
+FIXED_SIGNS = ["Taurus", "Leo", "Scorpio", "Aquarius"]
+DUAL_SIGNS = ["Gemini", "Virgo", "Sagittarius", "Pisces"]
+
+SIGN_LORD: dict[str, str] = {
+    "Aries": "Mars",
+    "Taurus": "Venus",
+    "Gemini": "Mercury",
+    "Cancer": "Moon",
+    "Leo": "Sun",
+    "Virgo": "Mercury",
+    "Libra": "Venus",
+    "Scorpio": "Mars",
+    "Sagittarius": "Jupiter",
+    "Capricorn": "Saturn",
+    "Aquarius": "Saturn",
+    "Pisces": "Jupiter",
+}
+
+# Planets eligible for Atmakaraka (7-karaka system, Rahu included)
+_AK_PLANETS = {"Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn", "Rahu"}
+
+
+# ── Private helpers ───────────────────────────────────────────────────────────
+
+
+def _rotated_signs(start_sign: str) -> list:
+    """Return RASHIS rotated so it begins at start_sign."""
+    idx = RASHIS.index(start_sign)
+    return RASHIS[idx:] + RASHIS[:idx]
+
+
+def _get_atmakaraka(planetary_positions: list) -> tuple:
+    """Return (ak_planet_name, ak_sign, degree_in_sign).
+
+    Atmakaraka = planet with the highest degree within its sign.
+    Rahu's degree is inverted (30 − degree) because it moves retrograde.
+    """
+    best_name = "Sun"
+    best_sign = "Aries"
+    best_raw_degree = 0.0
+    best_eff_degree = -1.0
+
+    for p in planetary_positions:
+        name = p.get("name", "")
+        if name not in _AK_PLANETS:
+            continue
+        raw_deg = p.get("degree", 0.0)  # degree within sign (0–30)
+        eff_deg = (30.0 - raw_deg) if name == "Rahu" else raw_deg
+
+        if eff_deg > best_eff_degree:
+            best_eff_degree = eff_deg
+            best_name = name
+            best_sign = p.get("rashi", "Aries")
+            best_raw_degree = raw_deg
+
+    return best_name, best_sign, best_raw_degree
+
+
+def _planet_sign_map(planetary_positions: list) -> dict[str, str]:
+    """Return {planet_name: rashi} for all planets in the chart."""
+    return {p["name"]: p.get("rashi", "") for p in planetary_positions}
+
+
+def _sign_has_planet(planetary_positions: list) -> dict[str, bool]:
+    """Return {rashi: True} for every sign occupied by at least one planet."""
+    occupied: dict[str, bool] = {}
+    for p in planetary_positions:
+        rashi = p.get("rashi", "")
+        if rashi:
+            occupied[rashi] = True
+    return occupied
+
+
+def _char_years_for_sign(
+    sign: str,
+    sign_idx: int,
+    lord_sign: str,
+    occupied: dict[str, bool],
+    forward: bool,
+) -> int:
+    """Calculate Char Dasha years for one sign.
+
+    Args:
+        sign: The sign being evaluated (e.g. "Aries").
+        sign_idx: 0-based index of sign in RASHIS (0 = Aries … 11 = Pisces).
+        lord_sign: The sign occupied by this sign's lord in the natal chart.
+        occupied: Mapping of which signs are occupied by planets.
+        forward: True → count forward (movable/dual/odd-Narayana); False → count backward.
+
+    Returns:
+        Clamped integer years in [1, 12].
+    """
+    lord_idx = RASHIS.index(lord_sign)
+
+    if forward:
+        distance = (lord_idx - sign_idx) % 12 + 1
+        count = 13 - distance  # lord in same sign → distance=1 → count=12
+    else:
+        count = (sign_idx - lord_idx) % 12 + 1  # lord in same sign → 0%12+1=1
+
+    # Subtract 1 if the 7th sign from this sign has any planet
+    seventh_sign = RASHIS[(sign_idx + 6) % 12]
+    if occupied.get(seventh_sign, False):
+        count -= 1
+
+    return max(1, min(12, count))
+
+
+def _compute_char_dasha_years(planetary_positions: list) -> dict[str, int]:
+    """Calculate Char Dasha years for each of the 12 signs.
+
+    Direction rules:
+    - Movable signs (Aries, Cancer, Libra, Capricorn): count forward
+    - Fixed signs   (Taurus, Leo, Scorpio, Aquarius):   count backward
+    - Dual signs    (Gemini, Virgo, Sagittarius, Pisces): count forward
+    """
+    pmap = _planet_sign_map(planetary_positions)
+    occupied = _sign_has_planet(planetary_positions)
+    sign_years: dict[str, int] = {}
+
+    for i, sign in enumerate(RASHIS):
+        lord = SIGN_LORD[sign]
+        lord_sign = pmap.get(lord)
+
+        if lord_sign is None:
+            # Lord not found — assign a neutral default
+            sign_years[sign] = 7
+            continue
+
+        forward = sign in MOVABLE_SIGNS or sign in DUAL_SIGNS
+        sign_years[sign] = _char_years_for_sign(sign, i, lord_sign, occupied, forward)
+
+    return sign_years
+
+
+def _compute_narayana_years(planetary_positions: list) -> dict[str, int]:
+    """Calculate Narayana Dasha years for each of the 12 signs.
+
+    Direction rules:
+    - Odd signs  (1-based: Aries, Gemini, Leo, Libra, Sagittarius, Aquarius): count forward
+    - Even signs (1-based: Taurus, Cancer, Virgo, Scorpio, Capricorn, Pisces): count backward
+    """
+    pmap = _planet_sign_map(planetary_positions)
+    occupied = _sign_has_planet(planetary_positions)
+    sign_years: dict[str, int] = {}
+
+    for i, sign in enumerate(RASHIS):
+        lord = SIGN_LORD[sign]
+        lord_sign = pmap.get(lord)
+
+        if lord_sign is None:
+            sign_years[sign] = 7
+            continue
+
+        # 0-based even index → 1-based odd sign → forward
+        forward = i % 2 == 0
+        sign_years[sign] = _char_years_for_sign(sign, i, lord_sign, occupied, forward)
+
+    return sign_years
+
+
+def _build_sign_dashas(
+    start_sign: str,
+    fraction_elapsed: float,
+    sign_years: dict[str, int],
+    birth_dt: datetime,
+) -> dict:
+    """Build mahadasha entries for all 12 signs with nested antardashas.
+
+    Args:
+        start_sign: First sign in the dasha sequence.
+        fraction_elapsed: Fraction of the first sign's period already elapsed at birth (0–1).
+        sign_years: {sign: years} map for all 12 signs.
+        birth_dt: Timezone-aware (or naive) birth datetime.
+
+    Returns:
+        dict: mahadashas structure keyed by sign name.
+    """
+    total_years = sum(sign_years.values())
+    sign_seq = _rotated_signs(start_sign)
+
+    result: dict = {}
+    # The first sign's period started (fraction_elapsed * first_sign_years) before birth
+    first_sign_years = sign_years[start_sign]
+    md_cursor = birth_dt - timedelta(days=fraction_elapsed * first_sign_years * 365.25)
+
+    for i, md_sign in enumerate(sign_seq):
+        md_years = sign_years[md_sign]
+        md_days = md_years * 365.25
+
+        md_start = md_cursor
+        md_end = md_start + timedelta(days=md_days)
+        md_cursor = md_end
+
+        display_duration: float = (
+            round((1.0 - fraction_elapsed) * md_years, 4) if i == 0 else float(md_years)
+        )
+
+        # ── Antardashas: 12 sub-signs starting from md_sign, zodiacal order ──
+        result_ads: dict = {}
+        ad_cursor = md_start
+        for ad_sign in _rotated_signs(md_sign):
+            ad_years = (sign_years[ad_sign] / total_years) * md_years
+            ad_days = ad_years * 365.25
+            ad_end = ad_cursor + timedelta(days=ad_days)
+
+            result_ads[ad_sign] = {
+                "start": ad_cursor.strftime("%d-%m-%Y"),
+                "end": ad_end.strftime("%d-%m-%Y"),
+            }
+            ad_cursor = ad_end
+
+        result[md_sign] = {
+            "start": md_start.strftime("%d-%m-%Y"),
+            "end": md_end.strftime("%d-%m-%Y"),
+            "duration_years": display_duration,
+            "antardashas": result_ads,
+        }
+
+    return result
+
+
+# ── Public functions ──────────────────────────────────────────────────────────
+
+
+def get_char_dasha(base_chart: dict, birth_dt: datetime) -> dict:
+    """Calculate Char Dasha (Jaimini sign-based dasha system).
+
+    Starting sign = sign occupied by the Atmakaraka (planet with highest
+    degree within its sign in the natal chart). The sequence then proceeds
+    through all 12 signs in zodiacal order.
+
+    Sub-periods (antardashas) within each sign-dasha rotate through all
+    12 signs starting from the main sign:
+        antardasha_duration = (sub_sign_years / total_years) × main_sign_years
+
+    Args:
+        base_chart: Full birth chart dict from ``build_chart()``.
+        birth_dt: Timezone-aware birth datetime.
+
+    Returns:
+        dict with ``system``, ``atmakaraka``, ``atmakaraka_sign``,
+        ``starting_sign``, ``sign_dasha_years``, and ``mahadashas``.
+    """
+    positions: list = base_chart.get("planetary_positions", [])
+
+    ak_name, ak_sign, ak_degree = _get_atmakaraka(positions)
+    sign_years = _compute_char_dasha_years(positions)
+
+    # Fraction of the first sign's dasha elapsed: AK's degree within its sign / 30
+    fraction_elapsed = ak_degree / 30.0
+
+    mahadashas = _build_sign_dashas(ak_sign, fraction_elapsed, sign_years, birth_dt)
+
+    return {
+        "system": "Char Dasha (Jaimini)",
+        "atmakaraka": ak_name,
+        "atmakaraka_sign": ak_sign,
+        "starting_sign": ak_sign,
+        "sign_dasha_years": sign_years,
+        "mahadashas": mahadashas,
+    }
+
+
+def get_narayana_dasha(base_chart: dict, birth_dt: datetime) -> dict:
+    """Calculate Narayana Dasha (sign-based dasha for worldly and outer circumstances).
+
+    Narayana Dasha uses the Lagna (Ascendant) sign as the starting sign rather
+    than the Atmakaraka's sign. Direction of counting for sign years depends on
+    whether the sign is odd (forward) or even (backward) in the natural zodiac.
+
+    Sub-periods follow the same proportional formula as Char Dasha.
+
+    Args:
+        base_chart: Full birth chart dict from ``build_chart()``.
+        birth_dt: Timezone-aware birth datetime.
+
+    Returns:
+        dict with ``system``, ``lagna_sign``, ``starting_sign``,
+        ``sign_dasha_years``, and ``mahadashas``.
+    """
+    positions: list = base_chart.get("planetary_positions", [])
+    ascendant: dict = base_chart.get("ascendant", {})
+
+    lagna_sign: str = ascendant.get("rashi", "Aries")
+    # Degree of Lagna within its sign determines fraction elapsed in first period
+    lagna_degree: float = ascendant.get("degree", 0.0)  # 0–30
+    fraction_elapsed = lagna_degree / 30.0
+
+    sign_years = _compute_narayana_years(positions)
+    mahadashas = _build_sign_dashas(lagna_sign, fraction_elapsed, sign_years, birth_dt)
+
+    return {
+        "system": "Narayana Dasha",
+        "lagna_sign": lagna_sign,
+        "starting_sign": lagna_sign,
+        "sign_dasha_years": sign_years,
+        "mahadashas": mahadashas,
+    }

package/python/kundali_lib/vedic/chart.py

@@ -0,0 +1,126 @@
+"""Build full birth chart from datetime and location."""
+
+from datetime import datetime
+
+import pytz
+import swisseph as swe
+
+from kundali_lib.vedic.ayanamsa import (
+    _SIDM_MAP,
+    DEFAULT_AYANAMSA,
+    DEFAULT_HOUSE_SYSTEM,
+)
+from kundali_lib.vedic.constants import PLANET_IDS
+from kundali_lib.vedic.houses import (
+    calc_houses_sidereal_with_system,
+    houses_dict_and_degrees,
+)
+from kundali_lib.vedic.planets import calc_planet_position
+from kundali_lib.vedic.zodiac import (
+    get_nakshatra,
+    get_nakshatra_lord,
+    get_rashi,
+    get_rashi_lord,
+    position_dict,
+)
+
+# PLANET_NAMES is iteration order for planets
+PLANET_NAMES = list(PLANET_IDS.keys())
+
+
+def _jd_ut(birth_dt: datetime, timezone: str) -> float:
+    if timezone:
+        tz = pytz.timezone(timezone)
+        local = tz.localize(birth_dt)
+        utc = local.astimezone(pytz.UTC)
+    else:
+        utc = pytz.UTC.localize(birth_dt)
+    h = utc.hour + utc.minute / 60.0 + utc.second / 3600.0
+    return swe.julday(utc.year, utc.month, utc.day, h)
+
+
+def _assign_houses(planetary_positions: list[dict], asc_lon: float) -> None:
+    asc_rashi_i = int(asc_lon / 30) % 12
+    for p in planetary_positions:
+        rashi_i = int(p["longitude"] / 30) % 12
+        p["house"] = (rashi_i - asc_rashi_i) % 12 + 1
+
+
+def _ayanamsa_name(mode_key: str) -> str:
+    try:
+        const = _SIDM_MAP.get(mode_key, _SIDM_MAP["lahiri"])
+        name = (swe.get_ayanamsa_name(const) or mode_key.title()).strip()
+        return name or "Lahiri"
+    except Exception:
+        return "Lahiri"
+
+
+def build_chart(
+    name: str,
+    birth_dt: datetime,
+    lat: float,
+    lon: float,
+    timezone: str,
+    ayanamsa_mode: str | None = None,
+    house_system: str | None = None,
+) -> dict:
+    """Full chart: planets, houses, ascendant, ayanamsa.
+
+    Args:
+        ayanamsa_mode: Key like 'lahiri', 'raman', 'krishnamurti', etc. Default 'lahiri'.
+        house_system: Single-char code like 'P' (Placidus), 'K' (Koch), 'E' (Equal), etc. Default 'P'.
+    """
+    swe.set_ephe_path(None)
+    mode_key = (ayanamsa_mode or DEFAULT_AYANAMSA).lower().replace("-", "_")
+    if mode_key not in _SIDM_MAP:
+        raise ValueError(
+            f"Unsupported ayanamsa_mode '{ayanamsa_mode}'. Use list_ayanamsa_modes to see options."
+        )
+    swe.set_sid_mode(_SIDM_MAP[mode_key])
+
+    hs = (house_system or DEFAULT_HOUSE_SYSTEM).upper()[:1]
+
+    jd = _jd_ut(birth_dt, timezone)
+    planetary_positions = [calc_planet_position(pname, jd) for pname in PLANET_NAMES]
+    cusps, ascmc = calc_houses_sidereal_with_system(jd, lat, lon, hs)
+    asc_lon = cusps[0]
+    mc_lon = ascmc[1] if len(ascmc) > 1 else cusps[9]
+
+    _assign_houses(planetary_positions, asc_lon)
+    houses, house_cusp_degrees = houses_dict_and_degrees(cusps)
+    ascendant = {"longitude": asc_lon, **position_dict(asc_lon)}
+    moon_pos = next(p for p in planetary_positions if p["name"] == "Moon")
+    sun_pos = next(p for p in planetary_positions if p["name"] == "Sun")
+    ayanamsa = swe.get_ayanamsa_ut(jd)
+
+    return {
+        "name": name,
+        "birth_details": {
+            "datetime": birth_dt.isoformat(),
+            "latitude": lat,
+            "longitude": lon,
+            "timezone": timezone,
+        },
+        "planetary_positions": planetary_positions,
+        "houses": houses,
+        "house_cusp_degrees": house_cusp_degrees,
+        "ascendant": ascendant,
+        "mc_longitude": round(mc_lon, 4),
+        "moon_sign": moon_pos["rashi"],
+        "sun_sign": sun_pos["rashi"],
+        "ayanamsa": round(ayanamsa, 4),
+        "ayanamsa_name": _ayanamsa_name(mode_key),
+        "ayanamsa_mode": mode_key,
+        "house_system": hs,
+    }
+
+
+def get_transit_positions(dt_utc: datetime) -> list[dict]:
+    """Sidereal (Lahiri) planetary positions for a given UTC moment (e.g. 'now' for transits)."""
+    swe.set_ephe_path(None)
+    swe.set_sid_mode(_SIDM_MAP["lahiri"])
+    if dt_utc.tzinfo is None:
+        dt_utc = pytz.UTC.localize(dt_utc)
+    h = dt_utc.hour + dt_utc.minute / 60.0 + dt_utc.second / 3600.0
+    jd = swe.julday(dt_utc.year, dt_utc.month, dt_utc.day, h)
+    return [calc_planet_position(pname, jd) for pname in PLANET_NAMES]