natal-chart 0.1.0__py3-none-any.whl

natal_chart/__init__.py

@@ -0,0 +1,42 @@
+"""natal-chart: tropical natal chart math on NASA JPL ephemerides (via Skyfield).
+
+>>> from natal_chart import chart, aspects
+>>> c = chart("1990-05-17T14:30", lat=55.75, lon=37.62, tz="Europe/Moscow")
+>>> c["Sun"].sign
+'Taurus'
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from ._ephemeris import data_dir, set_ephemeris
+from .aspects import (
+    ASPECT_ANGLES,
+    DEFAULT_ORBS,
+    DEFAULT_TRANSIT_ORBS,
+    Aspect,
+    aspects,
+    transits,
+)
+from .chart import PLANETS, Chart, Point, chart, positions
+from .houses import HOUSE_SYSTEMS, PolarHousesError
+
+__all__ = [
+    "ASPECT_ANGLES",
+    "DEFAULT_ORBS",
+    "DEFAULT_TRANSIT_ORBS",
+    "HOUSE_SYSTEMS",
+    "PLANETS",
+    "Aspect",
+    "Chart",
+    "Point",
+    "PolarHousesError",
+    "aspects",
+    "chart",
+    "data_dir",
+    "positions",
+    "set_ephemeris",
+    "transits",
+    "__version__",
+]

natal_chart/_angles.py

@@ -0,0 +1,69 @@
+"""Small angle helpers (degrees)."""
+
+from __future__ import annotations
+
+import math
+
+SIGNS: tuple[str, ...] = (
+    "Aries",
+    "Taurus",
+    "Gemini",
+    "Cancer",
+    "Leo",
+    "Virgo",
+    "Libra",
+    "Scorpio",
+    "Sagittarius",
+    "Capricorn",
+    "Aquarius",
+    "Pisces",
+)
+
+
+def norm360(x: float) -> float:
+    """Normalise an angle to [0, 360)."""
+    x = math.fmod(x, 360.0)
+    if x < 0:
+        x += 360.0
+    # fmod can return 360.0 for tiny negative inputs after the addition
+    return 0.0 if x >= 360.0 else x
+
+
+def norm180(x: float) -> float:
+    """Normalise an angle to [-180, 180)."""
+    return norm360(x + 180.0) - 180.0
+
+
+def sind(x: float) -> float:
+    return math.sin(math.radians(x))
+
+
+def cosd(x: float) -> float:
+    return math.cos(math.radians(x))
+
+
+def tand(x: float) -> float:
+    return math.tan(math.radians(x))
+
+
+def asind(x: float) -> float:
+    return math.degrees(math.asin(max(-1.0, min(1.0, x))))
+
+
+def atan2d(y: float, x: float) -> float:
+    return math.degrees(math.atan2(y, x))
+
+
+def sign_of(longitude: float) -> tuple[str, float]:
+    """Return (sign name, degree within sign) for an ecliptic longitude."""
+    lon = norm360(longitude)
+    idx = int(lon // 30.0)
+    return SIGNS[idx], lon - 30.0 * idx
+
+
+def format_dms(degree_in_sign: float) -> str:
+    """Format a degree within a sign as ``DD°MM'SS"``."""
+    total = int(round(degree_in_sign * 3600.0))
+    d, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    return f"{d:2d}°{m:02d}'{s:02d}\""

natal_chart/_ephemeris.py

@@ -0,0 +1,61 @@
+"""Loading of the JPL ephemeris through Skyfield.
+
+The ephemeris file is never shipped with the package. On first use Skyfield
+downloads it into a cache directory:
+
+* ``$NATAL_CHART_DATA`` if set, otherwise
+* ``~/.cache/natal-chart``.
+
+The default file is NASA JPL DE440s (1849-2150, ~32 MB). Any other
+Skyfield-readable SPK file (for example ``de421.bsp``, 1900-2050, ~17 MB, or
+``de440.bsp``, 1550-2650, ~114 MB) can be selected with
+:func:`set_ephemeris` or the ``NATAL_CHART_EPHEMERIS`` environment variable.
+"""
+
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from skyfield.api import Loader
+
+DEFAULT_EPHEMERIS = "de440s.bsp"
+
+_ephemeris_name: str = os.environ.get("NATAL_CHART_EPHEMERIS", DEFAULT_EPHEMERIS)
+
+
+def data_dir() -> Path:
+    """Directory where the ephemeris file is cached."""
+    env = os.environ.get("NATAL_CHART_DATA")
+    return Path(env).expanduser() if env else Path.home() / ".cache" / "natal-chart"
+
+
+@lru_cache(maxsize=1)
+def _loader() -> Loader:
+    path = data_dir()
+    path.mkdir(parents=True, exist_ok=True)
+    return Loader(str(path), verbose=False)
+
+
+@lru_cache(maxsize=1)
+def timescale() -> Any:
+    """Skyfield timescale (uses Skyfield's built-in Delta T / leap-second data)."""
+    return _loader().timescale()
+
+
+@lru_cache(maxsize=4)
+def _load(name: str) -> Any:
+    return _loader()(name)
+
+
+def ephemeris() -> Any:
+    """The currently selected JPL ephemeris, downloading it on first use."""
+    return _load(_ephemeris_name)
+
+
+def set_ephemeris(name_or_path: str) -> None:
+    """Select the SPK file to use, e.g. ``"de421.bsp"`` or a local path."""
+    global _ephemeris_name
+    _ephemeris_name = name_or_path

natal_chart/aspects.py

