aetherfield 0.1.0__tar.gz

aetherfield-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Heather Nightfall
+
+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.

aetherfield-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: aetherfield
+Version: 0.1.0
+Summary: AetherField runtime ephemeris
+Author: WitchMithras
+License: MIT
+Project-URL: Homepage, https://github.com/WitchMithras/aetherfield
+Keywords: time,calendar,lunar,astronomy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytz>=2023.3
+Dynamic: license-file
+
+AeTherField Staging
+===================
+
+This folder stages a future standalone package for AetherField — a Skyfield-free
+runtime ephemeris model that uses learned calibration/piecewise drift and offers
+simple APIs for signs, longitudes, alignments, phases, and (now) sunrise/sunset
+estimation.
+
+Plan
+- Extract reusable runtime core from the root `aetherfield.py`.
+- Preserve public APIs: `aether_longitude`, `aether_sign`, `aether_alignments`, `moon_phase`.
+- Add `sunrise_sunset(zone, coords, date, depression_deg)` for Moontime temporal hours.
+- Keep calibration loaders and CLI tools in a tools subpackage.
+ - Console scripts (staging): `aetherfield-compare`, `aetherfield-benchmark`, `aetherfield-calibrate-all`.
+
+Local Layout (staging)
+- `src/aetherfield_pkg/` — package source (to be populated)
+- `pyproject.toml` — packaging config (setuptools)
+
+Dev Tips
+- Create a venv and install local deps from the project root as usual.
+- In staging, the package may re-export from the root `aetherfield.py` to avoid duplication.
+
+CLI Usage (staging)
+- Compare a single timestamp: `python -m aetherfield_pkg.cli.compare --body mars --dt 2025-06-21T12:00:00Z`
+- Benchmark a range: `python -m aetherfield_pkg.cli.benchmark --start 2001-01-01T00:00:00Z --end 2001-12-31T00:00:00Z`
+- Calibrate all: `python -m aetherfield_pkg.cli.calibrate_all --out aetherfield_calibration.json`

aetherfield-0.1.0/README.md

@@ -0,0 +1,27 @@
+AeTherField Staging
+===================
+
+This folder stages a future standalone package for AetherField — a Skyfield-free
+runtime ephemeris model that uses learned calibration/piecewise drift and offers
+simple APIs for signs, longitudes, alignments, phases, and (now) sunrise/sunset
+estimation.
+
+Plan
+- Extract reusable runtime core from the root `aetherfield.py`.
+- Preserve public APIs: `aether_longitude`, `aether_sign`, `aether_alignments`, `moon_phase`.
+- Add `sunrise_sunset(zone, coords, date, depression_deg)` for Moontime temporal hours.
+- Keep calibration loaders and CLI tools in a tools subpackage.
+ - Console scripts (staging): `aetherfield-compare`, `aetherfield-benchmark`, `aetherfield-calibrate-all`.
+
+Local Layout (staging)
+- `src/aetherfield_pkg/` — package source (to be populated)
+- `pyproject.toml` — packaging config (setuptools)
+
+Dev Tips
+- Create a venv and install local deps from the project root as usual.
+- In staging, the package may re-export from the root `aetherfield.py` to avoid duplication.
+
+CLI Usage (staging)
+- Compare a single timestamp: `python -m aetherfield_pkg.cli.compare --body mars --dt 2025-06-21T12:00:00Z`
+- Benchmark a range: `python -m aetherfield_pkg.cli.benchmark --start 2001-01-01T00:00:00Z --end 2001-12-31T00:00:00Z`
+- Calibrate all: `python -m aetherfield_pkg.cli.calibrate_all --out aetherfield_calibration.json`

aetherfield-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aetherfield"
+version = "0.1.0"
+description = "AetherField runtime ephemeris"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "WitchMithras" }]
+license = { text = "MIT" }
+
+dependencies = [
+  "pytz>=2023.3",
+]
+
+keywords = ["time", "calendar", "lunar", "astronomy"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "License :: Other/Proprietary License",
+  "Operating System :: OS Independent"
+]
+
+[project.urls]
+Homepage = "https://github.com/WitchMithras/aetherfield"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["aetherfield_pkg*"]
+exclude = ["tests*"]
+
+[project.scripts]
+aetherfield-compare = "aetherfield_pkg.cli.compare:main"
+aetherfield-benchmark = "aetherfield_pkg.cli.benchmark:main"
+aetherfield-calibrate-all = "aetherfield_pkg.cli.calibrate_all:main"

