sidereon 3.0.1__tar.gz → 3.0.2__tar.gz

{sidereon-3.0.1 → sidereon-3.0.2}/.github/workflows/release.yml

@@ -153,10 +153,10 @@ jobs:
             done
             for source in mod.rs ocean.rs pole.rs; do
               unzip -p "$wheel" \
-                "third_party_source/sidereon-core-3.0.1/tides/$source" \
+                "third_party_source/sidereon-core-3.0.2/tides/$source" \
                 >"$RUNNER_TEMP/$source"
               cmp "$RUNNER_TEMP/$source" \
-                "third_party_source/sidereon-core-3.0.1/tides/$source"
+                "third_party_source/sidereon-core-3.0.2/tides/$source"
             done
           done
           notice="$RUNNER_TEMP/sdist.notices"
@@ -173,10 +173,10 @@ jobs:
           done
           for source in mod.rs ocean.rs pole.rs; do
             tar -xOf "${sdists[0]}" --wildcards \
-              "*/third_party_source/sidereon-core-3.0.1/tides/$source" \
+              "*/third_party_source/sidereon-core-3.0.2/tides/$source" \
               >"$RUNNER_TEMP/sdist-$source"
             cmp "$RUNNER_TEMP/sdist-$source" \
-              "third_party_source/sidereon-core-3.0.1/tides/$source"
+              "third_party_source/sidereon-core-3.0.2/tides/$source"
           done
       - name: Smoke-test installed x86_64 Linux wheel
         shell: bash
@@ -218,3 +218,39 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           attestations: true
+
+  public-consumer:
+    name: Verify public PyPI consumer
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 15
+    needs: publish
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install exact published wheel and exercise public references
+        shell: bash
+        run: |
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#v}"
+          scratch="$(mktemp -d)"
+          trap 'rm -rf "$scratch"' EXIT
+          python -m venv "$scratch/venv"
+          installed=false
+          for attempt in 1 2 3 4 5 6; do
+            if "$scratch/venv/bin/python" -m pip install --only-binary=sidereon "sidereon==$version" pytest; then
+              installed=true
+              break
+            fi
+            sleep 10
+          done
+          test "$installed" = true
+          mkdir -p "$scratch/tests/fixtures/bodies"
+          cp scripts/smoke-release.py "$scratch/smoke-release.py"
+          cp tests/test_body_observe_reference.py "$scratch/tests/"
+          cp tests/fixtures/bodies/observe_de.bsp "$scratch/tests/fixtures/bodies/"
+          cd "$scratch"
+          unset PYTHONPATH
+          SIDEREON_EXPECTED_VERSION="$version" "$scratch/venv/bin/python" -I smoke-release.py
+          "$scratch/venv/bin/python" -I -m pytest -q tests/test_body_observe_reference.py

{sidereon-3.0.1 → sidereon-3.0.2}/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to the Sidereon Python interface are documented here.
 
 ## [Unreleased]
 
+## [3.0.2] - 2026-10-05
+
+### Changed
+
+- Use the coordinated 3.0.2 Rust engine release, including NaN-safe Portable ULP comparisons.
+- Retain the existing Python API while keeping package versions and shipped source disclosures aligned across all libraries.
+
 ## [3.0.1] - 2026-10-04
 
 ### Added

{sidereon-3.0.1 → sidereon-3.0.2}/Cargo.lock

