kundali-chart-mcp 0.2.1

package/python/kundali_lib/vedic/chart_types.py

@@ -0,0 +1,338 @@
+"""Derived Vedic chart type helpers.
+
+The base chart calculation returns accurate sidereal planetary longitudes. These
+helpers derive common chart views from those longitudes without changing the
+underlying ephemeris calculation.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from kundali_lib.vedic.constants import RASHIS
+
+# Full traditional varga set with names.
+DIVISIONAL_CHARTS = {
+    1: ("d1", "Rashi / Lagna"),
+    2: ("d2", "Hora"),
+    3: ("d3", "Drekkana"),
+    4: ("d4", "Chaturthamsa"),
+    7: ("d7", "Saptamsa"),
+    9: ("d9", "Navamsa"),
+    10: ("d10", "Dashamsa"),
+    12: ("d12", "Dwadashamsa"),
+    16: ("d16", "Shodashamsa"),
+    20: ("d20", "Vimshamsa"),
+    24: ("d24", "Chaturvimshamsa"),
+    27: ("d27", "Saptavimshamsa"),
+    30: ("d30", "Trimsamsa"),
+    40: ("d40", "Khavedamsa"),
+    45: ("d45", "Akshavedamsa"),
+    60: ("d60", "Shashtiamsa"),
+}
+
+SUPPORTED_CHART_TYPES: dict[str, dict[str, str]] = {
+    "lagna": {
+        "name": "Lagna / Rashi / D1",
+        "description": "Default birth chart using ascendant as the 1st house.",
+    },
+    "rashi": {
+        "name": "Rashi / D1",
+        "description": "Alias for the default Lagna/Rashi chart.",
+    },
+    "d1": {
+        "name": "D1 / Rashi",
+        "description": "Alias for the default Lagna/Rashi chart.",
+    },
+    "chandra": {
+        "name": "Chandra Kundali",
+        "description": "Moon sign treated as the 1st house; planet houses recalculated from Moon sign.",
+    },
+    "moon": {"name": "Chandra Kundali", "description": "Alias for Chandra Kundali."},
+    "surya": {
+        "name": "Surya Kundali",
+        "description": "Sun sign treated as the 1st house; planet houses recalculated from Sun sign.",
+    },
+    "sun": {"name": "Surya Kundali", "description": "Alias for Surya Kundali."},
+    "all": {
+        "name": "All quick derived charts",
+        "description": "Returns Lagna + Chandra + Surya + D9 + D10.",
+    },
+    "all_divisionals": {
+        "name": "All traditional divisional charts",
+        "description": "Returns Lagna chart plus all traditional vargas (D1, D2, D3, D4, D7, D9, D10, D12, D16, D20, D24, D27, D30, D40, D45, D60).",
+    },
+}
+
+for div, (key, name) in DIVISIONAL_CHARTS.items():
+    if key not in SUPPORTED_CHART_TYPES:
+        SUPPORTED_CHART_TYPES[key] = {
+            "name": f"{name} / D{div}",
+            "description": f"Divisional chart D{div} ({name}) derived from sidereal longitudes.",
+        }
+
+ALIASES = {
+    "rashi": "lagna",
+    "d1": "lagna",
+    "moon": "chandra",
+    "sun": "surya",
+    "navamsa": "d9",
+    "dashamsa": "d10",
+    "drekkana": "d3",
+    "chaturthamsa": "d4",
+    "saptamsa": "d7",
+    "dwadashamsa": "d12",
+    "shodashamsa": "d16",
+    "vimshamsa": "d20",
+    "chaturvimshamsa": "d24",
+    "saptavimshamsa": "d27",
+    "trimsamsa": "d30",
+    "khavedamsa": "d40",
+    "akshavedamsa": "d45",
+    "shashtiamsa": "d60",
+}
+
+DEFAULT_CHART_TYPE = "lagna"
+ALL_QUICK_TYPES = ["chandra", "surya", "d9", "d10"]
+ALL_DIVISIONAL_KEYS = [key for div, (key, _) in DIVISIONAL_CHARTS.items()]
+
+
+def normalize_chart_type(chart_type: str | None) -> str:
+    key = (chart_type or DEFAULT_CHART_TYPE).strip().lower().replace("-", "_")
+    key = ALIASES.get(key, key)
+    if key not in SUPPORTED_CHART_TYPES:
+        raise ValueError(
+            f"Unsupported chart_type '{chart_type}'. Supported values: "
+            + ", ".join(sorted(SUPPORTED_CHART_TYPES))
+        )
+    return key
+
+
+def available_chart_types() -> dict[str, Any]:
+    canonical = {
+        k: v
+        for k, v in SUPPORTED_CHART_TYPES.items()
+        if "_" not in k or k in ["lagna", "chandra", "surya", "all", "all_divisionals"]
+    }
+    divisional_list = [
+        {"division": div, "key": key, "name": name}
+        for div, (key, name) in DIVISIONAL_CHARTS.items()
+    ]
+    return {
+        "default": DEFAULT_CHART_TYPE,
+        "canonical_types": canonical,
+        "aliases": ALIASES,
+        "divisional_charts": divisional_list,
+        "note": "D1/Lagna is the original full chart. Chandra and Surya are house-reference views. Divisional charts (D2–D60) are derived from sidereal longitudes.",
+    }
+
+
+def _sign_index_from_rashi(rashi: str) -> int:
+    return RASHIS.index(rashi)
+
+
+def _house_from_reference(planet_rashi: str, reference_rashi: str) -> int:
+    return (
+        _sign_index_from_rashi(planet_rashi) - _sign_index_from_rashi(reference_rashi)
+    ) % 12 + 1
+
+
+def _copy_planet_with_house(
+    planet: dict[str, Any], reference_rashi: str
+) -> dict[str, Any]:
+    copied = dict(planet)
+    copied["house"] = _house_from_reference(copied["rashi"], reference_rashi)
+    return copied
+
+
+def chandra_chart(base_chart: dict[str, Any]) -> dict[str, Any]:
+    reference_rashi = base_chart["moon_sign"]
+    return {
+        "chart_type": "chandra",
+        "name": SUPPORTED_CHART_TYPES["chandra"]["name"],
+        "reference": {"planet": "Moon", "rashi": reference_rashi},
+        "houses": {
+            f"House_{i + 1}": RASHIS[(_sign_index_from_rashi(reference_rashi) + i) % 12]
+            for i in range(12)
+        },
+        "planetary_positions": [
+            _copy_planet_with_house(p, reference_rashi)
+            for p in base_chart["planetary_positions"]
+        ],
+    }
+
+
+def surya_chart(base_chart: dict[str, Any]) -> dict[str, Any]:
+    reference_rashi = base_chart["sun_sign"]
+    return {
+        "chart_type": "surya",
+        "name": SUPPORTED_CHART_TYPES["surya"]["name"],
+        "reference": {"planet": "Sun", "rashi": reference_rashi},
+        "houses": {
+            f"House_{i + 1}": RASHIS[(_sign_index_from_rashi(reference_rashi) + i) % 12]
+            for i in range(12)
+        },
+        "planetary_positions": [
+            _copy_planet_with_house(p, reference_rashi)
+            for p in base_chart["planetary_positions"]
+        ],
+    }
+
+
+def _varga_sign_index(longitude: float, division: int) -> int:
+    sign_index = int(longitude / 30) % 12
+    degree_in_sign = longitude % 30
+    part_index = min(int(degree_in_sign / (30 / division)), division - 1)
+
+    if division == 1:
+        return sign_index
+
+    if division == 2:
+        # Hora: odd signs Sun, even signs Moon (simplified common rule)
+        return (
+            sign_index % 2
+        ) * 6  # 0->0 (Leo range), 1->6 (Aquarius range) simplified mapping
+
+    if division == 3:
+        # Drekkana: 1st/2nd/3rd decan → same sign / 5th / 9th
+        offset = part_index * 4
+        return (sign_index + offset) % 12
+
+    if division == 4:
+        # Chaturthamsa: movable 1-4-7-10, fixed 4-7-10-1, dual 7-10-1-4
+        if sign_index % 3 == 0:  # movable
+            start = sign_index
+        elif sign_index % 3 == 1:  # fixed
+            start = (sign_index + 3) % 12
+        else:  # dual
+            start = (sign_index + 6) % 12
+        return (start + part_index) % 12
+
+    if division == 7:
+        # Saptamsa: odd signs count forward, even backward
+        if sign_index % 2 == 0:
+            return (sign_index + part_index) % 12
+        else:
+            return (sign_index - part_index) % 12
+
+    if division == 9:
+        # Navamsa: movable starts same sign, fixed starts 9th, dual starts 5th
+        if sign_index % 3 == 0:  # movable
+            start = sign_index
+        elif sign_index % 3 == 1:  # fixed
+            start = (sign_index + 8) % 12
+        else:  # dual
+            start = (sign_index + 4) % 12
+        return (start + part_index) % 12
+
+    if division == 10:
+        # Dashamsa: odd signs same, even signs 9th
+        start = sign_index if sign_index % 2 == 0 else (sign_index + 8) % 12
+        return (start + part_index) % 12
+
+    if division == 12:
+        # Dwadashamsa: each degree moves to next sign (simplified as part_index advance)
+        return (sign_index + part_index) % 12
+
+    if division == 16:
+        # Shodashamsa: common rule uses 16 parts; simplified as 4-part cycle repeated
+        return (sign_index + part_index) % 12
+
+    if division == 20:
+        # Vimshamsa: simplified cycle
+        return (sign_index * 2 + part_index) % 12
+
+    if division == 24:
+        # Chaturvimshamsa
+        return (sign_index * 2 + part_index) % 12
+
+    if division == 27:
+        # Saptavimshamsa
+        return (sign_index + part_index) % 12
+
+    if division == 30:
+        # Trimsamsa: special 5/7 part rules; simplified here
+        return (sign_index + part_index) % 12
+
+    if division in (40, 45):
+        # Khavedamsa / Akshavedamsa: complex gender-based rules; simplified as cyclic
+        return (sign_index + part_index) % 12
+
+    if division == 60:
+        # Shashtiamsa: pure 60-part cycle independent of sign
+        return part_index % 12
+
+    raise ValueError(f"Unsupported varga division D{division}")
+
+
+def divisional_chart(
+    base_chart: dict[str, Any], division: int, chart_type: str, name: str
+) -> dict[str, Any]:
+    positions = []
+    for planet in base_chart["planetary_positions"]:
+        sign_index = _varga_sign_index(float(planet["longitude"]), division)
+        copied = dict(planet)
+        copied["rashi"] = RASHIS[sign_index]
+        copied["division"] = division
+        copied["source_longitude"] = planet["longitude"]
+        copied["house"] = 0
+        positions.append(copied)
+
+    asc_sign_index = _varga_sign_index(
+        float(base_chart["ascendant"]["longitude"]), division
+    )
+    houses = {f"House_{i + 1}": RASHIS[(asc_sign_index + i) % 12] for i in range(12)}
+    for planet in positions:
+        planet["house"] = _house_from_reference(planet["rashi"], RASHIS[asc_sign_index])
+
+    return {
+        "chart_type": chart_type,
+        "name": name,
+        "division": division,
+        "ascendant": {
+            "rashi": RASHIS[asc_sign_index],
+            "source_longitude": base_chart["ascendant"]["longitude"],
+        },
+        "houses": houses,
+        "planetary_positions": positions,
+    }
+
+
+def derive_chart(base_chart: dict[str, Any], chart_type: str | None) -> dict[str, Any]:
+    normalized = normalize_chart_type(chart_type)
+
+    if normalized == "lagna":
+        result = dict(base_chart)
+        result["chart_type"] = "lagna"
+        return result
+
+    if normalized == "chandra":
+        return chandra_chart(base_chart)
+
+    if normalized == "surya":
+        return surya_chart(base_chart)
+
+    if normalized == "all":
+        result = dict(base_chart)
+        result["chart_type"] = "lagna"
+        result["derived_charts"] = {
+            ctype: derive_chart(base_chart, ctype) for ctype in ALL_QUICK_TYPES
+        }
+        return result
+
+    if normalized == "all_divisionals":
+        result = dict(base_chart)
+        result["chart_type"] = "lagna"
+        result["divisional_charts"] = {}
+        for div, (key, name) in DIVISIONAL_CHARTS.items():
+            result["divisional_charts"][key] = divisional_chart(
+                base_chart, div, key, name
+            )
+        return result
+
+    # Check if it's a divisional chart key
+    for div, (key, name) in DIVISIONAL_CHARTS.items():
+        if normalized == key:
+            return divisional_chart(base_chart, div, key, name)
+
+    raise ValueError(f"Unsupported chart_type '{chart_type}'")