@@ -0,0 +1,136 @@
+"""Major aspects within a chart and transits to a natal chart."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from itertools import combinations
+from typing import Iterable, Mapping
+
+from ._angles import norm180
+from .chart import ASCENDANT, MC, PLANETS, Chart, Point, positions
+
+_ANGLES = {ASCENDANT, MC}
+
+ASPECT_ANGLES: dict[str, float] = {
+    "conjunction": 0.0,
+    "sextile": 60.0,
+    "square": 90.0,
+    "trine": 120.0,
+    "opposition": 180.0,
+}
+
+DEFAULT_ORBS: dict[str, float] = {
+    "conjunction": 8.0,
+    "opposition": 8.0,
+    "trine": 7.0,
+    "square": 7.0,
+    "sextile": 5.0,
+}
+
+DEFAULT_TRANSIT_ORBS: dict[str, float] = {name: 1.0 for name in ASPECT_ANGLES}
+
+
+@dataclass(frozen=True)
+class Aspect:
+    """An aspect between two points.
+
+    ``orb`` is the absolute distance from exactness in degrees. ``applying``
+    is True when the orb is shrinking given the current speeds of both
+    points (for transits the natal point is fixed).
+    """
+
+    first: str
+    second: str
+    aspect: str
+    angle: float
+    separation: float
+    """Shortest angular distance between the two points, 0..180."""
+    orb: float
+    applying: bool
+
+    @property
+    def separating(self) -> bool:
+        return not self.applying
+
+
+def _aspect_between(
+    p1: Point, p2: Point, orbs: Mapping[str, float], speed1: float, speed2: float
+) -> Aspect | None:
+    sep = norm180(p2.longitude - p1.longitude)  # signed, p1 -> p2
+    dist = abs(sep)
+    best: Aspect | None = None
+    for name, max_orb in orbs.items():
+        angle = ASPECT_ANGLES[name]
+        dev = dist - angle
+        if abs(dev) > max_orb:
+            continue
+        # d(dist)/dt; at sep == 0 the sign is irrelevant for a conjunction
+        rate = (speed2 - speed1) * (1.0 if sep >= 0 else -1.0)
+        applying = bool(dev * rate < 0)
+        cand = Aspect(p1.name, p2.name, name, angle, dist, abs(dev), applying)
+        if best is None or cand.orb < best.orb:
+            best = cand
+    return best
+
+
+def _check_orbs(orbs: Mapping[str, float]) -> None:
+    unknown = set(orbs) - set(ASPECT_ANGLES)
+    if unknown:
+        raise ValueError(f"unknown aspect(s) {sorted(unknown)}; known: {list(ASPECT_ANGLES)}")
+
+
+def aspects(
+    chart: Chart,
+    orbs: Mapping[str, float] | None = None,
+    points: Iterable[str] | None = None,
+) -> list[Aspect]:
+    """Major aspects between the points of a chart, tightest first.
+
+    Args:
+        chart: a :class:`~natal_chart.chart.Chart`.
+        orbs: maximum orb per aspect name in degrees; aspects not in the
+            mapping are not searched. Defaults to :data:`DEFAULT_ORBS`.
+        points: names of points to consider (default: all chart points,
+            including the Ascendant and MC; the ASC-MC pair itself is skipped).
+    """
+    orbs = DEFAULT_ORBS if orbs is None else orbs
+    _check_orbs(orbs)
+    names = list(chart.points) if points is None else list(points)
+    found: list[Aspect] = []
+    for a, b in combinations(names, 2):
+        if a in _ANGLES and b in _ANGLES:
+            continue  # ASC-MC geometry is not an aspect
+        p1, p2 = chart[a], chart[b]
+        asp = _aspect_between(p1, p2, orbs, p1.speed, p2.speed)
+        if asp is not None:
+            found.append(asp)
+    return sorted(found, key=lambda x: x.orb)
+
+
+def transits(
+    natal: Chart,
+    when: datetime | str,
+    tz: str | None = None,
+    orbs: Mapping[str, float] | None = None,
+    transiting: Iterable[str] = PLANETS,
+    natal_points: Iterable[str] | None = None,
+) -> list[Aspect]:
+    """Aspects from transiting planets at ``when`` to natal points.
+
+    In each returned :class:`Aspect`, ``first`` is the transiting body and
+    ``second`` the natal point. Natal points are treated as fixed when
+    deciding applying/separating. Default orbs: 1° (:data:`DEFAULT_TRANSIT_ORBS`).
+    """
+    orbs = DEFAULT_TRANSIT_ORBS if orbs is None else orbs
+    _check_orbs(orbs)
+    sky = positions(when, tz)
+    targets = list(natal.points) if natal_points is None else list(natal_points)
+    found: list[Aspect] = []
+    for t_name in transiting:
+        tp = sky[t_name]
+        for n_name in targets:
+            asp = _aspect_between(tp, natal[n_name], orbs, tp.speed, 0.0)
+            if asp is not None:
+                found.append(asp)
+    return sorted(found, key=lambda x: x.orb)

natal_chart/chart.py

@@ -0,0 +1,256 @@
+"""Natal chart computation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Iterator
+from zoneinfo import ZoneInfo
+
+from skyfield.framelib import ecliptic_frame
+from skyfield.nutationlib import iau2000a_radians, mean_obliquity
+
+from . import _ephemeris
+from ._angles import norm180, norm360, sign_of
+from .houses import Cusps, ascendant, house_cusps, house_of, midheaven
+from .points import mean_apogee, mean_apogee_speed, mean_node, mean_node_speed
+
+PLANETS: tuple[str, ...] = (
+    "Sun",
+    "Moon",
+    "Mercury",
+    "Venus",
+    "Mars",
+    "Jupiter",
+    "Saturn",
+    "Uranus",
+    "Neptune",
+    "Pluto",
+)
+MEAN_NODE = "Mean Node"
+LILITH = "Lilith"
+ASCENDANT = "Ascendant"
+MC = "MC"
+
+# Segments available in every JPL DE file (DE440s has no planet-centre
+# segments for Mars..Pluto). The offset between a planet's system
+# barycenter and its centre is < 0.1" as seen from Earth.
+_TARGETS = {
+    "Sun": "sun",
+    "Moon": "moon",
+    "Mercury": "mercury barycenter",
+    "Venus": "venus barycenter",
+    "Mars": "mars barycenter",
+    "Jupiter": "jupiter barycenter",
+    "Saturn": "saturn barycenter",
+    "Uranus": "uranus barycenter",
+    "Neptune": "neptune barycenter",
+    "Pluto": "pluto barycenter",
+}
+
+_SPEED_STEP_DAYS = 0.01  # central difference step for speeds (14.4 min)
+_ARCSEC = 1.0 / 3600.0
+
+
+@dataclass(frozen=True)
+class Point:
+    """A chart point: planet, lunar point or angle.
+
+    ``longitude``/``latitude`` are geocentric apparent ecliptic coordinates
+    referred to the true equinox and ecliptic of date (tropical zodiac).
+    ``speed`` is in degrees per day of longitude.
+    """
+
+    name: str
+    longitude: float
+    latitude: float
+    speed: float
+    house: int | None = None
+
+    @property
+    def sign(self) -> str:
+        return sign_of(self.longitude)[0]
+
+    @property
+    def degree(self) -> float:
+        """Degree within the sign, 0 <= degree < 30."""
+        return sign_of(self.longitude)[1]
+
+    @property
+    def retrograde(self) -> bool:
+        return bool(self.speed < 0)
+
+
+@dataclass(frozen=True)
+class Chart:
+    """A computed chart. Index it by point name: ``chart["Moon"]``."""
+
+    datetime_utc: datetime
+    latitude: float
+    longitude: float
+    house_system: str
+    """The house system actually used (may differ from the requested one
+    if ``polar_fallback`` kicked in, see :attr:`polar_fallback_used`)."""
+    polar_fallback_used: bool
+    cusps: Cusps
+    ramc: float
+    obliquity: float
+    """True obliquity of the ecliptic, degrees."""
+    jd_ut: float
+    jd_tt: float
+    points: dict[str, Point] = field(repr=False)
+
+    def __getitem__(self, name: str) -> Point:
+        return self.points[name]
+
+    def __iter__(self) -> Iterator[Point]:
+        return iter(self.points.values())
+
+    @property
+    def ascendant(self) -> Point:
+        return self.points[ASCENDANT]
+
+    @property
+    def mc(self) -> Point:
+        return self.points[MC]
+
+    @property
+    def planets(self) -> list[Point]:
+        return [self.points[n] for n in PLANETS]
+
+
+def to_utc(when: datetime | str, tz: str | None = None) -> datetime:
+    """Normalise input time to an aware UTC datetime.
+
+    * aware ``datetime``: converted to UTC (``tz`` must be omitted);
+    * naive ``datetime`` + ``tz``: interpreted as local time in that IANA
+      zone (ambiguous/non-existent DST times follow ``datetime.fold``);
+    * naive ``datetime`` without ``tz``: rejected, to avoid silent mistakes.
+    """
+    if isinstance(when, str):
+        when = datetime.fromisoformat(when)
+    if when.tzinfo is not None:
+        if tz is not None:
+            raise ValueError("pass either an aware datetime or tz, not both")
+        return when.astimezone(timezone.utc)
+    if tz is None:
+        raise ValueError(
+            "naive datetime: pass tz='Area/City' (IANA) or a timezone-aware datetime"
+        )
+    return when.replace(tzinfo=ZoneInfo(tz)).astimezone(timezone.utc)
+
+
+_UTC_EPOCH = datetime(1972, 1, 1, tzinfo=timezone.utc)
+
+
+def _time(dt_utc: datetime):  # -> skyfield Time
+    """Skyfield Time for a UTC instant.
+
+    Modern UTC (leap seconds) starts in 1972. Before that, civil time
+    followed UT (the "rubber second" UTC of 1961-1971 stayed within 0.1 s of
+    UT1), so earlier instants are taken as UT1 and converted with
+    Skyfield's Delta T model, as astrology software conventionally does.
+    """
+    ts = _ephemeris.timescale()
+    sec = dt_utc.second + dt_utc.microsecond / 1e6
+    args = (dt_utc.year, dt_utc.month, dt_utc.day, dt_utc.hour, dt_utc.minute, sec)
+    return ts.utc(*args) if dt_utc >= _UTC_EPOCH else ts.ut1(*args)
+
+
+def _bodies(t) -> dict[str, Point]:
+    """Apparent geocentric ecliptic positions of the ten planets + lunar points."""
+    ts = _ephemeris.timescale()
+    eph = _ephemeris.ephemeris()
+    earth = eph["earth"]
+    h = _SPEED_STEP_DAYS
+    tt = ts.tt_jd([t.tt - h, t.tt, t.tt + h])
+    out: dict[str, Point] = {}
+    for name in PLANETS:
+        apparent = earth.at(tt).observe(eph[_TARGETS[name]]).apparent()
+        lat, lon, _ = apparent.frame_latlon(ecliptic_frame)
+        lons = lon.degrees
+        speed = norm180(lons[2] - lons[0]) / (2 * h)
+        out[name] = Point(name, float(norm360(lons[1])), float(lat.degrees[1]), float(speed))
+
+    T = (float(t.tt) - 2451545.0) / 36525.0
+    dpsi, _ = iau2000a_radians(t)
+    dpsi_deg = float(dpsi) * 180.0 / 3.141592653589793
+    out[MEAN_NODE] = Point(
+        MEAN_NODE, norm360(mean_node(T) + dpsi_deg), 0.0, mean_node_speed(T)
+    )
+    a_lon, a_lat = mean_apogee(T)
+    out[LILITH] = Point(LILITH, norm360(a_lon + dpsi_deg), a_lat, mean_apogee_speed(T))
+    return out
+
+
+def _true_obliquity(t) -> float:
+    _, deps = iau2000a_radians(t)
+    return mean_obliquity(t.tdb) * _ARCSEC + float(deps) * 180.0 / 3.141592653589793
+
+
+def chart(
+    when: datetime | str,
+    lat: float,
+    lon: float,
+    tz: str | None = None,
+    house_system: str = "placidus",
+    polar_fallback: str | None = None,
+) -> Chart:
+    """Compute a tropical natal chart.
+
+    Args:
+        when: birth time; an aware datetime, or a naive one together with ``tz``.
+        lat: geographic latitude, degrees, north positive.
+        lon: geographic longitude, degrees, east positive.
+        tz: IANA time zone name for a naive ``when`` (e.g. ``"Europe/Moscow"``).
+        house_system: ``"placidus"`` (default), ``"koch"``, ``"porphyry"``,
+            ``"equal"`` or ``"whole_sign"``.
+        polar_fallback: system to use when Placidus/Koch are undefined
+            (``|lat| > 90° - obliquity``, about 66.56°). ``None`` (default)
+            raises :class:`~natal_chart.houses.PolarHousesError` instead.
+    """
+    if not -90.0 <= lat <= 90.0:
+        raise ValueError("latitude must be within [-90, 90]")
+    if not -180.0 <= lon <= 360.0:
+        raise ValueError("longitude must be within [-180, 360]")
+    dt_utc = to_utc(when, tz)
+    t = _time(dt_utc)
+
+    eps = _true_obliquity(t)
+    ramc = norm360(t.gast * 15.0 + lon)
+    cusps, used = house_cusps(ramc, eps, lat, house_system, polar_fallback)
+
+    points = _bodies(t)
+    points = {n: _with_house(p, cusps) for n, p in points.items()}
+
+    # Speeds of the angles from the rate of sidereal time (deg/day).
+    d_ramc = 360.98564736629 * 0.001  # 0.001 day step
+    asc = ascendant(ramc, eps, lat)
+    mc = midheaven(ramc, eps)
+    asc_speed = norm180(ascendant(ramc + d_ramc, eps, lat) - ascendant(ramc - d_ramc, eps, lat)) / 0.002
+    mc_speed = norm180(midheaven(ramc + d_ramc, eps) - midheaven(ramc - d_ramc, eps)) / 0.002
+    points[ASCENDANT] = Point(ASCENDANT, asc, 0.0, asc_speed, house_of(asc, cusps))
+    points[MC] = Point(MC, mc, 0.0, mc_speed, house_of(mc, cusps))
+
+    return Chart(
+        datetime_utc=dt_utc,
+        latitude=lat,
+        longitude=lon,
+        house_system=used,
+        polar_fallback_used=used != house_system,
+        cusps=cusps,
+        ramc=ramc,
+        obliquity=eps,
+        jd_ut=float(t.ut1),
+        jd_tt=float(t.tt),
+        points=points,
+    )
+
+
+def _with_house(p: Point, cusps: Cusps) -> Point:
+    return Point(p.name, p.longitude, p.latitude, p.speed, house_of(p.longitude, cusps))
+
+
+def positions(when: datetime | str, tz: str | None = None) -> dict[str, Point]:
+    """Planet and lunar-point positions only (no location, no houses)."""
+    return _bodies(_time(to_utc(when, tz)))