@@ -611,9 +611,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sidereon"
-version = "3.0.1"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9783598080524b015c13894f68c0df9ccbaa22ad34fd6e59c5aadfdb8b30bec"
+checksum = "8a424bd9dea809b4cf2b816c27aa129a3e437b95139389ecbc94416aeee27951"
 dependencies = [
  "crc32fast",
  "flate2",
@@ -622,9 +622,9 @@ dependencies = [
 
 [[package]]
 name = "sidereon-core"
-version = "3.0.1"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c3c49cae7e3b74a9de16cb576c831985158176141d713871eb3b4ec93db91e3"
+checksum = "29f682ba7089c512d83cfea712bdc6ce9caac5e46d9acbeca7a1b2151ad8ee5b"
 dependencies = [
  "approx",
  "cc",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "sidereon-py"
-version = "3.0.1"
+version = "3.0.2"
 dependencies = [
  "nalgebra",
  "numpy",

{sidereon-3.0.1 → sidereon-3.0.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sidereon-py"
-version = "3.0.1"
+version = "3.0.2"
 authors = []
 edition = "2021"
 description = "Python (PyO3) bindings over the sidereon ergonomic API: SP3 loading and SPP/RTK/PPP positioning solves"
@@ -25,12 +25,12 @@ exact-cache-test-failpoints = ["sidereon-core/exact-cache-test-failpoints"]
 # The thin ergonomic engine surface this binding marshals to. No modeling logic
 # lives here: every solve delegates to a `sidereon` entry point, which in turn
 # delegates to `sidereon-core`.
-sidereon = { version = "=3.0.1" }
-sidereon-core = { version = "=3.0.1", features = ["mmap"] }
+sidereon = "=3.0.2"
+sidereon-core = { version = "=3.0.2", features = ["mmap"] }
 # The standalone general-purpose trust-region least-squares solver: a data-driven
 # `least_squares` whose residual and Jacobian are evaluated entirely in Rust, so
 # no per-iteration Python callback is paid.
-trust-region-least-squares = "0.11.0"
+trust-region-least-squares = "=0.11.0"
 pyo3 = { version = "0.25", features = ["abi3-py39"] }
 # Zero-copy ndarray marshalling so a batched propagate/look-angle call crosses
 # the FFI boundary once (1-D epochs in, 2-D states / 1-D angles out) instead of a

{sidereon-3.0.1 → sidereon-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sidereon
-Version: 3.0.1
+Version: 3.0.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering

{sidereon-3.0.1 → sidereon-3.0.2}/THIRD-PARTY-NOTICES.md

@@ -330,9 +330,9 @@ endorsed by the IERS Conventions Center. The Rust source describes the origin,
 the renamed routines, and the differences from the Fortran implementation.
 The complete non-test tide source distributed in the compiled extension is
 included under
-`third_party_source/sidereon-core-3.0.1/tides/` in wheels and source
-distributions. These files match sidereon-core 3.0.1 at commit 592ca2bd293177bcd901286080baa6350522020f.
-Source: [sidereon-core tides at the pinned commit](https://github.com/neilberkman/sidereon/tree/592ca2bd293177bcd901286080baa6350522020f/crates/sidereon-core/src/tides).
+`third_party_source/sidereon-core-3.0.2/tides/` in wheels and source
+distributions. These files match sidereon-core 3.0.2 at commit 8694648892d8ab065d94014e2e21d6cd5054818e.
+Source: [sidereon-core tides at the pinned commit](https://github.com/neilberkman/sidereon/tree/8694648892d8ab065d94014e2e21d6cd5054818e/crates/sidereon-core/src/tides).
 The authoritative original is available from:
 
 <https://iers-conventions.obspm.fr/content/chapter7/software/dehanttideinel/DEHANTTIDEINEL.F>

{sidereon-3.0.1 → sidereon-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sidereon"
-version = "3.0.1"
+version = "3.0.2"
 description = "Python (PyO3) bindings over the sidereon engine: SP3 loading and SPP/RTK/PPP positioning solves"
 readme = "README.md"
 license = { text = "MIT" }
@@ -82,7 +82,7 @@ include = [
   "third_party_licenses/ERFA-BSD-3-Clause.txt",
   "third_party_licenses/IERS-CONVENTIONS-SOFTWARE-LICENSE.txt",
   "third_party_licenses/SciPy-BSD-3-Clause.txt",
-  "third_party_source/sidereon-core-3.0.1/tides/mod.rs",
-  "third_party_source/sidereon-core-3.0.1/tides/ocean.rs",
-  "third_party_source/sidereon-core-3.0.1/tides/pole.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/mod.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/ocean.rs",
+  "third_party_source/sidereon-core-3.0.2/tides/pole.rs",
 ]

{sidereon-3.0.1 → sidereon-3.0.2}/scripts/check-release.py

@@ -13,7 +13,7 @@ import tomllib
 ROOT = Path(__file__).resolve().parents[1]
 CORE_GIT_URL = "https://github.com/neilberkman/sidereon"
 FULL_GIT_REVISION = re.compile(r"^[0-9a-f]{40}$")
-CORE_SOURCE_REVISION = "592ca2bd293177bcd901286080baa6350522020f"
+CORE_SOURCE_REVISION = "8694648892d8ab065d94014e2e21d6cd5054818e"
 
 
 def registry_version(name, value, package_version):
@@ -114,7 +114,7 @@ def validate_trust_region_dependency(
     value, engine_dependencies, package_version, *, allow_candidate
 ):
     """Accept the registry release or its exact coordinated Git candidate."""
-    if value == "0.11.0":
+    if value in ("0.11.0", "=0.11.0"):
         return
     if not allow_candidate:
         raise ValueError(
@@ -309,7 +309,7 @@ def main() -> None:
         "ocean.rs": "25946677944425671a92717860ac2d70f255de5403eeb1fbf98b361716821d5c",
         "pole.rs": "b4cc4c16bdd8ce1d8f04073602ab47dfb85a002b946ab192e8d4d2d600f0a1f8",
     }
-    tide_root = ROOT / "third_party_source" / "sidereon-core-3.0.1" / "tides"
+    tide_root = ROOT / "third_party_source" / "sidereon-core-3.0.2" / "tides"
     for filename, expected_digest in tide_sources.items():
         source = tide_root / filename
         if not source.is_file():
@@ -318,7 +318,7 @@ def main() -> None:
         if digest != expected_digest:
             raise SystemExit(
                 f"IERS-derived source disclosure {source} has digest {digest}, "
-                f"expected {expected_digest} from sidereon-core 3.0.1 at "
+                f"expected {expected_digest} from sidereon-core 3.0.2 at "
                 f"{CORE_SOURCE_REVISION}"
             )
 

{sidereon-3.0.1 → sidereon-3.0.2}/scripts/core_source_identity.rs

@@ -8,7 +8,7 @@ use std::path::{Path, PathBuf};
 
 const REGISTRY_SOURCE: &str = "registry+https://github.com/rust-lang/crates.io-index";
 const GIT_SOURCE_PREFIX: &str = "git+https://github.com/neilberkman/sidereon?rev=";
-const RELEASE_VERSION: &str = "3.0.1";
+const RELEASE_VERSION: &str = "3.0.2";
 
 #[derive(Debug)]
 struct LockedPackage {

{sidereon-3.0.1 → sidereon-3.0.2}/tests/fixtures/core_goldens.json

@@ -1,6 +1,6 @@
 {
   "source": "scripts/core_goldens",
-  "core_revision": "592ca2bd293177bcd901286080baa6350522020f",
+  "core_revision": "8694648892d8ab065d94014e2e21d6cd5054818e",
   "spp_trace_default": {
     "position_m": [
       "0x41511b0a63f49487",

{sidereon-3.0.1 → sidereon-3.0.2}/tests/fixtures/ppp_esbc.json

@@ -16520,5 +16520,5 @@
       ]
     }
   },
-  "core_revision": "592ca2bd293177bcd901286080baa6350522020f"
+  "core_revision": "8694648892d8ab065d94014e2e21d6cd5054818e"
 }

sidereon-3.0.2/tests/test_body_observe_reference.py

@@ -0,0 +1,311 @@
+"""Public body-observation checks against independent ephemeris references.
+
+JPL values are reproducible with GET https://ssd.jpl.nasa.gov/api/horizons.api
+and format=text, OBJ_DATA=NO, MAKE_EPHEM=YES, EPHEM_TYPE=OBSERVER,
+CENTER=coord@399, COORD_TYPE=GEODETIC, SITE_COORD=0,51.4769,0.046,
+STEP_SIZE=1 m, TIME_TYPE=UT, QUANTITIES=2,4,20, ANG_FORMAT=DEG,
+APPARENT=AIRLESS, RANGE_UNITS=KM. For the Sun use COMMAND=10,
+START_TIME=2024-06-20 12:01:42, STOP_TIME=2024-06-20 12:02:42; for the
+Moon use COMMAND=301, START_TIME=2024-04-23 23:55:59,
+STOP_TIME=2024-04-24 00:00:59. Both responses identify DE441. First data
+rows (apparent RA/Dec, az/el, range km) are Sun 89.61786, 23.43665,
+179.997296, 61.959749, 1.5201128641E+08; Moon 211.50898, -15.40328,
+179.999082, 23.119822, 3.9720636319E+05. The JPL manual documents q2 apparent
+coordinates as true-equator/equinox-of-date for Earth sites and q4 azimuth as
+clockwise from north. Sidereon's analytic Sun/Moon series are intended for
+planning and visualization, not almanac precision, so the angular tolerances
+are deliberately sub-degree.
+"""
+
+from datetime import datetime, timezone
+
+import pytest
+import sidereon
+
+
+@pytest.mark.parametrize(
+    (
+        "target",
+        "epoch",
+        "apparent_ra_deg",
+        "apparent_dec_deg",
+        "azimuth_deg",
+        "elevation_deg",
+        "range_km",
+        "angle_tolerance_deg",
+        "range_tolerance_km",
+    ),
+    [
+        (
+            sidereon.Target.sun(),
+            datetime(2024, 6, 20, 12, 1, 42, tzinfo=timezone.utc),
+            89.61786,
+            23.43665,
+            179.997296,
+            61.959749,
+            152_011_286.41,
+            0.01,
+            100_000.0,
+        ),
+        (
+            sidereon.Target.moon(),
+            datetime(2024, 4, 23, 23, 55, 59, tzinfo=timezone.utc),
+            211.50898,
+            -15.40328,
+            179.999082,
+            23.119822,
+            397_206.36319,
+            0.95,
+            1_000.0,
+        ),
+    ],
+    ids=("sun", "moon"),
+)
+def test_ground_observation_tracks_independent_horizons_reference(
+    target,
+    epoch,
+    apparent_ra_deg,
+    apparent_dec_deg,
+    azimuth_deg,
+    elevation_deg,
+    range_km,
+    angle_tolerance_deg,
+    range_tolerance_km,
+):
+    epoch_unix_us = int(epoch.timestamp()) * 1_000_000
+
+    observation = sidereon.observe_body(
+        51.4769,
+        0.0,
+        0.046,
+        epoch_unix_us,
+        target,
+    )
+
+    assert observation.reduced is True
+    assert 0.0 <= observation.apparent.right_ascension_deg < 360.0
+    assert 0.0 <= observation.apparent.right_ascension_hours < 24.0
+    assert -180.0 < observation.hour_angle_deg <= 180.0
+    assert -12.0 < observation.hour_angle_hours <= 12.0
+    assert 0.0 <= observation.horizontal.azimuth_deg < 360.0
+    assert observation.apparent.right_ascension_deg == pytest.approx(
+        apparent_ra_deg, abs=angle_tolerance_deg, rel=0.0
+    )
+    assert observation.apparent.declination_deg == pytest.approx(
+        apparent_dec_deg, abs=angle_tolerance_deg, rel=0.0
+    )
+    assert observation.horizontal.azimuth_deg == pytest.approx(
+        azimuth_deg, abs=angle_tolerance_deg, rel=0.0
+    )
+    assert observation.horizontal.elevation_deg == pytest.approx(
+        elevation_deg, abs=angle_tolerance_deg, rel=0.0
+    )
+    assert observation.horizontal.range_km == pytest.approx(
+        range_km, abs=range_tolerance_km, rel=0.0
+    )
+
+    # The API exposes both degree and hour forms of RA/hour angle.
+    assert observation.apparent.right_ascension_hours * 15.0 == pytest.approx(
+        observation.apparent.right_ascension_deg, abs=1e-12, rel=0.0
+    )
+    assert observation.hour_angle_hours * 15.0 == pytest.approx(
+        observation.hour_angle_deg, abs=1e-12, rel=0.0
+    )
+
+
+# Full-target values are generated independently by the pinned Skyfield
+# fixture generator also used by the core integration test. Its source is
+# tests/fixtures/bodies/gen_observe_golden.py in sidereon-core; that generator
+# uses observe_de.bsp and applies Sun-only gravitational deflection.
+@pytest.mark.parametrize(
+    (
+        "naif_id",
+        "latitude_deg",
+        "longitude_deg",
+        "altitude_km",
+        "apparent_ra_deg",
+        "apparent_dec_deg",
+        "apparent_distance_km",
+        "apparent_icrs_ra_deg",
+        "apparent_icrs_dec_deg",
+        "apparent_icrs_distance_km",
+        "astrometric_ra_deg",
+        "astrometric_dec_deg",
+        "astrometric_distance_km",
+        "azimuth_deg",
+        "elevation_deg",
+        "range_km",
+        "ecliptic_longitude_deg",
+        "ecliptic_latitude_deg",
+        "ecliptic_distance_km",
+    ),
+    [
+        (
+            4,
+            51.4779,
+            -0.0015,
+            0.046,
+            267.0545293733468,
+            -23.96185179890772,
+            362_601_889.49888045,
+            266.689454311102,
+            -23.95235998065674,
+            362_601_889.4988812,
+            266.69569176937006,
+            -23.95250704362053,
+            362_601_889.498879,
+            25.029803759785487,
+            -60.701353351529,
+            362_601_889.4988805,
+            267.3084528018354,
+            -0.550968260129117,
+            362_601_889.49888045,
+        ),
+        (
+            5,
+            -33.8568,
+            151.2153,
+            0.040,
+            33.685726736672464,
+            12.26418101472206,
+            670_428_149.8823149,
+            33.36411888660434,
+            12.152064228124974,
+            670_428_149.8823142,
+            33.36174062892731,
+            12.151348694023607,
+            670_428_149.8823142,
+            113.07414946418533,
+            -49.51460784852244,
+            670_428_149.8823149,
+            35.582668467646254,
+            -1.1853565914672937,
+            670_428_149.8823149,
+        ),
+    ],
+    ids=("mars-greenwich", "jupiter-sydney"),
+)
+def test_spk_target_projects_complete_skyfield_golden(
+    naif_id,
+    latitude_deg,
+    longitude_deg,
+    altitude_km,
+    apparent_ra_deg,
+    apparent_dec_deg,
+    apparent_distance_km,
+    apparent_icrs_ra_deg,
+    apparent_icrs_dec_deg,
+    apparent_icrs_distance_km,
+    astrometric_ra_deg,
+    astrometric_dec_deg,
+    astrometric_distance_km,
+    azimuth_deg,
+    elevation_deg,
+    range_km,
+    ecliptic_longitude_deg,
+    ecliptic_latitude_deg,
+    ecliptic_distance_km,
+):
+    import math
+    from pathlib import Path
+
+    kernel = sidereon.load_spk(
+        Path(__file__).parent / "fixtures" / "bodies" / "observe_de.bsp"
+    )
+    observation = sidereon.observe_body(
+        latitude_deg,
+        longitude_deg,
+        altitude_km,
+        int(datetime(2024, 1, 1, tzinfo=timezone.utc).timestamp()) * 1_000_000,
+        sidereon.Target.spk(kernel, naif_id),
+    )
+
+    def equatorial_separation_arcsec(coords, expected_ra_deg, expected_dec_deg):
+        def vector(ra_deg, dec_deg):
+            ra = math.radians(ra_deg)
+            dec = math.radians(dec_deg)
+            return (
+                math.cos(dec) * math.cos(ra),
+                math.cos(dec) * math.sin(ra),
+                math.sin(dec),
+            )
+
+        actual = vector(coords.right_ascension_deg, coords.declination_deg)
+        expected = vector(expected_ra_deg, expected_dec_deg)
+        cross = (
+            actual[1] * expected[2] - actual[2] * expected[1],
+            actual[2] * expected[0] - actual[0] * expected[2],
+            actual[0] * expected[1] - actual[1] * expected[0],
+        )
+        cross_norm = math.sqrt(sum(component * component for component in cross))
+        dot = sum(a * b for a, b in zip(actual, expected))
+        return math.degrees(math.atan2(cross_norm, dot)) * 3600.0
+
+    def relative_distance(actual, expected):
+        return abs(actual - expected) / max(abs(expected), 1.0)
+
+    assert observation.reduced is False
+    for coords, ra, dec, distance in (
+        (
+            observation.astrometric,
+            astrometric_ra_deg,
+            astrometric_dec_deg,
+            astrometric_distance_km,
+        ),
+        (
+            observation.apparent_icrs,
+            apparent_icrs_ra_deg,
+            apparent_icrs_dec_deg,
+            apparent_icrs_distance_km,
+        ),
+        (
+            observation.apparent,
+            apparent_ra_deg,
+            apparent_dec_deg,
+            apparent_distance_km,
+        ),
+    ):
+        assert 0.0 <= coords.right_ascension_deg < 360.0
+        assert 0.0 <= coords.right_ascension_hours < 24.0
+        assert equatorial_separation_arcsec(coords, ra, dec) < 1.0
+        assert relative_distance(coords.distance_km, distance) < 1e-8
+        assert coords.right_ascension_hours * 15.0 == pytest.approx(
+            coords.right_ascension_deg, abs=1e-12, rel=0.0
+        )
+
+    assert -180.0 < observation.hour_angle_deg <= 180.0
+    assert -12.0 < observation.hour_angle_hours <= 12.0
+    assert 0.0 <= observation.horizontal.azimuth_deg < 360.0
+    assert observation.horizontal.azimuth_deg == pytest.approx(
+        azimuth_deg, abs=2.0 / 3600.0, rel=0.0
+    )
+    assert observation.horizontal.elevation_deg == pytest.approx(
+        elevation_deg, abs=2.0 / 3600.0, rel=0.0
+    )
+    assert relative_distance(observation.horizontal.range_km, range_km) < 1e-8
+    assert 0.0 <= observation.ecliptic.longitude_deg < 360.0
+    assert observation.ecliptic.longitude_deg == pytest.approx(
+        ecliptic_longitude_deg, abs=1.0 / 3600.0, rel=0.0
+    )
+    assert observation.ecliptic.latitude_deg == pytest.approx(
+        ecliptic_latitude_deg, abs=1.0 / 3600.0, rel=0.0
+    )
+    assert (
+        relative_distance(observation.ecliptic.distance_km, ecliptic_distance_km) < 1e-8
+    )
+
+    # Recover local hour angle from the independent Skyfield alt/az values.
+    lat = math.radians(latitude_deg)
+    az = math.radians(azimuth_deg)
+    el = math.radians(elevation_deg)
+    hour_angle = math.degrees(
+        math.atan2(
+            -math.sin(az) * math.cos(el),
+            math.sin(el) * math.cos(lat) - math.cos(el) * math.sin(lat) * math.cos(az),
+        )
+    )
+    delta_hour_angle = (observation.hour_angle_deg - hour_angle + 180.0) % 360.0 - 180.0
+    assert abs(delta_hour_angle) < 5.0 / 3600.0
+    assert observation.hour_angle_hours * 15.0 == pytest.approx(
+        observation.hour_angle_deg, abs=1e-12, rel=0.0
+    )