feat(backend): service cache Redis pour identifications

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/services/lunar.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+from dataclasses import dataclass, asdict
+from datetime import date, datetime, timedelta
+import math
+from pathlib import Path
+import pytz
+from skyfield.api import load
+from skyfield import almanac
+
+TZ = pytz.timezone("Europe/Paris")
+SIGN_NAMES = [
+    "Bélier", "Taureau", "Gémeaux", "Cancer", "Lion", "Vierge",
+    "Balance", "Scorpion", "Sagittaire", "Capricorne", "Verseau", "Poissons",
+]
+SIGN_TO_TYPE = {
+    "Taureau": "Racine", "Vierge": "Racine", "Capricorne": "Racine",
+    "Cancer": "Feuille", "Scorpion": "Feuille", "Poissons": "Feuille",
+    "Gémeaux": "Fleur", "Balance": "Fleur", "Verseau": "Fleur",
+    "Bélier": "Fruit", "Lion": "Fruit", "Sagittaire": "Fruit",
+}
+
+
+@dataclass
+class DayInfo:
+    date: str
+    phase: str
+    illumination: float
+    croissante_decroissante: str
+    montante_descendante: str
+    signe: str
+    type_jour: str
+    perigee: bool
+    apogee: bool
+    noeud_lunaire: bool
+
+
+def zodiac_sign_from_lon(lon_deg: float) -> str:
+    return SIGN_NAMES[int(lon_deg // 30) % 12]
+
+
+def _local_noon(d: date) -> datetime:
+    return TZ.localize(datetime(d.year, d.month, d.day, 12, 0, 0))
+
+
+def _compute_perigee_apogee_days(
+    ts, earth, moon, start: date, end: date
+) -> tuple[set[date], set[date]]:
+    sample_start = datetime.combine(start - timedelta(days=1), datetime.min.time())
+    sample_end = datetime.combine(
+        end + timedelta(days=1), datetime.max.time().replace(microsecond=0)
+    )
+    samples = []
+    current = TZ.localize(sample_start)
+    end_local = TZ.localize(sample_end)
+    step = timedelta(hours=1)
+    while current <= end_local:
+        t = ts.utc(current.astimezone(pytz.utc))
+        dist_km = earth.at(t).observe(moon).distance().km
+        samples.append((current.date(), dist_km))
+        current += step
+    perigee_days, apogee_days = set(), set()
+    for i in range(1, len(samples) - 1):
+        day, dist = samples[i]
+        if not (start <= day <= end):
+            continue
+        prev_dist = samples[i - 1][1]
+        next_dist = samples[i + 1][1]
+        if dist < prev_dist and dist < next_dist:
+            perigee_days.add(day)
+        if dist > prev_dist and dist > next_dist:
+            apogee_days.add(day)
+    return perigee_days, apogee_days
+
+
+def build_calendar(start: date, end: date) -> list[DayInfo]:
+    if end < start:
+        raise ValueError(f"Invalid date range: {start} > {end}")
+    ts = load.timescale()
+    eph = load("de421.bsp")
+    earth, moon, sun = eph["earth"], eph["moon"], eph["sun"]
+    t0 = ts.utc(start.year, start.month, start.day)
+    t1 = ts.utc(end.year, end.month, end.day + 1)
+    f_phase = almanac.moon_phases(eph)
+    phase_times, phase_events = almanac.find_discrete(t0, t1, f_phase)
+    phase_by_day = {}
+    for t, ev in zip(phase_times, phase_events):
+        local_day = (
+            t.utc_datetime().replace(tzinfo=pytz.utc).astimezone(TZ).date()
+        )
+        phase_by_day[local_day] = [
+            "Nouvelle Lune", "Premier Quartier", "Pleine Lune", "Dernier Quartier"
+        ][int(ev)]
+    f_nodes = almanac.moon_nodes(eph)
+    node_times, _ = almanac.find_discrete(t0, t1, f_nodes)
+    node_days = set()
+    for t in node_times:
+        local_day = (
+            t.utc_datetime().replace(tzinfo=pytz.utc).astimezone(TZ).date()
+        )
+        node_days.add(local_day)
+    perigee_days, apogee_days = _compute_perigee_apogee_days(
+        ts, earth, moon, start, end
+    )
+    result = []
+    d = start
+    while d <= end:
+        local_noon = _local_noon(d)
+        t = ts.utc(local_noon.astimezone(pytz.utc))
+        e = earth.at(t)
+        v_sun = e.observe(sun).apparent()
+        v_moon = e.observe(moon).apparent()
+        sep = v_sun.separation_from(v_moon).radians
+        illum = (1 - math.cos(sep)) / 2
+        d2 = d + timedelta(days=1)
+        local_noon2 = _local_noon(d2)
+        t2 = ts.utc(local_noon2.astimezone(pytz.utc))
+        e2 = earth.at(t2)
+        v_sun2 = e2.observe(sun).apparent()
+        v_moon2 = e2.observe(moon).apparent()
+        sep2 = v_sun2.separation_from(v_moon2).radians
+        illum2 = (1 - math.cos(sep2)) / 2
+        croissante = "Croissante" if illum2 >= illum else "Décroissante"
+        dec = v_moon.radec()[1].degrees
+        dec2 = v_moon2.radec()[1].degrees
+        montante = "Montante" if dec2 >= dec else "Descendante"
+        lat, lon, dist = v_moon.ecliptic_latlon()
+        signe = zodiac_sign_from_lon(lon.degrees % 360.0)
+        type_jour = SIGN_TO_TYPE[signe]
+        result.append(
+            DayInfo(
+                date=d.isoformat(),
+                phase=phase_by_day.get(d, ""),
+                illumination=round(illum * 100, 2),
+                croissante_decroissante=croissante,
+                montante_descendante=montante,
+                signe=signe,
+                type_jour=type_jour,
+                perigee=(d in perigee_days),
+                apogee=(d in apogee_days),
+                noeud_lunaire=(d in node_days),
+            )
+        )
+        d += timedelta(days=1)
+    return result