kundali-chart-mcp 0.2.1

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

@@ -0,0 +1,482 @@
+"""Tajaka Yogas: special yogas in annual charts (Varshaphal) based on Persian/Tajika system."""
+
+from __future__ import annotations
+
+from kundali_lib.vedic.constants import RASHI_LORDS, RASHIS
+
+# ---------------------------------------------------------------------------
+# Reference data
+# ---------------------------------------------------------------------------
+
+RASHI_LORDS_MAP: dict[str, str] = {r: RASHI_LORDS[i] for i, r in enumerate(RASHIS)}
+
+# Approximate daily mean motion (degrees/day) used to determine faster vs slower planet.
+MEAN_DAILY_MOTION: dict[str, float] = {
+    "Moon": 13.2,
+    "Mercury": 1.38,
+    "Venus": 1.2,
+    "Sun": 0.985,
+    "Mars": 0.524,
+    "Jupiter": 0.083,
+    "Saturn": 0.034,
+    "Rahu": -0.053,
+    "Ketu": -0.053,
+}
+
+DUSTHANA_HOUSES = {6, 8, 12}
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_planet(positions: list[dict], name: str) -> dict | None:
+    for p in positions:
+        if p["name"] == name:
+            return p
+    return None
+
+
+def _angular_diff(a: float, b: float) -> float:
+    """Signed difference (a − b) normalised to [−180, 180]."""
+    diff = (a - b) % 360.0
+    if diff > 180.0:
+        diff -= 360.0
+    return diff
+
+
+def _planet_speed(planet: dict) -> float:
+    """Return absolute daily motion; prefer actual speed field if present."""
+    return abs(
+        planet.get("speed_longitude", MEAN_DAILY_MOTION.get(planet["name"], 0.5))
+    )
+
+
+def _house_of_sign(sign: str, asc_sign: str) -> int:
+    """Return the house number that a given sign falls in, relative to the ascendant sign."""
+    asc_idx = RASHIS.index(asc_sign)
+    sign_idx = RASHIS.index(sign)
+    return (sign_idx - asc_idx) % 12 + 1
+
+
+def _sign_of_house(house: int, asc_sign: str) -> str:
+    asc_idx = RASHIS.index(asc_sign)
+    return RASHIS[(asc_idx + house - 1) % 12]
+
+
+def _planet_strength(planet: dict, varshaphal_chart: dict) -> str:
+    """Rough strength assessment for a planet in the Varshaphal chart."""
+    name = planet["name"]
+    rashi = planet.get("rashi", "")
+    house = planet.get("house", 0)
+
+    from kundali_lib.vedic.yogas import (  # local import to avoid cycles
+        DEBILITATION,
+        EXALTATION,
+    )
+
+    if rashi == EXALTATION.get(name):
+        return "Exalted (Strong)"
+    if rashi == DEBILITATION.get(name):
+        return "Debilitated (Weak)"
+    if RASHI_LORDS_MAP.get(rashi) == name:
+        return "Own sign (Strong)"
+    if house in {1, 4, 7, 10}:
+        return "Angular (Moderate-Strong)"
+    if house in {6, 8, 12}:
+        return "Dusthana (Weak)"
+    return "Moderate"
+
+
+# ---------------------------------------------------------------------------
+# Yoga checkers
+# ---------------------------------------------------------------------------
+
+
+def _check_ithasala(varshaphal_positions: list[dict], asc_sign: str) -> list[dict]:
+    """Ithasala (Approach) yoga: faster planet approaching slower one within 13°."""
+    results = []
+    planets = [p for p in varshaphal_positions if p["name"] not in ("Rahu", "Ketu")]
+
+    checked: set[frozenset] = set()
+    for i, p1 in enumerate(planets):
+        for p2 in planets[i + 1 :]:
+            pair = frozenset([p1["name"], p2["name"]])
+            if pair in checked:
+                continue
+            checked.add(pair)
+
+            speed1 = _planet_speed(p1)
+            speed2 = _planet_speed(p2)
+
+            faster, slower = (p1, p2) if speed1 >= speed2 else (p2, p1)
+            lon_f = faster["longitude"]
+            lon_s = slower["longitude"]
+            diff = _angular_diff(lon_s, lon_f)  # positive → slower is ahead of faster
+
+            if 0 < diff <= 13:
+                yoga_type = "Poorna Ithasala" if diff <= 1 else "Ithasala"
+                results.append(
+                    {
+                        "name": yoga_type,
+                        "present": True,
+                        "planets": [faster["name"], slower["name"]],
+                        "orb": round(diff, 2),
+                        "description": (
+                            f"{faster['name']} is approaching {slower['name']} "
+                            f"(separation {round(diff, 2)}°)."
+                        ),
+                        "effect": "The matter will come to pass — good results",
+                    }
+                )
+    return results
+
+
+def _check_ishrafa(varshaphal_positions: list[dict]) -> list[dict]:
+    """Ishrafa (Separation) yoga: faster planet has just passed the slower one within 13°."""
+    results = []
+    planets = [p for p in varshaphal_positions if p["name"] not in ("Rahu", "Ketu")]
+
+    checked: set[frozenset] = set()
+    for i, p1 in enumerate(planets):
+        for p2 in planets[i + 1 :]:
+            pair = frozenset([p1["name"], p2["name"]])
+            if pair in checked:
+                continue
+            checked.add(pair)
+
+            speed1 = _planet_speed(p1)
+            speed2 = _planet_speed(p2)
+            faster, slower = (p1, p2) if speed1 >= speed2 else (p2, p1)
+            lon_f = faster["longitude"]
+            lon_s = slower["longitude"]
+            diff = _angular_diff(
+                lon_f, lon_s
+            )  # positive → faster has moved past slower
+
+            if 0 < diff <= 13:
+                results.append(
+                    {
+                        "name": "Ishrafa",
+                        "present": True,
+                        "planets": [faster["name"], slower["name"]],
+                        "orb": round(diff, 2),
+                        "description": (
+                            f"{faster['name']} has already passed {slower['name']} "
+                            f"(separation {round(diff, 2)}°)."
+                        ),
+                        "effect": "Matter will not succeed, past opportunity missed",
+                    }
+                )
+    return results
+
+
+def _check_mutthasila(varshaphal_positions: list[dict], asc_sign: str) -> list[dict]:
+    """Mutthasila yoga: a third planet creates connection between Lagna lord and another."""
+    results = []
+    lagna_lord_name = RASHI_LORDS_MAP.get(asc_sign)
+    if not lagna_lord_name:
+        return results
+
+    lagna_lord = _get_planet(varshaphal_positions, lagna_lord_name)
+    if not lagna_lord:
+        return results
+
+    for connector in varshaphal_positions:
+        if connector["name"] in (lagna_lord_name, "Rahu", "Ketu"):
+            continue
+        for target in varshaphal_positions:
+            if target["name"] in (lagna_lord_name, connector["name"], "Rahu", "Ketu"):
+                continue
+            diff_lc = abs(
+                _angular_diff(connector["longitude"], lagna_lord["longitude"])
+            )
+            diff_ct = abs(_angular_diff(target["longitude"], connector["longitude"]))
+            if diff_lc <= 13 and diff_ct <= 13:
+                results.append(
+                    {
+                        "name": "Mutthasila",
+                        "present": True,
+                        "planets": [lagna_lord_name, connector["name"], target["name"]],
+                        "orb": round(max(diff_lc, diff_ct), 2),
+                        "description": (
+                            f"{connector['name']} connects {lagna_lord_name} "
+                            f"and {target['name']} indirectly."
+                        ),
+                        "effect": "Results come through an intermediary",
+                    }
+                )
+    return results
+
+
+def _check_nakta(varshaphal_positions: list[dict]) -> list[dict]:
+    """Nakta yoga: Moon collects light between two planets."""
+    results = []
+    moon = _get_planet(varshaphal_positions, "Moon")
+    if not moon:
+        return results
+
+    moon_lon = moon["longitude"]
+    others = [
+        p for p in varshaphal_positions if p["name"] not in ("Moon", "Rahu", "Ketu")
+    ]
+
+    for i, p1 in enumerate(others):
+        for p2 in others[i + 1 :]:
+            lon1, lon2 = p1["longitude"], p2["longitude"]
+            lo, hi = (lon1, lon2) if lon1 <= lon2 else (lon2, lon1)
+            if lo <= moon_lon <= hi or (hi - lo > 180 and not (lo <= moon_lon <= hi)):
+                diff = abs(hi - lo)
+                if diff <= 30:  # Moon collects within a reasonable arc
+                    results.append(
+                        {
+                            "name": "Nakta",
+                            "present": True,
+                            "planets": [p1["name"], "Moon", p2["name"]],
+                            "description": (
+                                f"Moon is between {p1['name']} and {p2['name']}, "
+                                f"collecting light."
+                            ),
+                            "effect": "Results come slowly through intermediary help",
+                        }
+                    )
+    return results
+
+
+def _check_yamaya(varshaphal_positions: list[dict], birth_chart: dict) -> list[dict]:
+    """Yamaya yoga: planet within 1° of its natal position in Varshaphal."""
+    results = []
+    natal_positions = birth_chart.get("planetary_positions", [])
+    for vp in varshaphal_positions:
+        for np_ in natal_positions:
+            if vp["name"] == np_["name"]:
+                diff = abs(_angular_diff(vp["longitude"], np_["longitude"]))
+                if diff <= 1.0:
+                    results.append(
+                        {
+                            "name": "Yamaya",
+                            "present": True,
+                            "planets": [vp["name"]],
+                            "orb": round(diff, 2),
+                            "description": (
+                                f"{vp['name']} is within 1° of its natal position "
+                                f"in the Varshaphal chart."
+                            ),
+                            "effect": f"Strong year for matters ruled by {vp['name']}",
+                        }
+                    )
+    return results
+
+
+def _check_duphali_kuttha(
+    varshaphal_positions: list[dict], asc_sign: str
+) -> list[dict]:
+    """Duphali Kuttha: Varsha Lagna lord in dusthana and weak."""
+    results = []
+    lagna_lord_name = RASHI_LORDS_MAP.get(asc_sign)
+    if not lagna_lord_name:
+        return results
+    ll = _get_planet(varshaphal_positions, lagna_lord_name)
+    if not ll:
+        return results
+    house = ll.get("house", 0)
+    strength = _planet_strength(ll, {})
+    if house in DUSTHANA_HOUSES and "Weak" in strength:
+        results.append(
+            {
+                "name": "Duphali Kuttha",
+                "present": True,
+                "planets": [lagna_lord_name],
+                "description": (
+                    f"Varsha Lagna lord {lagna_lord_name} is in house {house} "
+                    f"(dusthana) and {strength}."
+                ),
+                "effect": "Difficult year",
+            }
+        )
+    return results
+
+
+def _check_tambira(muntha_house: int) -> list[dict]:
+    """Tambira yoga: Muntha in dusthana (6, 8, 12)."""
+    if muntha_house in DUSTHANA_HOUSES:
+        return [
+            {
+                "name": "Tambira",
+                "present": True,
+                "planets": [],
+                "description": f"Muntha is in house {muntha_house} (dusthana).",
+                "effect": "Health challenges and obstacles during the year",
+            }
+        ]
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Year-quality assessment
+# ---------------------------------------------------------------------------
+
+
+def _assess_year_quality(
+    yogas: list[dict], muntha_house: int, lagna_lord_strong: bool
+) -> str:
+    names = [y["name"] for y in yogas]
+    score = 0
+    if "Poorna Ithasala" in names:
+        score += 3
+    if "Ithasala" in names:
+        score += 2
+    if "Yamaya" in names:
+        score += 2
+    if "Mutthasila" in names:
+        score += 1
+    if "Nakta" in names:
+        score += 1
+    if "Ishrafa" in names:
+        score -= 2
+    if "Duphali Kuttha" in names:
+        score -= 3
+    if "Tambira" in names:
+        score -= 2
+    if muntha_house in {1, 4, 7, 10}:
+        score += 1
+    if muntha_house in DUSTHANA_HOUSES:
+        score -= 1
+    if lagna_lord_strong:
+        score += 1
+
+    if score >= 4:
+        return "Excellent"
+    if score >= 2:
+        return "Good"
+    if score >= -1:
+        return "Average"
+    return "Difficult"
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def get_tajaka_analysis(
+    birth_chart: dict,
+    varshaphal_chart: dict,
+    year_of_life: int,
+) -> dict:
+    """Analyse Tajaka yogas for a Varshaphal (Solar Return) chart.
+
+    Args:
+        birth_chart:      Output of ``build_chart()`` for the native's birth.
+        varshaphal_chart: Output of ``get_varshaphal()``; the ``varshaphal_chart``
+                          sub-dict (containing ``planetary_positions``, ``houses``,
+                          ``ascendant``, …).
+        year_of_life:     Solar return number (e.g. 26 for the 26th year).
+
+    Returns:
+        dict with Muntha details, Munthesh, all detected Tajaka yogas, year
+        quality assessment, and a brief summary.
+    """
+    # ── Accept either the top-level get_varshaphal() output or the inner chart ─
+    if "varshaphal_chart" in varshaphal_chart:
+        vp = varshaphal_chart["varshaphal_chart"]
+    else:
+        vp = varshaphal_chart
+
+    vp_positions: list[dict] = vp.get("planetary_positions", [])
+    asc_info: dict = vp.get("ascendant", {})
+    asc_sign: str = asc_info.get("rashi", RASHIS[0])
+
+    # ── Muntha ────────────────────────────────────────────────────────────────
+    birth_asc_sign: str = birth_chart.get("ascendant", {}).get("rashi", RASHIS[0])
+    birth_asc_idx = RASHIS.index(birth_asc_sign)
+    muntha_idx = (birth_asc_idx + year_of_life) % 12
+    muntha_sign = RASHIS[muntha_idx]
+    muntha_house = _house_of_sign(muntha_sign, asc_sign)
+    muntha_lord_name = RASHI_LORDS_MAP[muntha_sign]
+
+    muntha_significance_map = {
+        1: "Self, health, vitality — very prominent year",
+        2: "Finances, family, speech",
+        3: "Courage, siblings, short travel",
+        4: "Home, mother, property",
+        5: "Children, creativity, intellect",
+        6: "Enemies, disease, service",
+        7: "Partnerships, marriage, business",
+        8: "Obstacles, transformation, longevity",
+        9: "Luck, dharma, father, long travel",
+        10: "Career, reputation, authority — prominent year",
+        11: "Gains, social network, fulfilment",
+        12: "Losses, expenditure, spirituality",
+    }
+    muntha_significance = muntha_significance_map.get(muntha_house, "")
+
+    muntha_lord_planet = _get_planet(vp_positions, muntha_lord_name)
+    muntha_lord_house = muntha_lord_planet.get("house", 0) if muntha_lord_planet else 0
+    muntha_lord_strength = (
+        _planet_strength(muntha_lord_planet, vp) if muntha_lord_planet else "Unknown"
+    )
+
+    # ── Lagna lord for Duphali Kuttha check ──────────────────────────────────
+    lagna_lord_name = RASHI_LORDS_MAP.get(asc_sign, "")
+    lagna_lord_planet = _get_planet(vp_positions, lagna_lord_name)
+    lagna_lord_strong = (
+        "Strong" in _planet_strength(lagna_lord_planet, vp)
+        if lagna_lord_planet
+        else False
+    )
+
+    # ── Yoga detection ────────────────────────────────────────────────────────
+    yogas: list[dict] = []
+    yogas.extend(_check_ithasala(vp_positions, asc_sign))
+    yogas.extend(_check_ishrafa(vp_positions))
+    yogas.extend(_check_mutthasila(vp_positions, asc_sign))
+    yogas.extend(_check_nakta(vp_positions))
+    yogas.extend(_check_yamaya(vp_positions, birth_chart))
+    yogas.extend(_check_duphali_kuttha(vp_positions, asc_sign))
+    yogas.extend(_check_tambira(muntha_house))
+
+    # Normalise yoga list to match the requested output schema
+    normalised_yogas = []
+    for y in yogas:
+        normalised_yogas.append(
+            {
+                "name": y["name"],
+                "present": y["present"],
+                "description": y["description"],
+                "effect": y["effect"],
+            }
+        )
+
+    # ── Year quality ──────────────────────────────────────────────────────────
+    year_quality = _assess_year_quality(yogas, muntha_house, lagna_lord_strong)
+
+    # ── Summary ───────────────────────────────────────────────────────────────
+    yoga_names = [y["name"] for y in yogas]
+    summary_parts = [
+        f"Year {year_of_life} Varshaphal analysis.",
+        f"Muntha is in {muntha_sign} (house {muntha_house}): {muntha_significance}.",
+        f"Munthesh ({muntha_lord_name}) is in house {muntha_lord_house} — {muntha_lord_strength}.",
+    ]
+    if yoga_names:
+        summary_parts.append(f"Active Tajaka yogas: {', '.join(yoga_names)}.")
+    summary_parts.append(f"Overall year quality: {year_quality}.")
+    summary = " ".join(summary_parts)
+
+    return {
+        "muntha": {
+            "sign": muntha_sign,
+            "house_in_varshaphal": muntha_house,
+            "lord": muntha_lord_name,
+            "significance": muntha_significance,
+        },
+        "munthesh": {
+            "planet": muntha_lord_name,
+            "varshaphal_house": muntha_lord_house,
+            "strength": muntha_lord_strength,
+        },
+        "yogas": normalised_yogas,
+        "year_quality": year_quality,
+        "summary": summary,
+    }