natal_chart/cli.py

@@ -0,0 +1,130 @@
+"""Command line interface: ``natal-chart 1990-05-17T14:30 --tz Europe/Moscow --lat 55.75 --lon 37.62``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from typing import Sequence
+
+from . import __version__
+from ._angles import format_dms
+from .aspects import aspects, transits
+from .chart import Chart, chart
+from .houses import HOUSE_SYSTEMS, PolarHousesError
+
+_GLYPH_ASPECT = {
+    "conjunction": "conj",
+    "sextile": "sext",
+    "square": "sqr",
+    "trine": "tri",
+    "opposition": "opp",
+}
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="natal-chart",
+        description="Tropical natal chart (planets, houses, aspects) from JPL ephemerides.",
+    )
+    p.add_argument("datetime", help="birth time, ISO format, e.g. 1990-05-17T14:30")
+    p.add_argument("--tz", help="IANA time zone of the given time (default: UTC)", default=None)
+    p.add_argument("--lat", type=float, required=True, help="latitude, north positive")
+    p.add_argument("--lon", type=float, required=True, help="longitude, east positive")
+    p.add_argument("--houses", choices=HOUSE_SYSTEMS, default="placidus")
+    p.add_argument(
+        "--polar-fallback",
+        choices=("porphyry", "equal", "whole_sign"),
+        default=None,
+        help="house system to use where Placidus/Koch are undefined (|lat| > ~66.56)",
+    )
+    p.add_argument("--aspects", action="store_true", help="also list major aspects")
+    p.add_argument("--transits", metavar="DATETIME", help="list transits for this time (UTC unless it has an offset)")
+    p.add_argument("--json", action="store_true", help="machine-readable output")
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return p
+
+
+def _chart_dict(c: Chart) -> dict:
+    return {
+        "datetime_utc": c.datetime_utc.isoformat(),
+        "latitude": c.latitude,
+        "longitude": c.longitude,
+        "house_system": c.house_system,
+        "polar_fallback_used": c.polar_fallback_used,
+        "points": [
+            {
+                "name": p.name,
+                "longitude": p.longitude,
+                "latitude": p.latitude,
+                "sign": p.sign,
+                "degree": p.degree,
+                "speed": p.speed,
+                "retrograde": p.retrograde,
+                "house": p.house,
+            }
+            for p in c
+        ],
+        "cusps": list(c.cusps),
+    }
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    when = datetime.fromisoformat(args.datetime)
+    tz = args.tz
+    if when.tzinfo is None and tz is None:
+        tz = "UTC"
+    try:
+        c = chart(when, args.lat, args.lon, tz=tz, house_system=args.houses,
+                  polar_fallback=args.polar_fallback)
+    except (PolarHousesError, ValueError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    asp = aspects(c) if args.aspects else []
+    tr = []
+    if args.transits:
+        tw = datetime.fromisoformat(args.transits)
+        if tw.tzinfo is None:
+            tw = tw.replace(tzinfo=timezone.utc)
+        tr = transits(c, tw)
+
+    if args.json:
+        out = _chart_dict(c)
+        if args.aspects:
+            out["aspects"] = [a.__dict__ for a in asp]
+        if args.transits:
+            out["transits"] = [a.__dict__ for a in tr]
+        print(json.dumps(out, indent=2, ensure_ascii=False))
+        return 0
+
+    note = " (polar fallback)" if c.polar_fallback_used else ""
+    print(f"{c.datetime_utc:%Y-%m-%d %H:%M:%S} UTC  lat {c.latitude:.4f}  lon {c.longitude:.4f}"
+          f"  houses: {c.house_system}{note}")
+    print()
+    print(f"{'Point':<10} {'Sign':<12} {'Degree':>10}  {'Longitude':>10}  {'Speed':>8}  R  House")
+    for p in c:
+        r = "R" if p.retrograde else " "
+        print(f"{p.name:<10} {p.sign:<12} {format_dms(p.degree):>10}  {p.longitude:10.4f}"
+              f"  {p.speed:8.4f}  {r}  {p.house or '':>5}")
+    print()
+    print("Cusps: " + "  ".join(f"{i + 1}:{x:.2f}" for i, x in enumerate(c.cusps)))
+    if args.aspects:
+        print()
+        print("Aspects (orb, A=applying S=separating):")
+        for a in asp:
+            print(f"  {a.first:<10} {_GLYPH_ASPECT[a.aspect]:<4} {a.second:<10} "
+                  f"{a.orb:5.2f}  {'A' if a.applying else 'S'}")
+    if args.transits:
+        print()
+        print(f"Transits at {args.transits} (transiting -> natal):")
+        for a in tr:
+            print(f"  {a.first:<10} {_GLYPH_ASPECT[a.aspect]:<4} natal {a.second:<10} "
+                  f"{a.orb:5.2f}  {'A' if a.applying else 'S'}")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

natal_chart/houses.py

@@ -0,0 +1,202 @@
+"""House systems, Ascendant and Midheaven.
+
+All functions here are pure math and take:
+
+* ``ramc`` - right ascension of the meridian (local apparent sidereal time
+  in degrees),
+* ``eps`` - true obliquity of the ecliptic, degrees,
+* ``lat`` - geographic latitude, degrees (north positive).
+
+Cusps are returned as a 12-tuple of ecliptic longitudes, index 0 = cusp 1.
+
+Placidus and Koch are undefined when part of the ecliptic never rises or
+sets, i.e. for ``|lat| > 90° - eps`` (about 66.56°). In that case
+:class:`PolarHousesError` is raised; :func:`house_cusps` can instead fall
+back to another system when asked to.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ._angles import asind, atan2d, cosd, norm180, norm360, sind, tand
+
+HouseSystem = Literal["placidus", "koch", "porphyry", "equal", "whole_sign"]
+HOUSE_SYSTEMS: tuple[str, ...] = ("placidus", "koch", "porphyry", "equal", "whole_sign")
+_QUADRANT_SYSTEMS = ("placidus", "koch")
+
+Cusps = tuple[float, float, float, float, float, float, float, float, float, float, float, float]
+
+
+class PolarHousesError(ValueError):
+    """Placidus/Koch cusps do not exist at this latitude."""
+
+
+def midheaven(ramc: float, eps: float) -> float:
+    """Ecliptic longitude of the MC."""
+    return norm360(atan2d(sind(ramc), cosd(ramc) * cosd(eps)))
+
+
+def ascendant(ramc: float, eps: float, lat: float) -> float:
+    """Ecliptic longitude of the ecliptic point rising in the east."""
+    return norm360(
+        atan2d(cosd(ramc), -(sind(ramc) * cosd(eps) + tand(lat) * sind(eps)))
+    )
+
+
+def _lon_from_ra(ra: float, eps: float) -> float:
+    """Ecliptic longitude of the ecliptic point with right ascension ``ra``."""
+    return norm360(atan2d(sind(ra), cosd(ra) * cosd(eps)))
+
+
+def _check_polar(lat: float, eps: float, system: str) -> None:
+    if abs(lat) >= 90.0 - eps:
+        raise PolarHousesError(
+            f"{system.capitalize()} houses are undefined at latitude {lat:.4f}° "
+            f"(|latitude| >= 90° - obliquity = {90.0 - eps:.4f}°): part of the "
+            "ecliptic never rises or sets. Use house_system='porphyry', 'equal' or "
+            "'whole_sign', or pass polar_fallback=..."
+        )
+
+
+def placidus(ramc: float, eps: float, lat: float) -> Cusps:
+    """Placidus cusps by iterating on the diurnal semi-arc of each cusp.
+
+    Cusp 11/12 is the ecliptic point whose right ascension exceeds RAMC by
+    1/3 resp. 2/3 of its own diurnal semi-arc; cusps 2/3 likewise trisect
+    the nocturnal semi-arc between the Ascendant and the IC.
+    """
+    _check_polar(lat, eps, "placidus")
+    tan_lat = tand(lat)
+
+    def cusp(offset: float, factor: float) -> float:
+        # RA(cusp) = RAMC + offset + factor * DSA(dec(cusp)), DSA = 90 + AD
+        lon = _lon_from_ra(ramc + offset + factor * 90.0, eps)  # start: equator
+        for _ in range(100):
+            dec = asind(sind(eps) * sind(lon))
+            ad = asind(tan_lat * tand(dec))
+            new = _lon_from_ra(ramc + offset + factor * (90.0 + ad), eps)
+            if abs(norm180(new - lon)) < 1e-10:
+                return new
+            lon = new
+        return lon
+
+    mc = midheaven(ramc, eps)
+    asc = ascendant(ramc, eps, lat)
+    c11 = cusp(0.0, 1.0 / 3.0)
+    c12 = cusp(0.0, 2.0 / 3.0)
+    # RA(c2) = RAMC + 180 - 2/3 NSA = RAMC + 60 + 2/3 DSA ; RA(c3) = RAMC + 120 + 1/3 DSA
+    c2 = cusp(60.0, 2.0 / 3.0)
+    c3 = cusp(120.0, 1.0 / 3.0)
+    return _from_quadrant(asc, c2, c3, mc, c11, c12)
+
+
+def koch(ramc: float, eps: float, lat: float) -> Cusps:
+    """Koch (birthplace) cusps.
+
+    Intermediate cusps are Ascendants computed for sidereal times that
+    trisect the diurnal semi-arc of the MC degree.
+    """
+    _check_polar(lat, eps, "koch")
+    mc = midheaven(ramc, eps)
+    dec_mc = asind(sind(eps) * sind(mc))
+    ad = asind(tand(lat) * tand(dec_mc))
+    dsa = 90.0 + ad
+    asc = ascendant(ramc, eps, lat)
+    c11 = ascendant(ramc - 2.0 * dsa / 3.0, eps, lat)
+    c12 = ascendant(ramc - dsa / 3.0, eps, lat)
+    c2 = ascendant(ramc + dsa / 3.0, eps, lat)
+    c3 = ascendant(ramc + 2.0 * dsa / 3.0, eps, lat)
+    return _from_quadrant(asc, c2, c3, mc, c11, c12)
+
+
+def porphyry(ramc: float, eps: float, lat: float) -> Cusps:
+    """Porphyry: each quadrant between the angles is trisected in longitude."""
+    mc = midheaven(ramc, eps)
+    asc = ascendant(ramc, eps, lat)
+    q1 = norm360(asc - mc)  # MC -> ASC (houses 10-12)
+    q2 = 180.0 - q1  # ASC -> IC (houses 1-3)
+    c11 = norm360(mc + q1 / 3.0)
+    c12 = norm360(mc + 2.0 * q1 / 3.0)
+    c2 = norm360(asc + q2 / 3.0)
+    c3 = norm360(asc + 2.0 * q2 / 3.0)
+    return _from_quadrant(asc, c2, c3, mc, c11, c12)
+
+
+def equal(ramc: float, eps: float, lat: float) -> Cusps:
+    """Equal houses: 30° steps from the Ascendant."""
+    asc = ascendant(ramc, eps, lat)
+    return tuple(norm360(asc + 30.0 * i) for i in range(12))  # type: ignore[return-value]
+
+
+def whole_sign(ramc: float, eps: float, lat: float) -> Cusps:
+    """Whole-sign houses: house 1 is the whole sign containing the Ascendant."""
+    asc = ascendant(ramc, eps, lat)
+    start = 30.0 * int(asc // 30.0)
+    return tuple(norm360(start + 30.0 * i) for i in range(12))  # type: ignore[return-value]
+
+
+def _from_quadrant(
+    asc: float, c2: float, c3: float, mc: float, c11: float, c12: float
+) -> Cusps:
+    ic, dsc = norm360(mc + 180.0), norm360(asc + 180.0)
+    return (
+        asc,
+        c2,
+        c3,
+        ic,
+        norm360(c11 + 180.0),
+        norm360(c12 + 180.0),
+        dsc,
+        norm360(c2 + 180.0),
+        norm360(c3 + 180.0),
+        mc,
+        c11,
+        c12,
+    )
+
+
+_SYSTEMS = {
+    "placidus": placidus,
+    "koch": koch,
+    "porphyry": porphyry,
+    "equal": equal,
+    "whole_sign": whole_sign,
+}
+
+
+def house_cusps(
+    ramc: float,
+    eps: float,
+    lat: float,
+    system: str = "placidus",
+    polar_fallback: str | None = None,
+) -> tuple[Cusps, str]:
+    """Compute cusps and return ``(cusps, system_actually_used)``.
+
+    If ``system`` is Placidus or Koch and the latitude is beyond the polar
+    circle, :class:`PolarHousesError` is raised unless ``polar_fallback``
+    names another system, which is then used instead.
+    """
+    if system not in _SYSTEMS:
+        raise ValueError(f"unknown house system {system!r}; choose from {HOUSE_SYSTEMS}")
+    try:
+        return _SYSTEMS[system](ramc, eps, lat), system
+    except PolarHousesError:
+        if polar_fallback is None:
+            raise
+        if polar_fallback not in _SYSTEMS or polar_fallback in _QUADRANT_SYSTEMS:
+            raise ValueError(
+                "polar_fallback must be one of 'porphyry', 'equal', 'whole_sign'"
+            ) from None
+        return _SYSTEMS[polar_fallback](ramc, eps, lat), polar_fallback
+
+
+def house_of(longitude: float, cusps: Cusps) -> int:
+    """House number (1-12) containing an ecliptic longitude."""
+    lon = norm360(longitude)
+    for i in range(12):
+        start, end = cusps[i], cusps[(i + 1) % 12]
+        if norm360(lon - start) < norm360(end - start):
+            return i + 1
+    return 12  # pragma: no cover - only reachable with degenerate cusps

natal_chart/points.py

@@ -0,0 +1,76 @@
+"""Mean lunar node and mean Black Moon Lilith (mean lunar apogee).
+
+Both come from the ELP-2000/82 mean-element polynomials as given by
+J. Meeus, *Astronomical Algorithms* (2nd ed.), ch. 47:
+
+* mean ascending node  Ω = 125.0445479 − 1934.1362891 T + 0.0020754 T²
+  + T³/467441 − T⁴/60616000
+* mean perigee         ϖ = 83.3532465 + 4069.0137287 T − 0.0103200 T²
+  − T³/80053 + T⁴/18999000
+
+with T in Julian centuries of TT from J2000.0. The values refer to the mean
+equinox of date; we add the nutation in longitude so they are on the same
+true-equinox-of-date frame as the planets.
+
+The mean apogee (ϖ + 180°) lies on the inclined lunar orbit. Its ecliptic
+longitude is obtained by projecting it from the orbit plane (inclination
+5.1453964°) onto the ecliptic, which is what most astrology software does.
+"""
+
+from __future__ import annotations
+
+import math
+
+from ._angles import atan2d, cosd, norm360, sind
+
+LUNAR_INCLINATION = 5.1453964  # degrees, mean inclination of the lunar orbit
+
+
+def mean_node(T: float) -> float:
+    """Mean ascending lunar node, mean equinox of date (degrees)."""
+    return norm360(
+        125.0445479
+        - 1934.1362891 * T
+        + 0.0020754 * T**2
+        + T**3 / 467441.0
+        - T**4 / 60616000.0
+    )
+
+
+def mean_node_speed(T: float) -> float:
+    """Speed of the mean node in degrees per day."""
+    dT = -1934.1362891 + 2 * 0.0020754 * T + 3 * T**2 / 467441.0 - 4 * T**3 / 60616000.0
+    return dT / 36525.0
+
+
+def mean_perigee(T: float) -> float:
+    """Mean longitude of the lunar perigee (Ω + ω, along ecliptic then orbit)."""
+    return norm360(
+        83.3532465
+        + 4069.0137287 * T
+        - 0.0103200 * T**2
+        - T**3 / 80053.0
+        + T**4 / 18999000.0
+    )
+
+
+def mean_apogee(T: float) -> tuple[float, float]:
+    """Mean lunar apogee (Black Moon Lilith): (ecliptic longitude, latitude).
+
+    Mean equinox of date, degrees.
+    """
+    node = mean_node(T)
+    # argument of the apogee measured in the orbit plane from the node
+    u = norm360(mean_perigee(T) + 180.0 - node)
+    i = LUNAR_INCLINATION
+    lon = norm360(node + atan2d(sind(u) * cosd(i), cosd(u)))
+    lat = math.degrees(math.asin(sind(u) * sind(i)))
+    return lon, lat
+
+
+def mean_apogee_speed(T: float, h: float = 0.5) -> float:
+    """Speed of the mean apogee in degrees per day (central difference)."""
+    dT = h / 36525.0
+    a = mean_apogee(T - dT)[0]
+    b = mean_apogee(T + dT)[0]
+    return ((b - a + 540.0) % 360.0 - 180.0) / (2 * h)

natal_chart-0.1.0.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.5
+Name: natal-chart
+Version: 0.1.0
+Summary: Tropical natal chart math (planets, Placidus/Koch/whole-sign houses, aspects, transits) on NASA JPL ephemerides via Skyfield. No Swiss Ephemeris.
+Project-URL: Homepage, https://astralread.com
+Project-URL: Repository, https://github.com/VictorMachiavelli/natal-chart
+Project-URL: Issues, https://github.com/VictorMachiavelli/natal-chart/issues
+Author-email: Victor Balakirev <balakirevvictor@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aspects,astrology,ephemeris,horoscope,houses,jpl,natal chart,placidus,skyfield,transits
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: skyfield>=1.45
+Requires-Dist: tzdata; sys_platform == 'win32'
+Provides-Extra: test
+Requires-Dist: pyswisseph>=2.10; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# natal-chart
+
+Tropical natal chart math for Python: planet positions, houses
+(Placidus, Koch, Porphyry, Equal, Whole Sign), Ascendant/MC, mean lunar node,
+mean Black Moon Lilith, major aspects and transits.
+
+Positions come from NASA JPL ephemerides through
+[Skyfield](https://rhodesmill.org/skyfield/). The package does **not** use or
+contain the Swiss Ephemeris, so it can be released under the MIT license.
+
+## Install
+
+```bash
+pip install natal-chart
+```
+
+Requires Python 3.10+. The only dependency is Skyfield (which brings NumPy).
+
+The first call downloads the JPL DE440s ephemeris (~32 MB, covers
+1849-2150) into `~/.cache/natal-chart` (override with the `NATAL_CHART_DATA`
+environment variable). It is never bundled with the package. To use a
+different file, e.g. the smaller DE421 (1900-2050) or DE440 (1550-2650):
+
+```python
+import natal_chart
+natal_chart.set_ephemeris("de421.bsp")   # or NATAL_CHART_EPHEMERIS=de421.bsp
+```
+
+## Quickstart
+
+```python
+from natal_chart import chart, aspects, transits
+
+# Fictional birth data: local time + IANA time zone
+c = chart("1990-05-17T14:30", lat=55.75, lon=37.62, tz="Europe/Moscow")
+
+c["Sun"].sign, round(c["Sun"].degree, 2)   # ('Taurus', 26.26)
+c["Saturn"].retrograde                      # True
+c["Moon"].house                             # 5
+c.ascendant.longitude, c.mc.longitude       # 166.69..., 71.52...
+c.cusps                                     # 12 cusp longitudes, cusp 1 first
+
+for a in aspects(c)[:3]:
+    print(a.first, a.aspect, a.second, round(a.orb, 2),
+          "applying" if a.applying else "separating")
+
+for a in transits(c, "2026-11-10T12:00:00+00:00"):
+    print("transiting", a.first, a.aspect, "natal", a.second, round(a.orb, 2))
+```
+
+`chart()` accepts a timezone-aware `datetime`, or a naive one plus `tz=`.
+A naive time without `tz` is rejected rather than silently treated as UTC.
+
+Points: Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune,
+Pluto, `"Mean Node"`, `"Lilith"`, `"Ascendant"`, `"MC"`. Each `Point` has
+`longitude`, `latitude`, `speed` (°/day), `sign`, `degree` (within sign),
+`retrograde` and `house`.
+
+### Aspects
+
+`aspects(chart, orbs=None, points=None)` finds conjunction, sextile, square,
+trine and opposition, tightest first. Default orbs:
+conjunction/opposition 8°, trine/square 7°, sextile 5°. Pass your own
+mapping, e.g. `orbs={"conjunction": 10, "square": 6}` (aspects left out are
+not searched). `applying` is decided from the current speeds of both points.
+
+`transits(natal, when, orbs=None)` compares the transiting planets with every
+natal point (default orb 1°). The natal point is treated as fixed.
+
+### Command line
+
+```text
+$ natal-chart 1990-05-17T14:30 --tz Europe/Moscow --lat 55.75 --lon 37.62 --aspects
+1990-05-17 10:30:00 UTC  lat 55.7500  lon 37.6200  houses: placidus
+
+Point      Sign             Degree   Longitude     Speed  R  House
+Sun        Taurus        26°15'49"     56.2636    0.9636         9
+Moon       Aquarius      21°37'13"    321.6204   12.9387         5
+...
+```
+
+Options: `--houses {placidus,koch,porphyry,equal,whole_sign}`,
+`--polar-fallback {porphyry,equal,whole_sign}`, `--aspects`,
+`--transits DATETIME`, `--json`. Without `--tz` the time is taken as UTC.
+
+## What exactly is computed
+
+* **Planets**: geocentric *apparent* positions (light-time, aberration,
+  gravitational deflection), ecliptic longitude and latitude referred to the
+  **true equinox and ecliptic of date** (IAU 2006 precession + IAU 2000A
+  nutation), tropical zodiac. This is the same convention as the default
+  output of most astrology software. Mars-Pluto use the planetary-system
+  barycenter segments of the JPL file; the offset from the planet's centre
+  is below 0.1" as seen from Earth.
+* **Speed**: central difference over ±0.01 day, degrees per day.
+* **Mean node / mean Lilith**: ELP-2000/82 mean-element polynomials
+  (Meeus, *Astronomical Algorithms*, ch. 47), plus nutation in longitude.
+  Lilith (mean lunar apogee) is projected from the inclined lunar orbit onto
+  the ecliptic, so it also has a small ecliptic latitude.
+* **Houses**: RAMC from Skyfield's Greenwich apparent sidereal time plus the
+  east longitude; true obliquity of date. Placidus is computed by iterating
+  each cusp on its own diurnal/nocturnal semi-arc; Koch from Ascendants at
+  the times that trisect the MC degree's semi-arc.
+* **Time**: from 1972 the input is UTC with leap seconds. Before 1972 the
+  given UTC is treated as UT1 (civil time followed UT then); Delta T comes
+  from Skyfield's built-in model. Ambiguous or non-existent local times at
+  DST changes follow Python's `datetime.fold` rule (`fold=0` by default).
+
+### High latitudes
+
+Placidus and Koch are undefined when part of the ecliptic never rises or sets,
+i.e. for |latitude| ≥ 90° − obliquity (about 66.56°). There `chart()` raises
+`PolarHousesError` with an explanation. Pass
+`polar_fallback="porphyry"` (or `"equal"`, `"whole_sign"`) to get a chart
+anyway; then `chart.house_system` names the system actually used and
+`chart.polar_fallback_used` is `True`. Equal, Whole Sign and Porphyry work at
+any latitude short of the poles.
+
+## Accuracy
+
+Measured against the Swiss Ephemeris 2.10 (pyswisseph, with its
+`sepl_18`/`semo_18` data files) on 300 random fictional dates 1900-2100 and
+latitudes within ±66°. The comparison is run at identical instants (same TT
+for bodies, same UT1 for houses) so that what is measured is ephemeris,
+reduction and house math, not the two libraries' Delta T models.
+
+| Quantity | Max difference |
+| --- | --- |
+| Sun ... Pluto, longitude | 0.007" |
+| Sun ... Pluto, latitude | 0.003" |
+| Speeds | 0.00008 °/day |
+| Mean Node | 0.11" |
+| Mean Lilith (longitude / latitude) | 0.54" / 0.04" |
+| Ascendant, MC | 0.000003° |
+| Placidus, Koch, Porphyry, Equal cusps | 0.000006° |
+
+Things that differ between libraries and are *not* in the table:
+
+* **Delta T for future dates.** Neither library can know future Earth
+  rotation; their predictions differ by a few seconds after 2026, which moves
+  the Moon (0.5"/s) by up to ~13" at the same civil time (we measured 0.003"
+  for 1972-2025 and 0.4" for 1900-1971).
+* **Sidereal time after 2050.** From 2050-01-01 the Swiss Ephemeris switches
+  to its own long-term sidereal-time formula, which differs from the IERS
+  expression used here by ~1.9" (0.13 s of time).
+
+The comparison test (`tests/test_vs_swisseph.py`) runs only when the
+optional `pyswisseph` dev dependency is installed; point `SE_EPHE_PATH` at the
+Swiss data files to compare against the full Swiss Ephemeris instead of its
+built-in Moshier fallback.
+
+## Ephemeris data
+
+NASA JPL DE440 (public domain) via Skyfield. Default file DE440s; the
+file is downloaded on first use and is not part of this package.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[test]"
+.venv/bin/pytest -s
+```
+
+All birth data in the tests is fictional. `pyswisseph` (AGPL) appears only in
+the optional test extra and is never imported by the package.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+---
+
+Built by the team behind [AstralRead](https://astralread.com) — free natal
+chart & AI astrologer.

natal_chart-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+natal_chart/__init__.py,sha256=9T-WJMOUAw0jYDaAVecEpfa4q29ZA2S2QhjejpMsQjc,880
+natal_chart/_angles.py,sha256=pL9voqEl5xgRtA3ZnYpWW700pKiNMG1iif6qNJ9h5hA,1512
+natal_chart/_ephemeris.py,sha256=Ps3jESFhy6xfKCDc8m7two_IDzRg_FwizFyHl1b2Z6E,1733
+natal_chart/aspects.py,sha256=64yia5Xcbf6EuUJy9S28KAbYeZJgEOzM46nPEn3OViQ,4366
+natal_chart/chart.py,sha256=VjsJRj-d6gweXGts35gdHwM8E11K8edceQBph4_WpQ0,8421
+natal_chart/cli.py,sha256=JUcPPwPelDfYh4LWLcAsZwbsPIDrfE8gIIaBthouavY,4742
+natal_chart/houses.py,sha256=qBZiXmzEJfUTqAEfalLw0JsA5S7vbuwe50A5RhCHqPc,7113
+natal_chart/points.py,sha256=hOZg90nJsYc7mjzYXXEUb7NQB77DTrvPoxrLG1IwXoE,2501
+natal_chart/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+natal_chart-0.1.0.dist-info/METADATA,sha256=CKDP75WFFX3veiXzxSzHEs_madrZ40Qp4Nu_iPDMr-w,8644
+natal_chart-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+natal_chart-0.1.0.dist-info/entry_points.txt,sha256=RaKlTrmq6ejcUDcpuY1CJZuYH0CKDLEMa9oQTqKtnXM,53
+natal_chart-0.1.0.dist-info/licenses/LICENSE,sha256=UGbCTv1llXHxJ-jOi3S_rk8wFiWtAvlFiW1sqWLeI6o,1073
+natal_chart-0.1.0.dist-info/RECORD,,

natal_chart-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

natal_chart-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+natal-chart = natal_chart.cli:main

natal_chart-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victor Balakirev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.