From 21a00b0000eeb83d43a518a422540f21158aa4fb Mon Sep 17 00:00:00 2001 From: migatu Date: Thu, 6 Aug 2026 12:22:48 +0200 Subject: [PATCH] =?UTF-8?q?feat(silnik=20B):=20endpoint=20/houses=20+=20no?= =?UTF-8?q?cny=20przemia=C5=82;=20=CE=B5=20PRAWDZIWE=20zamiast=20=C5=9Bred?= =?UTF-8?q?niego?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Etap 4, z jedną istotną zmianą planu i jednym znalezionym błędem. /houses W SILNIKU B Domyka kontrakt parzystości (LOG-28) po stronie domów — dotąd obejmował tylko pozycje obiektów, więc błąd w podziale na domy przechodził przez porównanie silników niezauważony. Nazwy systemów są NASZE (te same, co houses.SYSTEMS), więc wołający nie musi znać liter swissepha; rozjazd tych dwóch list oznaczałby, że parzystość przestała obejmować część systemów. Poza dziedziną (Placidus/Koch za kołem podbiegunowym) zwracamy 422 z powodem, a NIE podstawiamy po cichu innego systemu — cicha podmiana jest po stronie wołającego niewykrywalna, a to on ma zdecydować, co z tym zrobić. PRZEMIAŁ: NOCNE CI ZAMIAST CRONJOBA W KLASTRZE Plan zakładał Job w k3s, bo „duży przemiał jest kosztowny". Pomiar tego nie potwierdził: 500 000 przypadków × 13 systemów = 70 mln porównań w 64 sekundy, skalowanie liniowe (20k→2,8 s, 100k→12,3 s, 500k→64 s). Osobny obraz w rejestrze, manifest, CronJob i kopia harnessu poza repo byłyby infrastrukturą do problemu, którego nie ma — a kopia harnessu poza repo to ryzyko cichego rozjazdu z kodem, który ma testować. Workflow z harmonogramem daje to samo: co noc inne ziarno, więc dziedzina przeczesuje się z czasem gęściej niż pojedynczym przebiegiem. ε PRAWDZIWE — BŁĄD ZNALEZIONY PRZY OKAZJI Silnik liczył RAMC z GAST (czas gwiazdowy POZORNY, mierzony od równonocy PRAWDZIWEJ), ale parował go z ε ŚREDNIM, czyli bez nutacji. To nie wybór konwencji, tylko pomieszanie dwóch układów odniesienia. Skutek: do 3,2″ na cuspach domów oraz niespójne ε dla deklinacji i antyscji, liczonych z pozycji POZORNYCH. Teraz ε pochodzi z serii IAU 2000A — z tego samego źródła, którego Skyfield używa do GAST, więc oba są spójne z definicji. Framework wyroczni tego NIE MÓGŁ wykryć: z założenia podaje to samo ε obu stronom, żeby izolować samą funkcję domów. Błąd siedział w danych WEJŚCIOWYCH, nie w testowanej funkcji — i cały czas świecił na zielono. Wejście ma więc teraz własny sprawdzian, ze Skyfieldem jako niezależnym autorytetem (bez swissepha, więc działa w każdym środowisku). Luka opisana wprost w tests/oracle/README.md, bo poprzedni tekst twierdził, że ε jest testowane — nie było. Reszta ~3″ przy porównaniu „cały horoskop nasz vs swissepha" to UT1 kontra UTC: Skyfield konwertuje z tablic IERS, swisseph przyjmuje podany JD jako UT1 (dla 1984-04-30 różnica 0,181 s = 2,7″ RAMC — zgadza się co do trzeciego miejsca). Podanie swissephowi JD w UT1 kasuje ją do 0,00065″. Nasza strona jest dokładniejsza; niczego tu nie zmieniam. Co-Authored-By: Claude Opus 5 --- .gitea/workflows/oracle-sweep.yaml | 59 ++++++++++++++++++ .gitea/workflows/tests.yml | 31 ++++++++++ services/engine-swisseph/app/main.py | 63 +++++++++++++++++++- services/logic/app/engine/chart.py | 10 +++- services/logic/app/engine/skyfield_engine.py | 24 ++++++-- services/logic/tests/test_houses.py | 45 ++++++++++++++ tests/oracle/README.md | 21 ++++++- 7 files changed, 245 insertions(+), 8 deletions(-) create mode 100644 .gitea/workflows/oracle-sweep.yaml diff --git a/.gitea/workflows/oracle-sweep.yaml b/.gitea/workflows/oracle-sweep.yaml new file mode 100644 index 0000000..bbc65a4 --- /dev/null +++ b/.gitea/workflows/oracle-sweep.yaml @@ -0,0 +1,59 @@ +name: Wyrocznia domów — nocny przemiał + +# DLACZEGO TU, A NIE JAKO JOB W KLASTRZE +# Pierwotny plan zakładał CronJob w k3s, bo „duży przemiał jest kosztowny". +# Pomiar tego nie potwierdził: 500 000 przypadków × 13 systemów = 70 mln porównań +# w 64 sekundy, skalowanie liniowe. Osobny obraz w rejestrze (który już raz zapchał +# dysk hosta), manifest, CronJob i kopia harnessu poza repo byłyby infrastrukturą +# do problemu, którego nie ma — a każda kopia harnessu poza repo to ryzyko cichego +# rozjazdu z kodem, który ma testować. +# +# Zestaw brzegowy blokuje KAŻDY build (patrz tests.yml). Tutaj chodzi o co innego: +# duża losowa próbka z INNYM ZIARNEM co noc, żeby z czasem przeczesać dziedzinę +# gęściej, niż zrobi to pojedynczy przebieg. +on: + schedule: + - cron: '17 2 * * *' # 02:17 — poza godzinami budowania + workflow_dispatch: + inputs: + count: + description: 'Liczba przypadków' + default: '500000' + seed: + description: 'Ziarno (puste = z daty)' + default: '' + +jobs: + sweep: + name: Przemiał losowy (13 systemów) + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Obraz wyroczni (silnik B + nasza logika + harness) + run: | + docker build -t astrololo/engine-swisseph:sweep services/engine-swisseph + # Pliki WBUDOWANE, nie montowane: job Gitea Actions sam działa w kontenerze, + # więc `-v $PWD/...` rozwiązałoby się na HOŚCIE (docker cicho tworzy pusty + # katalog i skrypt „znika"). Kontekst builda jest strumieniowany do demona. + docker build -t astrololo/oracle:sweep -f - . <<'DOCKERFILE' + FROM astrololo/engine-swisseph:sweep + COPY services/logic /logic + COPY tests/oracle /oracle + ENV LOGIC_PATH=/logic + DOCKERFILE + + - name: Przemiał + run: | + COUNT="${{ inputs.count }}"; COUNT="${COUNT:-500000}" + SEED="${{ inputs.seed }}"; SEED="${SEED:-$(date -u +%Y%m%d)}" + echo "count=$COUNT seed=$SEED" + # Kod wyjścia 1 przy przekroczeniu tolerancji ALBO niezgodności dziedziny, + # więc job czerwieni się sam — bez parsowania tekstu raportu. + docker run --rm astrololo/oracle:sweep \ + python /oracle/run.py --mode sweep --count "$COUNT" --seed "$SEED" + + # Runner miał już incydent „no space left on device" — sprzątamy zawsze. + - name: Usuń obrazy pomocnicze + if: always() + run: docker rmi -f astrololo/oracle:sweep astrololo/engine-swisseph:sweep 2>/dev/null || true diff --git a/.gitea/workflows/tests.yml b/.gitea/workflows/tests.yml index 2c36acb..e8bf142 100644 --- a/.gitea/workflows/tests.yml +++ b/.gitea/workflows/tests.yml @@ -138,6 +138,37 @@ jobs: assert abs(((sn - nn) % 360.0) - 180.0) < 1e-6, (nn, sn) print(f"Sun={sun:.4f} NN={nn:.4f} obiektow={len(by)}") + + # /houses — kontrakt parzystosci (LOG-28) po stronie DOMOW. Sprawdzamy + # nie tylko, ze liczy, ale i ze ODMAWIA tam, gdzie system nie istnieje: + # ciche podstawienie innego systemu byloby niewykrywalne dla wolajacego. + from fastapi import HTTPException + + from app.main import _HOUSE_CODES, HousesRequest, houses + + WHEN = "1984-04-30T09:20:00Z" + h = houses(HousesRequest(when_utc=WHEN, lat=50.0647, lon=19.9450, system="campanus")) + assert h["engine"] == "swisseph" and h["system"] == "campanus" + assert len(h["cusps"]) == 12, h["cusps"] + assert [c["house"] for c in h["cusps"]] == list(range(1, 13)) + assert all(0.0 <= c["longitude"] < 360.0 for c in h["cusps"]) + assert {"Asc", "MC", "ARMC"} <= set(h["angles"]), h["angles"] + + # kazdy ogloszony system musi dac 12 cuspow tam, gdzie ma definicje + for name in _HOUSE_CODES: + out = houses(HousesRequest(when_utc=WHEN, lat=50.0647, lon=19.9450, system=name)) + assert len(out["cusps"]) == 12, name + print(f"/houses: {len(_HOUSE_CODES)} systemow OK") + + for bad, why in ((dict(lat=69.65, lon=18.96, system="placidus"), "Tromso/placidus"), + (dict(lat=50.0, lon=19.0, system="nie-ma-takiego"), "nieznany system")): + try: + houses(HousesRequest(when_utc=WHEN, **bad)) + raise AssertionError(f"{why}: mialo byc 422, a przeszlo") + except HTTPException as e: + assert e.status_code == 422, (why, e.status_code) + print("/houses: odmowy poza dziedzina OK") + print("SMOKE OK") PY diff --git a/services/engine-swisseph/app/main.py b/services/engine-swisseph/app/main.py index 9a3f79b..4cfabd5 100644 --- a/services/engine-swisseph/app/main.py +++ b/services/engine-swisseph/app/main.py @@ -15,7 +15,7 @@ from __future__ import annotations from datetime import datetime -from fastapi import FastAPI +from fastapi import FastAPI, HTTPException from pydantic import BaseModel import swisseph as swe @@ -69,6 +69,67 @@ def positions(req: PositionsRequest) -> dict: return {"engine": "swisseph", "positions": rows} +# Kody systemów domów w Swiss Ephemeris. Nazwy po LEWEJ są nasze — te same, +# których używa houses.SYSTEMS w warstwie logicznej — żeby wołający nie musiał +# znać liter swissepha. Lista celowo pokrywa się 1:1 z naszą: rozjazd oznaczałby, +# że kontrakt parzystości (LOG-28) przestał obejmować część systemów. +_HOUSE_CODES = { + "whole_sign": b"W", "whole_sign_aries": b"N", + "equal": b"E", "equal_mc": b"D", + "porphyry": b"O", "vehlow": b"V", "morinus": b"M", + "regiomontanus": b"R", "campanus": b"C", "alcabitus": b"B", + "topocentric": b"T", "placidus": b"P", "koch": b"K", +} + +# Kolejność, w jakiej swe_houses zwraca punkty w tablicy ascmc. +_ASCMC = ("Asc", "MC", "ARMC", "Vertex", "equatorial_asc", + "co_asc_koch", "co_asc_munkasey", "polar_asc") + + +class HousesRequest(BaseModel): + when_utc: datetime + lat: float = 0.0 + lon: float = 0.0 + system: str = "whole_sign" + + +@app.post("/houses") +def houses(req: HousesRequest) -> dict: + """Cuspy domów i osie policzone przez silnik B — do porównania z własnym. + + Domyka kontrakt parzystości (LOG-28) po stronie domów: dotąd obejmował + wyłącznie pozycje obiektów, więc błąd w podziale na domy przechodził przez + porównanie silników niezauważony. Błąd w domach jest CICHY — wykres wygląda + poprawnie, tylko planety siedzą gdzie indziej — więc akurat tu warto mieć + drugie zdanie. + + Placidus i Koch nie istnieją powyżej koła podbiegunowego i swisseph zgłasza + tam wyjątek. Oddajemy to jako 422 z czytelnym powodem, a NIE podstawiamy po + cichu innego systemu: cicha podmiana jest nie do wykrycia po stronie + wołającego, a to on ma zdecydować, co z tym zrobić. + """ + code = _HOUSE_CODES.get(req.system) + if code is None: + raise HTTPException(422, f"nieznany system domów: {req.system!r} " + f"(znane: {', '.join(sorted(_HOUSE_CODES))})") + d = req.when_utc + ut_hours = d.hour + d.minute / 60.0 + d.second / 3600.0 + jd = swe.julday(d.year, d.month, d.day, ut_hours) + try: + cusps, ascmc = swe.houses(jd, req.lat, req.lon, code) + except Exception as e: # poza dziedziną systemu + raise HTTPException( + 422, f"system {req.system!r} nie ma definicji dla φ={req.lat}: {e}") from e + + return { + "engine": "swisseph", + "system": req.system, + "cusps": [{"house": i + 1, "longitude": c % 360.0} for i, c in enumerate(cusps)], + "angles": {name: ascmc[i] % 360.0 for i, name in enumerate(_ASCMC) + if i < len(ascmc) and name in ("Asc", "MC", "ARMC", "Vertex")}, + } + + @app.get("/health") def health() -> dict: return {"engine": "swisseph", "status": "ok", "mode": "moshier", "license": "AGPL-3.0"} diff --git a/services/logic/app/engine/chart.py b/services/logic/app/engine/chart.py index c3b9fa2..dbf5263 100644 --- a/services/logic/app/engine/chart.py +++ b/services/logic/app/engine/chart.py @@ -60,7 +60,15 @@ def build_chart(engine: EphemerisEngine, moment: ChartMoment, house_system: str # współrzędnych TROPIKALNYCH of-date — deklinacja jest fizyczna (równikowa), # a antyscja z definicji tropikalna. Dlatego PRZED przesunięciem na zodiak, # z surowych długości/szerokości silnika. - eps = mean_obliquity(Z.julian_day(moment.when_utc)) + # ε PRAWDZIWE — to samo, którym liczymy domy, bo pozycje ze Skyfielda są + # POZORNE (uwzględniają nutację). Silnik bez sidereal() nutacji nie poda; + # wtedy zostaje średnie, z jawnym oznaczeniem w wyniku. + if hasattr(engine, "sidereal"): + eps = engine.sidereal(moment)[1] + result["obliquity_kind"] = "true" + else: + eps = mean_obliquity(Z.julian_day(moment.when_utc)) + result["obliquity_kind"] = "mean" result["obliquity"] = round(eps, 6) for pdict, obj in zip(result["positions"], positions): dec = declination(obj.longitude, obj.latitude, eps) diff --git a/services/logic/app/engine/skyfield_engine.py b/services/logic/app/engine/skyfield_engine.py index f17f3f8..b095d38 100644 --- a/services/logic/app/engine/skyfield_engine.py +++ b/services/logic/app/engine/skyfield_engine.py @@ -117,12 +117,28 @@ class SkyfieldEngine(EphemerisEngine): Materiał wejściowy do osi i domów (LOG-05). RAMC = GAST·15 + długość geo. """ - from app.engine.houses import mean_obliquity - t = self.ts.from_datetime(moment.when_utc) ramc = norm360(t.gast * 15.0 + moment.lon) - eps = mean_obliquity(t.tt) - return ramc, eps + return ramc, true_obliquity(t) def health(self) -> dict: return {"engine": self.name, "status": "ok", "kernel": self.kernel} + + +def true_obliquity(t) -> float: + """ε PRAWDZIWE (średnie + nutacja w nachyleniu), w stopniach. + + MUSI być prawdziwe, nie średnie. RAMC liczymy z `t.gast` — czasu gwiazdowego + POZORNEGO, mierzonego od równonocy PRAWDZIWEJ. Ekliptyka odniesiona do tej + samej równonocy ma ε z nutacją; sparowanie GAST z ε średnim miesza dwa układy + odniesienia. Kosztowało to ~3,2″ na cuspach domów i było niewidoczne dla + frameworka wyroczni, bo ten z założenia podaje to samo ε obu stronom + (izoluje samą funkcję domów) — patrz tests/oracle/README.md. + + Nutacja z serii IAU 2000A, czyli z tego samego źródła, którego Skyfield + używa do policzenia GAST — dzięki temu oba są spójne z definicji.""" + from skyfield.nutationlib import iau2000a, mean_obliquity + + mean_arcsec = float(mean_obliquity(t.tdb)) + d_eps_arcsec = float(iau2000a(t.tt)[1]) * 1e-7 # jednostki 0,1 µas + return (mean_arcsec + d_eps_arcsec) / 3600.0 diff --git a/services/logic/tests/test_houses.py b/services/logic/tests/test_houses.py index cdfbd55..6e492af 100644 --- a/services/logic/tests/test_houses.py +++ b/services/logic/tests/test_houses.py @@ -249,3 +249,48 @@ def test_equal_mc_starts_the_tenth_house_exactly_on_the_midheaven(): assert c[0] == pytest.approx(H.norm360(mc + 90.0), abs=1e-9) for i in range(12): # nadal równe 30° assert H.norm360(c[(i + 1) % 12] - c[i]) == pytest.approx(30.0, abs=1e-9) + + +# ── nachylenie ekliptyki: prawdziwe, nie średnie ───────────────────────── + +def test_sidereal_returns_true_obliquity_not_mean(): + """RAMC liczymy z GAST — czasu gwiazdowego POZORNEGO, mierzonego od + równonocy PRAWDZIWEJ. Ekliptyka odniesiona do tej samej równonocy ma ε + Z NUTACJĄ. Sparowanie GAST z ε średnim mieszało dwa układy odniesienia + i przesuwało cuspy domów o ~3″. + + Framework wyroczni tego NIE wykryje: z założenia podaje to samo ε obu + stronom, żeby izolować samą funkcję domów. Dlatego sprawdzian jest tutaj, + ze Skyfieldem jako niezależnym autorytetem.""" + from datetime import datetime, timezone + + from skyfield.api import load + from skyfield.nutationlib import mean_obliquity + + from app.engine.models import ChartMoment + from app.engine.skyfield_engine import SkyfieldEngine, true_obliquity + + when = datetime(1984, 4, 30, 9, 20, tzinfo=timezone.utc) + t = load.timescale().from_datetime(when) + _, eps = SkyfieldEngine().sidereal(ChartMoment(when_utc=when, lat=50.06, lon=19.94)) + + assert eps == pytest.approx(true_obliquity(t), abs=1e-12) + eps_mean = float(mean_obliquity(t.tdb)) / 3600.0 + assert eps != pytest.approx(eps_mean, abs=1e-9), "ε jest średnie — nutacja zgubiona" + # nutacja w nachyleniu nie przekracza ~9,2″; większa różnica to nie nutacja + assert abs(eps - eps_mean) * 3600.0 < 9.3 + + +def test_true_obliquity_stays_in_a_sane_band_across_the_date_range(): + """ε maleje ~0,013°/wiek. Na całym zakresie programu (370 p.n.e. – 2270 n.e.) + musi zostać w widełkach 23,2–23,8° — wyjście oznacza błąd jednostek.""" + from datetime import datetime, timezone + + from skyfield.api import load + + from app.engine.skyfield_engine import true_obliquity + + ts = load.timescale() + for year in (1600, 1900, 2000, 2100): + t = ts.from_datetime(datetime(year, 6, 1, tzinfo=timezone.utc)) + assert 23.2 < true_obliquity(t) < 23.8, year diff --git a/tests/oracle/README.md b/tests/oracle/README.md index 55d40a4..4fd3682 100644 --- a/tests/oracle/README.md +++ b/tests/oracle/README.md @@ -14,8 +14,25 @@ tysiące porównań na całej dziedzinie tak. **Izolacja jednostki.** Obu implementacjom podajemy TE SAME wejścia przez `swe_houses_armc`. Gdybyśmy porównywali „nasz horoskop" z „horoskopem swissepha", różnica mogłaby wynikać z innego czasu gwiazdowego albo innego ε — czyli z czegoś, -co nie jest testowaną funkcją, i utonęlibyśmy w fałszywych alarmach. Czas gwiazdowy -i ε mają własny, osobny test (`asc/mc`). +co nie jest testowaną funkcją, i utonęlibyśmy w fałszywych alarmach. + +**Czego ten framework NIE sprawdza — i trzeba o tym pamiętać.** Skoro ε podajemy +obu stronom, to **samo ε nie jest tu testowane**. Test `asc/mc` sprawdza wyłącznie +wzory na Ascendent i MC przy zadanym ε, a nie to, czy ε jest właściwe. Kosztowało +to realny błąd: silnik liczył RAMC z GAST (czas gwiazdowy POZORNY, od równonocy +PRAWDZIWEJ), ale parował go z ε ŚREDNIM, bez nutacji. Dwa różne układy odniesienia, +~3,2″ przesunięcia na cuspach — i komplet zielonych przebiegów wyroczni, bo błąd +siedział w danych WEJŚCIOWYCH, nie w testowanej funkcji. + +Wejście ma więc własny sprawdzian, poza tym frameworkiem: +`test_sidereal_returns_true_obliquity_not_mean` w `services/logic/tests/`, ze +Skyfieldem jako niezależnym autorytetem (bez swissepha, więc działa wszędzie). + +Uwaga pokrewna: porównanie „cały horoskop nasz vs cały horoskop swissepha" zostawia +resztę ~3″ nawet po naprawie ε — to UT1 kontra UTC. Skyfield konwertuje UTC na UT1 +z tablic IERS, swisseph przyjmuje podany JD jako UT1 (w 1984-04-30 różnica wynosiła +0,181 s = 2,7″ RAMC). Nasza strona jest tu dokładniejsza. Dokładnie po to porównujemy +przy identycznym RAMC. **Kryterium, nie procent.** Raportujemy liczbę przypadków **powyżej tolerancji (1″)**, **maksymalne odchylenie** i **miejsce** jego wystąpienia oraz histogram.