aetherfield-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aetherfield-0.1.0/src/aetherfield.egg-info/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: aetherfield
+Version: 0.1.0
+Summary: AetherField runtime ephemeris
+Author: WitchMithras
+License: MIT
+Project-URL: Homepage, https://github.com/WitchMithras/aetherfield
+Keywords: time,calendar,lunar,astronomy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytz>=2023.3
+Dynamic: license-file
+
+AeTherField Staging
+===================
+
+This folder stages a future standalone package for AetherField — a Skyfield-free
+runtime ephemeris model that uses learned calibration/piecewise drift and offers
+simple APIs for signs, longitudes, alignments, phases, and (now) sunrise/sunset
+estimation.
+
+Plan
+- Extract reusable runtime core from the root `aetherfield.py`.
+- Preserve public APIs: `aether_longitude`, `aether_sign`, `aether_alignments`, `moon_phase`.
+- Add `sunrise_sunset(zone, coords, date, depression_deg)` for Moontime temporal hours.
+- Keep calibration loaders and CLI tools in a tools subpackage.
+ - Console scripts (staging): `aetherfield-compare`, `aetherfield-benchmark`, `aetherfield-calibrate-all`.
+
+Local Layout (staging)
+- `src/aetherfield_pkg/` — package source (to be populated)
+- `pyproject.toml` — packaging config (setuptools)
+
+Dev Tips
+- Create a venv and install local deps from the project root as usual.
+- In staging, the package may re-export from the root `aetherfield.py` to avoid duplication.
+
+CLI Usage (staging)
+- Compare a single timestamp: `python -m aetherfield_pkg.cli.compare --body mars --dt 2025-06-21T12:00:00Z`
+- Benchmark a range: `python -m aetherfield_pkg.cli.benchmark --start 2001-01-01T00:00:00Z --end 2001-12-31T00:00:00Z`
+- Calibrate all: `python -m aetherfield_pkg.cli.calibrate_all --out aetherfield_calibration.json`

aetherfield-0.1.0/src/aetherfield.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+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_pkg/__init__.py
+src/aetherfield_pkg/core.py
+src/aetherfield_pkg/cli/benchmark.py
+src/aetherfield_pkg/cli/calibrate_all.py
+src/aetherfield_pkg/cli/compare.py

aetherfield-0.1.0/src/aetherfield.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

aetherfield-0.1.0/src/aetherfield.egg-info/requires.txt

@@ -0,0 +1 @@
+pytz>=2023.3

aetherfield-0.1.0/src/aetherfield.egg-info/top_level.txt

@@ -0,0 +1 @@
+aetherfield_pkg

aetherfield-0.1.0/src/aetherfield_pkg/__init__.py

@@ -0,0 +1,34 @@
+"""AetherField staging package shim.
+
+For now, re-export selected APIs from the host project's `aetherfield.py` to
+allow downstream packages to begin switching imports to `aetherfield_pkg`.
+
+In a full extraction, we will move the implementation here and keep this API
+surface stable.
+"""
+
+from .core import (
+    aether_longitude,
+    aether_sign,
+    aether_alignments,
+    moon_phase,
+    sunrise_sunset,
+    AetherField,
+    DE421_START,
+    DE421_END,
+    ae_is_up,
+    summarize_is_up,
+)
+
+__all__ = [
+    "aether_longitude",
+    "aether_sign",
+    "aether_alignments",
+    "moon_phase",
+    "sunrise_sunset",
+    "AetherField",
+    "DE421_START",
+    "DE421_END",
+    "ae_is_up",
+    "summarize_is_up",
+]

aetherfield-0.1.0/src/aetherfield_pkg/cli/benchmark.py

@@ -0,0 +1,195 @@
+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.1.0/src/aetherfield_pkg/cli/calibrate_all.py

@@ -0,0 +1,61 @@
+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())
+