astrololo/services/logic/app/engine/chart.py

"""Złożenie pełnego horoskopu: pozycje + osie + domy (LOG-01 + LOG-05).

Silnik-agnostyczne: potrzebuje tylko `positions()` oraz (dla osi/domów)
`sidereal()`. Jeśli silnik nie umie policzyć czasu gwiazdowego, zwraca same
pozycje.
"""
from __future__ import annotations

from app.engine import houses as H
from app.engine import zodiac as Z
from app.engine.base import EphemerisEngine
from app.engine.formats import SIGNS, absolute, decimal, in_sign, norm360, sign_index
from app.engine.models import ChartMoment


def _fmt(name: str, lon: float, off: float = 0.0) -> dict:
    lon = norm360(lon - off)
    return {
        "name": name,
        "sign": SIGNS[sign_index(lon)],
        "in_sign": in_sign(lon),
        "decimal": round(lon, 6),
    }


def _shift_pos(pdict: dict, off: float) -> None:
    """Przelicza etykiety pozycji na wybrany zodiak (in-place). off=0 → bez zmian."""
    if not off:
        return
    lon = norm360(pdict["decimal"] - off)
    pdict["sign"] = SIGNS[sign_index(lon)]
    pdict["in_sign"] = in_sign(lon)
    pdict["absolute"] = absolute(lon)
    pdict["decimal"] = decimal(lon)


def build_chart(engine: EphemerisEngine, moment: ChartMoment, house_system: str = H.WHOLE_SIGN,
                lots_method: str = "degree", zodiac: str = Z.TROPICAL) -> dict:
    from app.engine.aspects import find_aspects
    from app.engine.houses import mean_obliquity
    from app.engine.out_of_zodiac import (
        declination,
        find_antiscia,
        find_declination_aspects,
        is_out_of_bounds,
    )

    positions = engine.positions(moment)
    result: dict = {"engine": engine.name, "positions": [p.as_dict() for p in positions]}
    # aspekty liczymy PRZED zmianą zodiaku — kąty między obiektami są niezmiennicze
    result["aspects"] = find_aspects(result["positions"])  # aspekty (LOG-06)

    # Aspekty pozazodiakalne (LOG-07): deklinacja i antyscja liczone na
    # współrzędnych TROPIKALNYCH of-date — deklinacja jest fizyczna (równikowa),
    # a antyscja z definicji tropikalna. Dlatego PRZED przesunięciem na zodiak,
    # z surowych długości/szerokości silnika.
    eps = mean_obliquity(Z.julian_day(moment.when_utc))
    result["obliquity"] = round(eps, 6)
    for pdict, obj in zip(result["positions"], positions):
        dec = declination(obj.longitude, obj.latitude, eps)
        pdict["declination"] = round(dec, 4)
        if is_out_of_bounds(dec, eps):
            pdict["out_of_bounds"] = True
    result["parallels"] = find_declination_aspects(result["positions"])
    result["antiscia"] = find_antiscia(result["positions"])

    # offset zodiaku (LOG-04): syderyczny = ayanamsa, draconic = długość węzła
    node_lon = next((p.longitude for p in positions if p.name == "North Node"), None)
    off = Z.offset(zodiac, Z.julian_day(moment.when_utc), node_lon)
    result["zodiac"] = zodiac
    if zodiac in Z.SIDEREAL:
        result["ayanamsha"] = round(off, 6)
    for pdict in result["positions"]:
        _shift_pos(pdict, off)

    if not hasattr(engine, "sidereal"):
        return result

    ramc, eps = engine.sidereal(moment)
    asc = H.compute_asc(ramc, eps, moment.lat)
    mc = H.compute_mc(ramc, eps)
    system = house_system if house_system in H.SYSTEMS else H.WHOLE_SIGN
    cusp_list = H.cusps(asc, mc, system)   # tropikalne — geometria domów jest niezmiennicza

    result["house_system"] = system
    result["angles"] = {
        "Asc": _fmt("Asc", asc, off),
        "MC": _fmt("MC", mc, off),
        "Dsc": _fmt("Dsc", norm360(asc + 180.0), off),
        "IC": _fmt("IC", norm360(mc + 180.0), off),
    }
    result["cusps"] = [
        {"house": i + 1, "sign": SIGNS[sign_index(norm360(c - off))],
         "in_sign": in_sign(norm360(c - off))}
        for i, c in enumerate(cusp_list)
    ]
    for pdict, obj in zip(result["positions"], positions):
        pdict["house"] = H.assign_house(obj.longitude, cusp_list)  # dom po długości tropikalnej

    # Lots (LOG-08) — wymagają Asc i sekty (dzień/noc)
    from app.engine.firdaria import is_day_birth
    from app.engine.lots import compute_lots

    pts = {p.name: p.longitude for p in positions}
    pts["Asc"] = asc
    day = is_day_birth(pts["Sun"], asc, mc) if "Sun" in pts else True
    result["sect"] = "day" if day else "night"
    result["lots"] = [
        {**lot,
         "longitude": decimal(norm360(lot["longitude"] - off)),   # w wybranym zodiaku
         "sign": SIGNS[sign_index(norm360(lot["longitude"] - off))],
         "in_sign": in_sign(norm360(lot["longitude"] - off)),
         "house": H.assign_house(lot["longitude"], cusp_list)}     # dom po długości tropikalnej
        for lot in compute_lots(pts, day, lots_method)
    ]
    return result