aetherfield 0.2.6__tar.gz → 0.2.7__tar.gz

{aetherfield-0.2.6/src/aetherfield.egg-info → aetherfield-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aetherfield
-Version: 0.2.6
+Version: 0.2.7
 Summary: AetherField runtime ephemeris
 Author: WitchMithras
 License: Other/Proprietary License

{aetherfield-0.2.6 → aetherfield-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aetherfield"
-version = "0.2.6"
+version = "0.2.7"
 description = "AetherField runtime ephemeris"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -32,9 +32,4 @@ package-dir = {"" = "src"}
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["aetherfield*"]
-exclude = ["tests*"]
-
-[project.scripts]
-aetherfield-compare = "aetherfield.cli.compare:main"
-aetherfield-benchmark = "aetherfield.cli.benchmark:main"
-aetherfield-calibrate-all = "aetherfield.cli.calibrate_all:main"
+exclude = ["tests*"]

{aetherfield-0.2.6 → aetherfield-0.2.7}/src/aetherfield/core.py

@@ -40,6 +40,8 @@ AGE_LENGTH = 2147.67
 ANCHOR_YEAR = 1
 ANCHOR_SIGN = "Pisces"
 
+load_dotenv()
+
 def _wrap_deg(x: float) -> float:
     return x % 360.0
 
@@ -156,7 +158,6 @@ def _lst_deg(dt, lon_deg):
     return (_gmst_deg(dt) + lon_deg) % 360.0
 
 
-load_dotenv()
 
 try:
     import pytz
@@ -219,8 +220,8 @@ except Exception:
 
 DE421_START = datetime(1951, 1, 1, tzinfo=UTC)
 DE421_END = datetime(2050, 12, 31, 23, 59, 59, tzinfo=UTC)
-DE400_START = datetime(1550, 1, 1, tzinfo=UTC)
-DE400_END = datetime(2650, 12, 31, 23, 59, 59, tzinfo=UTC)
+DE440_START = datetime(1550, 1, 1, tzinfo=UTC)
+DE440_END = datetime(2650, 12, 31, 23, 59, 59, tzinfo=UTC)
 # DE441 spans beyond Python's datetime range; clamp to supported bounds.
 DE441_START = datetime(1, 1, 1, tzinfo=UTC)
 DE441_END = datetime(9999, 12, 31, 23, 59, 59, tzinfo=UTC)
@@ -235,16 +236,6 @@ class EphemerisSpec:
     true_start_year: int
     true_end_year: int
 
-
-_DE440_SPEC = EphemerisSpec(
-    name="de440",
-    filename="de440.bsp",
-    start=DE400_START,
-    end=DE400_END,
-    true_start_year=1550,
-    true_end_year=2650,
-)
-
 EPHEMERIS_SPECS: Dict[str, EphemerisSpec] = {
     "de421": EphemerisSpec(
         name="de421",
@@ -254,8 +245,14 @@ EPHEMERIS_SPECS: Dict[str, EphemerisSpec] = {
         true_start_year=1951,
         true_end_year=2050,
     ),
-    "de440": _DE440_SPEC,
-    "de400": _DE440_SPEC,  # alias for de440
+    "de440": EphemerisSpec(
+        name="de440",
+        filename="de440.bsp",
+        start=DE440_START,
+        end=DE440_END,
+        true_start_year=1550,
+        true_end_year=2650,
+    ),
     "de441": EphemerisSpec(
         name="de441",
         filename="de441.bsp",
@@ -318,6 +315,13 @@ def _select_calibration_ephemeris() -> Tuple[EphemerisSpec, Optional[Path]]:
             return spec, path
     return EPHEMERIS_SPECS["de421"], _resolve_ephemeris_path("de421.bsp")
 
+def resolve_ephemeris(year: int):
+    if 1950 <= year <= 2050:
+        return "de421"
+    elif 1550 <= year <= 2650:
+        return "de440"
+    else:
+        return "de441"
 
 _CAL_EPHEMERIS_SPEC, _CAL_EPHEMERIS_PATH = _select_calibration_ephemeris()
 EPHEMERIS_NAME = _CAL_EPHEMERIS_SPEC.name
@@ -943,14 +947,14 @@ class AetherField:
             'rates_deg_per_day': self.rates_deg_per_day,
             'anchors_min': self.anchors_min,
             'anchors_max': self.anchors_max,
-            'ephemeris_name': ephemeris_name,
-            'ephemeris_path': ephemeris_path,
+            #'ephemeris_name': ephemeris_name,
+            #'ephemeris_path': ephemeris_path,
             'ephemeris_start': self.window_start.isoformat(),
             'ephemeris_end': self.window_end.isoformat(),
             'ephemeris_true_start_year': spec.true_start_year if spec else None,
             'ephemeris_true_end_year': spec.true_end_year if spec else None,
-            'de421_start': self.window_start.isoformat(),
-            'de421_end': self.window_end.isoformat(),
+            #'de421_start': self.window_start.isoformat(),
+            #'de421_end': self.window_end.isoformat(),
             'piecewise': pw,
         }
         with open(path, 'w', encoding='utf-8') as f:

{aetherfield-0.2.6 → aetherfield-0.2.7/src/aetherfield.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aetherfield
-Version: 0.2.6
+Version: 0.2.7
 Summary: AetherField runtime ephemeris
 Author: WitchMithras
 License: Other/Proprietary License

{aetherfield-0.2.6 → aetherfield-0.2.7}/src/aetherfield.egg-info/SOURCES.txt

@@ -7,9 +7,5 @@ src/aetherfield/iplocal.py
 src/aetherfield.egg-info/PKG-INFO
 src/aetherfield.egg-info/SOURCES.txt
 src/aetherfield.egg-info/dependency_links.txt
-src/aetherfield.egg-info/entry_points.txt
 src/aetherfield.egg-info/requires.txt
-src/aetherfield.egg-info/top_level.txt
-src/aetherfield/cli/benchmark.py
-src/aetherfield/cli/calibrate_all.py
-src/aetherfield/cli/compare.py
+src/aetherfield.egg-info/top_level.txt

aetherfield-0.2.6/src/aetherfield/cli/benchmark.py

@@ -1,195 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from statistics import mean, median
-from typing import Dict, List, Optional, Sequence
-
-import pytz
-import aetherfield as af
-
-
-UTC = pytz.utc
-DE421_START = af.DE421_START
-DE421_END = af.DE421_END
-
-
-def parse_dt(s: str) -> datetime:
-    s = s.strip()
-    if s.endswith('Z'):
-        s = s[:-1]
-        dt = datetime.fromisoformat(s)
-        return dt.replace(tzinfo=UTC)
-    dt = datetime.fromisoformat(s)
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=UTC)
-    return dt.astimezone(UTC)
-
-
-def wrap_delta_deg(a: float, b: float) -> float:
-    return (a - b + 540.0) % 360.0 - 180.0
-
-
-def _drift_longitude(a: af.AetherField, dt: datetime, body: str, anchor_mode: str = 'nearest') -> float:
-    a._ensure_anchor(body)  # type: ignore[attr-defined]
-    rate = a.rates_deg_per_day.get(body)
-    if rate is None:
-        raise KeyError(f"No drift rate for body: {body}")
-    dt = dt if dt.tzinfo else dt.replace(tzinfo=UTC)
-    dt = dt.astimezone(UTC)
-    if anchor_mode == 'nearest':
-        d_start = abs((dt - DE421_START).total_seconds())
-        d_end = abs((DE421_END - dt).total_seconds())
-        anchor_mode = 'start' if d_start < d_end else 'end'
-    if anchor_mode == 'start':
-        days = (dt - DE421_START).total_seconds() / 86400.0
-        return (a.anchors_min[body] + rate * days) % 360.0  # type: ignore[attr-defined]
-    else:
-        days = (dt - DE421_END).total_seconds() / 86400.0
-        return (a.anchors_max[body] + rate * days) % 360.0  # type: ignore[attr-defined]
-
-
-def skyfield_longitudes(ts: Sequence[datetime], body: str) -> List[float]:
-    from skyfield.api import load
-    from skyfield.framelib import ecliptic_frame
-
-    eph = load('de421.bsp')
-    earth = eph['earth']
-    key = af._body_key(eph, body)  # type: ignore[attr-defined]
-    tscale = load.timescale()
-    out: List[float] = []
-    for dt in ts:
-        t = tscale.from_datetime(dt.astimezone(UTC))
-        app = earth.at(t).observe(key).apparent()
-        lon, lat, dist = app.frame_latlon(ecliptic_frame)
-        out.append(float(lon.degrees) % 360.0)
-    return out
-
-
-@dataclass
-class BodyStats:
-    n: int
-    mae_mean: float
-    mae_piece: float
-    med_mean: float
-    med_piece: float
-    max_mean: float
-    max_piece: float
-
-
-def benchmark(
-    bodies: Sequence[str],
-    start: datetime,
-    end: datetime,
-    step_days: int,
-    piecewise_step: int,
-    build_piecewise: bool,
-    fit_rates: bool,
-    drift_anchor: str,
-    load_cal: Optional[str],
-    save_cal: Optional[str],
-) -> Dict[str, BodyStats]:
-    r0 = max(start, DE421_START)
-    r1 = min(end, DE421_END)
-    if r1 < r0:
-        return {}
-    tlist: List[datetime] = []
-    step_days = max(1, int(step_days))
-    t = r0
-    while t <= r1:
-        tlist.append(t)
-        t = t + timedelta(days=step_days)
-
-    if load_cal:
-        a = af.AetherField.load_calibration(load_cal)
-    else:
-        a = af.AetherField()
-    if fit_rates:
-        try:
-            a.fit_rates()
-        except Exception:
-            pass
-    if build_piecewise:
-        try:
-            a.fit_piecewise(step_days=piecewise_step, bodies=tuple(bodies))
-        except Exception:
-            pass
-    if save_cal:
-        try:
-            a.save_calibration(save_cal)
-        except Exception:
-            pass
-
-    results: Dict[str, BodyStats] = {}
-    for body in bodies:
-        sky = skyfield_longitudes(tlist, body)
-        mean_preds = [_drift_longitude(a, dt, body, anchor_mode=drift_anchor) for dt in tlist]
-        if build_piecewise and (body in getattr(a, 'piecewise', {})):
-            piece_preds = [a.longitude_piecewise(dt, body, anchor_mode=drift_anchor) for dt in tlist]
-        else:
-            piece_preds = [a.longitude(dt, body) for dt in tlist]
-
-        mean_err = [abs(wrap_delta_deg(p, s)) for p, s in zip(mean_preds, sky)]
-        piece_err = [abs(wrap_delta_deg(p, s)) for p, s in zip(piece_preds, sky)]
-
-        stats = BodyStats(
-            n=len(sky),
-            mae_mean=mean(mean_err) if mean_err else float('nan'),
-            mae_piece=mean(piece_err) if piece_err else float('nan'),
-            med_mean=median(mean_err) if mean_err else float('nan'),
-            med_piece=median(piece_err) if piece_err else float('nan'),
-            max_mean=max(mean_err) if mean_err else float('nan'),
-            max_piece=max(piece_err) if piece_err else float('nan'),
-        )
-        results[body] = stats
-
-    return results
-
-
-def main(argv=None) -> int:
-    parser = argparse.ArgumentParser(description="Benchmark AetherField mean drift vs piecewise against Skyfield/de421.")
-    parser.add_argument('--bodies', default='sun,moon,mercury,venus,mars,jupiter,saturn,uranus,neptune,pluto', help='Comma-separated list of bodies to evaluate.')
-    parser.add_argument('--start', required=True, help='Start datetime ISO8601 (e.g., 2001-01-01T00:00:00Z).')
-    parser.add_argument('--end', required=True, help='End datetime ISO8601 (inclusive).')
-    parser.add_argument('--step-days', type=int, default=5, help='Sampling step in days.')
-    parser.add_argument('--drift-anchor', choices=['start', 'end', 'nearest'], default='nearest', help='Anchor used for mean-drift and extrapolation.')
-    parser.add_argument('--piecewise', action='store_true', help='Build and use piecewise segments for evaluation.')
-    parser.add_argument('--piecewise-step', type=int, default=10, help='Step in days for fitting piecewise segments.')
-    parser.add_argument('--fit-rates', action='store_true', help='Fit mean drift rates from in-range samples before benchmarking.')
-    parser.add_argument('--load-calibration', default=None, help='Path to load saved calibration (rates/anchors/piecewise).')
-    parser.add_argument('--save-calibration', default=None, help='Path to save calibration after building.')
-    parser.add_argument('--json', action='store_true', help='Emit JSON summary instead of text table.')
-
-    args = parser.parse_args(argv)
-    bodies = [b.strip().lower() for b in args.bodies.split(',') if b.strip()]
-
-    start = parse_dt(args.start)
-    end = parse_dt(args.end)
-    stats = benchmark(
-        bodies=bodies,
-        start=start,
-        end=end,
-        step_days=args.step_days,
-        piecewise_step=args.piecewise_step,
-        build_piecewise=args.piecewise,
-        fit_rates=args.fit_rates,
-        drift_anchor=args.drift_anchor,
-        load_cal=args.load_calibration,
-        save_cal=args.save_calibration,
-    )
-
-    if args.json:
-        import json
-        print(json.dumps({k: vars(v) for k, v in stats.items()}, indent=2))
-    else:
-        for b, st in stats.items():
-            print(f"{b:9s} N={st.n:4d}  MAE(mean)={st.mae_mean:6.3f}°  MAE(piece)={st.mae_piece:6.3f}°  "
-                  f"MED(mean)={st.med_mean:6.3f}°  MED(piece)={st.med_piece:6.3f}°  "
-                  f"MAX(mean)={st.max_mean:6.3f}°  MAX(piece)={st.max_piece:6.3f}°")
-    return 0
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())
-

aetherfield-0.2.6/src/aetherfield/cli/calibrate_all.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import argparse
-
-import aetherfield as af
-
-
-DEFAULT_OUT = 'aetherfield_calibration.json'
-
-
-def main(argv=None) -> int:
-    parser = argparse.ArgumentParser(description='Calibrate AetherField and save piecewise segments for all bodies.')
-    parser.add_argument('--out', default=DEFAULT_OUT, help='Output JSON path for calibration data.')
-    args = parser.parse_args(argv)
-
-    a = af.AetherField()
-
-    bodies_all = ('sun','moon','mercury','venus','mars','jupiter','saturn','uranus','neptune','pluto')
-    # Ensure anchors
-    for b in bodies_all:
-        a._ensure_anchor(b)  # type: ignore[attr-defined]
-
-    # Fit mean drift from in-range samples (coarse global refinement)
-    try:
-        a.fit_rates()
-    except Exception:
-        pass
-
-    # Piecewise segments with tuned steps per group
-    groups = [
-        (('moon',), 1),
-        (('sun','mercury','venus'), 5),
-        (('mars',), 10),
-        (('jupiter','saturn'), 15),
-        (('uranus','neptune','pluto'), 30),
-    ]
-
-    summary = {}
-    for bodies, step in groups:
-        try:
-            created = a.fit_piecewise(step_days=step, bodies=bodies)
-            summary.update(created)
-        except Exception:
-            for b in bodies:
-                summary[b] = summary.get(b, 0)
-
-    # Persist
-    a.save_calibration(args.out)
-
-    # Print a compact summary
-    print(f"Saved calibration -> {args.out}")
-    for b in bodies_all:
-        n = summary.get(b, 0)
-        print(f"  {b:9s} segments: {n}")
-
-    return 0
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())
-

aetherfield-0.2.6/src/aetherfield/cli/compare.py

@@ -1,194 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from typing import Optional
-
-import pytz
-
-import aetherfield as af  # reuse host implementation during staging
-
-
-UTC = pytz.utc
-DE421_START = af.DE421_START
-DE421_END = af.DE421_END
-
-planet_eph = {
-    'jupiter': 5,
-    'saturn': 6,
-    'uranus': 7,
-    'neptune': 8,
-    'pluto': 9
-}
-
-
-def parse_dt(dt_str: Optional[str]) -> datetime:
-    if not dt_str:
-        return datetime.now(UTC)
-    s = dt_str.strip()
-    if s.endswith('Z'):
-        s = s[:-1]
-        dt = datetime.fromisoformat(s)
-        return dt.replace(tzinfo=UTC)
-    dt = datetime.fromisoformat(s)
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=UTC)
-    return dt.astimezone(UTC)
-
-
-def parse_moontime(mt_str: Optional[str]) -> Optional[datetime]:
-    if not mt_str:
-        return None
-    try:
-        from moontime import MoonTime
-        mt = MoonTime.fromisoformat(mt_str)
-        return mt.to_datetime().astimezone(UTC)
-    except Exception:
-        return None
-
-
-def wrap_delta_deg(a: float, b: float) -> float:
-    d = (a - b + 540.0) % 360.0 - 180.0
-    return d
-
-
-def sf_ecliptic_longitude(dt: datetime, body: str) -> float:
-    from skyfield.api import load
-    from skyfield.framelib import ecliptic_frame
-
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=UTC)
-    dt = dt.astimezone(UTC)
-
-    eph = load('de421.bsp')
-    ts = load.timescale()
-    t = ts.from_datetime(dt)
-    earth = eph['earth']
-    b = af._body_key(eph, body)  # type: ignore[attr-defined]
-    app = earth.at(t).observe(b).apparent()
-    lon, lat, dist = app.frame_latlon(ecliptic_frame)
-    return float(lon.degrees) % 360.0
-
-
-@dataclass
-class CompareResult:
-    body: str
-    dt: datetime
-    aether_lon: float
-    skyfield_lon: Optional[float]
-    delta_deg: Optional[float]
-    aether_sign: str
-    skyfield_sign: Optional[str]
-
-
-def _drift_longitude(a: af.AetherField, dt: datetime, body: str, anchor_mode: str = 'end') -> float:
-    a._ensure_anchor(body)  # type: ignore[attr-defined]
-    rate = a.rates_deg_per_day.get(body)
-    if rate is None:
-        raise KeyError(f"No drift rate for body: {body}")
-    dt = dt if dt.tzinfo else dt.replace(tzinfo=UTC)
-    dt = dt.astimezone(UTC)
-    if anchor_mode == 'nearest':
-        d_start = abs((dt - DE421_START).total_seconds())
-        d_end = abs((DE421_END - dt).total_seconds())
-        anchor_mode = 'start' if d_start < d_end else 'end'
-    if anchor_mode == 'start':
-        days = (dt - DE421_START).total_seconds() / 86400.0
-        return (a.anchors_min[body] + rate * days) % 360.0  # type: ignore[attr-defined]
-    else:
-        days = (dt - DE421_END).total_seconds() / 86400.0
-        return (a.anchors_max[body] + rate * days) % 360.0  # type: ignore[attr-defined]
-
-
-def compare_once(body: str, dt: datetime, force_aether: bool = False, fit_rates: bool = False) -> CompareResult:
-    a = af.AetherField()
-    if fit_rates:
-        try:
-            a.fit_rates()
-        except Exception:
-            pass
-    if force_aether:
-        aether_lon = _drift_longitude(a, dt, body)
-        aether_sign = af.get_zodiac_by_longitude(aether_lon)
-    else:
-        aether_lon = a.longitude(dt, body)
-        aether_sign = a.sign(dt, body)
-    sky_lon: Optional[float] = None
-    sky_sign: Optional[str] = None
-    if DE421_START <= dt <= DE421_END:
-        try:
-            sky_lon = sf_ecliptic_longitude(dt, body)
-            sky_sign = af.get_zodiac_by_longitude(sky_lon)
-        except Exception:
-            pass
-    delta = wrap_delta_deg(aether_lon, sky_lon) if sky_lon is not None else None
-    return CompareResult(body, dt, aether_lon, sky_lon, delta, aether_sign, sky_sign)
-
-
-def main(argv=None) -> int:
-    p = argparse.ArgumentParser(description="Compare AetherField with Skyfield for a single timestamp.")
-    p.add_argument('--body', required=True, help='Body (sun, moon, mercury, ... pluto)')
-    p.add_argument('--dt', default=None, help='ISO8601 datetime (UTC).')
-    p.add_argument('--moontime', default=None, help='MoonTime string (mt:...)')
-    p.add_argument('--force-aether', action='store_true', help='Use AetherField-only (drift).')
-    p.add_argument('--fit-rates', action='store_true', help='Fit mean drift from in-range samples.')
-    p.add_argument('--calibrate', action='store_true', help='Ensure anchors and piecewise segments (no-ops if present).')
-    p.add_argument('--save-calibration', default=None, help='Save calibration JSON path.')
-    p.add_argument('--load-calibration', default=None, help='Load calibration JSON path.')
-    p.add_argument('--drift-anchor', choices=['start','end','nearest'], default='end', help='Anchor for drift only mode.')
-    p.add_argument('--piecewise', action='store_true', help='Use piecewise segments when forcing aether.')
-    p.add_argument('--piecewise-step', type=int, default=30, help='Step in days for piecewise building.')
-    p.add_argument('--json', action='store_true', help='Emit JSON instead of text.')
-    args = p.parse_args(argv)
-
-    body = args.body.strip().lower()
-    dt = parse_moontime(args.moontime) or parse_dt(args.dt)
-
-    if args.load_calibration:
-        try:
-            a = af.AetherField.load_calibration(args.load_calibration)
-        except Exception:
-            a = af.AetherField()
-    else:
-        a = af.AetherField()
-    if args.fit_rates:
-        try:
-            a.fit_rates()
-        except Exception:
-            pass
-    if args.calibrate:
-        try:
-            if args.piecewise:
-                a.fit_piecewise(step_days=int(args.piecewise_step), bodies=(body,))
-        except Exception:
-            pass
-    if args.save_calibration:
-        try:
-            a.save_calibration(args.save_calibration)
-        except Exception:
-            pass
-
-    res = compare_once(body, dt, force_aether=args.force_aether, fit_rates=args.fit_rates)
-
-    if args.json:
-        import json
-        print(json.dumps({
-            'body': res.body,
-            'dt': res.dt.isoformat(),
-            'aether_lon': res.aether_lon,
-            'skyfield_lon': res.skyfield_lon,
-            'delta_deg': res.delta_deg,
-            'aether_sign': res.aether_sign,
-            'skyfield_sign': res.skyfield_sign,
-        }, indent=2))
-    else:
-        print(f"{res.body} @ {res.dt.isoformat()}\n"
-              f"  Aether:   {res.aether_lon:8.3f} deg  ({res.aether_sign})\n"
-              f"  Skyfield: {'n/a' if res.skyfield_lon is None else f'{res.skyfield_lon:8.3f} deg  ('+str(res.skyfield_sign)+')'}\n"
-              f"  Delta:    {'n/a' if res.delta_deg is None else f'{res.delta_deg:+.3f} deg'}")
-    return 0
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())

aetherfield-0.2.6/src/aetherfield.egg-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-aetherfield-benchmark = aetherfield.cli.benchmark:main
-aetherfield-calibrate-all = aetherfield.cli.calibrate_all:main
-aetherfield-compare = aetherfield.cli.compare:main