# Calendrier lunaire de jardinage – Guide complet

## Résumé exécutif  
Le **calendrier lunaire** de jardinage exploite la position et le cycle de la Lune (phases, déclinaison, périgée/apogée, nœuds) pour rythmer semis, plantations et récoltes. Cette approche traditionnelle, popularisée depuis le b.a.-ba de l’agriculture biodynamique, associe chaque jour lunaire à un type de culture (racine/feuille/fleur/fruit) et tient compte de la Lune montante ou descendante. **Attention toutefois**: la science moderne ne confirme aucune influence directe significative de la Lune sur la croissance des plantes【6†L373-L381】【5†L108-L116】. Néanmoins, beaucoup de jardiniers l’utilisent comme repère complémentaire. Ce document explique les notions astronomiques (phases, illumination, déclinaison, signes zodiacaux, périgée/apogée, nœuds), leur calcul en Python, les règles de jardinage associées, ainsi que le fonctionnement du script fourni (algorithme, limites, sortie). Des exemples de configuration (JSON/CSV) et des conseils d’amélioration (CLI, API, base, front-end) sont détaillés, ainsi qu’une section sur les dictons français du jardinage et les « saints de glace ».

## Concepts astronomiques du calendrier lunaire  

- **Phases lunaires** : La phase se définit par l’angle Lunaire-Solaire autour de la Terre. Concrètement, on calcule la différence de longitude écliptique entre la Lune et le Soleil【14†L123-L131】. Cette différence vaut 0° pour la Nouvelle Lune, 90° pour le Premier Quartier, 180° pour la Pleine Lune, 270° pour le Dernier Quartier (modulo 360°)【14†L123-L131】. En Python (Skyfield), on utilise `almanac.find_discrete(ts0,ts1, almanac.moon_phases(eph))` pour trouver les instants précis (UTC) de chaque phase.  

- **Illumination de la Lune** : Le pourcentage du disque lunaire éclairé se calcule par la géométrie Soleil–Terre–Lune. Si θ est la séparation angulaire (en radians) entre la Lune et le Soleil vue de la Terre, alors la fraction illuminée = (1–cos θ)/2. En code, `sep = v_sun.separation_from(v_moon).radians; illum = (1 - math.cos(sep))/2`. Skyfield offre aussi `moon.fraction_illuminated(sun)`, mais la formule ci-dessus est équivalente. Le script compare l’illumination d’un jour au lendemain pour déterminer si la Lune croît ou décroît.  

- **Lune montante / descendante** : On dit « Lune montante » si la déclinaison géocentrique de la Lune (angle par rapport à l’équateur céleste) augmente d’un jour sur l’autre. Sinon elle est « descendante ». Dans le script on calcule la déclinaison (`v_moon.radec()[1].degrees`) à midi un jour et le jour suivant. Exemple :  
  ```python
  dec = v_moon.radec()[1].degrees
  dec2 = v_moon2.radec()[1].degrees
  montante = dec2 >= dec  # True si Lune "montante"
  ```  
  La lune montante est traditionnellement favorable aux travaux aériens (semis, récoltes), la descendante aux travaux racinaires (plantation, taille).  

- **Signe zodiacal (longitude écliptique)** : La position de la Lune devant le zodiaque sert à définir le type de jour (racine/feuille/fleur/fruit). On calcule la longitude écliptique lunaire (0°–360°) via Skyfield (`v_moon.ecliptic_latlon()`). Le signe astrologique = int(longitude/30) (0=Bélier, 1=Taureau, …). Par convention :  
  - **Terre (Taureau, Vierge, Capricorne)** → *Jour Racine* (légumes-racines)【24†L44-L53】.  
  - **Eau (Cancer, Scorpion, Poissons)** → *Jour Feuille* (plantes feuillues)【24†L44-L53】.  
  - **Air (Gémeaux, Balance, Verseau)** → *Jour Fleur* (fleurs, choux-fleurs)【24†L50-L53】.  
  - **Feu (Bélier, Lion, Sagittaire)** → *Jour Fruit* (légumes-fruits)【24†L52-L55】.  
  Ces correspondances sont purement traditionnelles. Le script possède une table Python :  
  ```python
  SIGN_NAMES = ["Bélier","Taureau",…,"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"
  }
  signe = SIGN_NAMES[int(lon.degrees//30)]
  type_jour = SIGN_TO_TYPE[signe]
  ```  

- **Périgée / Apogée de la Lune** : L’orbite lunaire est elliptique. *Périgée* = point le plus proche de la Terre, *apogée* = point le plus éloigné【18†L108-L112】. Chaque lunaison comporte un périgée et un apogée. Skyfield n’a plus `almanac.moon_distance`, donc on calcule la distance Terre–Lune à midi chaque jour :  
  ```python
  dist = earth.at(ts.utc(date)).observe(moon).distance().km
  ```  
  On repère les minima locaux (périgée) et maxima locaux (apogée) dans la liste journalière. Ex.:  
  ```python
  distances = [earth.at(ts.utc(d.year,d.month,d.day,12,0,0)).observe(moon).distance().km for d in days]
  # repérer indices i tels que dist[i] < dist[i±1] → périgée
  ```  
  Traditionnellement, on **évite de jardiner** durant ces jours (le périgée apporterait «trop d’énergie», l’apogée «ralentissement de croissance»)【24†L66-L73】.  

- **Nœuds lunaires** : Ce sont les deux points où l’orbite de la Lune coupe l’écliptique【16†L155-L163】 (juste avant/après éclipses). On peut utiliser `almanac.moon_nodes(eph)` et `find_discrete` pour obtenir ces dates. Dans la pratique, les jours de nœuds sont considérés «perturbés» et déconseillés au jardinage【24†L66-L73】.

```mermaid
gantt
    dateFormat  YYYY-MM-DD
    title Phases lunaires (Mars 2026)
    section Phases
    Nouvelle lune        : 2026-03-03, 1d
    Premier quartier     : 2026-03-10, 1d
    Pleine lune          : 2026-03-18, 1d
    Dernier quartier     : 2026-03-25, 1d
```

## Liens vers les pratiques de jardinage  
Les astronomes jardiniers ont formulé ces règles pratiques (purement empiriques)【7†L208-L214】【20†L24-L32】 :  
- **Lune croissante** (montante) – *moment d’action au-dessus du sol* : semis de légumes-fruits, greffage, récolte. Exemple : on sème haricots/tomates le premier quartier【7†L208-L214】.  
- **Lune décroissante** (descendante) – *moment d’action sur racines/sol* : plantations, repiquages, binage, taille. Ex.: planter pommes de terre en lune descendante【7†L208-L214】.  
- **Jour “Racine”** (signe de Terre) : planter légumes-racines (carottes, betteraves)【24†L44-L53】.  
- **Jour “Feuille”** (signe d’Eau) : semer feuilles et aromatiques (laitues, épinards)【24†L44-L53】.  
- **Jour “Fleur”** (signe d’Air) : greffer et soigner fleurs/ornementales (brocolis, roses)【24†L50-L53】.  
- **Jour “Fruit”** (signe de Feu) : semer/planter légumes-fruits (tomates, courgettes, arbres fruitiers)【24†L52-L55】.  

Un tableau synthétique :  

| **Phase / Jour lunaire**      | **Action jardin**                 | **Exemple**                             |
|-------------------------------|-----------------------------------|-----------------------------------------|
| Croissante (Nouvelle→Pleine)  | Développement aérien – semis/greffe| Semer tomates au premier quartier【7†L208-L214】 |
| Décroissante (Pleine→Nouvelle)| Consolidation – planter, tailler   | Planter pommes de terre en lune descendante【7†L208-L214】 |
| Lune montante                 | Semis/engrais/ récoltes           | Récolter herbes aromatiques【7†L208-L214】 |
| Lune descendante             | Planter/tailler/travailler le sol  | Repiquer laitues, tailler rosiers【7†L208-L214】 |
| Jour **Racine** (Terre)      | Légumes-racines (oignons, navets) | Semer carottes (Lune en Taureau)【24†L44-L53】 |
| Jour **Feuille** (Eau)       | Laitues, choux, épinards          | Semer épinards (Lune en Cancer)【24†L44-L53】 |
| Jour **Fleur** (Air)         | Fleurs, brocolis, vivaces         | Planter choux-fleurs (Lune en Balance)【24†L50-L53】 |
| Jour **Fruit** (Feu)         | Tomates, haricots, pois           | Semer tomates (Lune en Lion)【24†L52-L55】 |
| Nœuds lunaires               | *Éviter tout travail*             | (période d’éclipse, jours “perturbés”)【24†L66-L73】 |
| Périgée / Apogée             | *Éviter/attention*                | Récoltes précoces, éviter tailes risquées【24†L66-L73】 |

En pratique, on imprime souvent un calendrier lunaire annuel (papier ou appli mobile) pour suivre ces repères【24†L54-L60】【22†L66-L73】. À titre d’exemple, voici la correspondance **signes zodiacaux → type de jour**, sous forme tabulaire :

| Signe zodiacal              | Élément | Type de jour | Exemples de cultures                |
|-----------------------------|---------|--------------|--------------------------------------|
| Bélier, Lion, Sagittaire    | Feu     | Fruit        | Tomates, poivrons, arbres fruitiers  |
| Taureau, Vierge, Capricorne | Terre   | Racine       | Carottes, pommes de terre, oignons   |
| Gémeaux, Balance, Verseau   | Air     | Fleur        | Fleurs, choux-fleurs, aromatiques    |
| Cancer, Scorpion, Poissons  | Eau     | Feuille      | Laitues, épinards, choux, salades    |

Ces associations sont présentées par exemple dans Semencemag【24†L44-L53】. 

## Le script Python : description technique

Le script `lunar_calendar.py` (Python 3.9+) génère un calendrier lunaire sur une période donnée. Points clés du fonctionnement :

- **Dépendances** : `skyfield` (pour l’astronomie), `pytz` (timezones), `numpy`. `de421.bsp` est téléchargé automatiquement (éphéméride NASA).  
- **Période de calcul** : par défaut un an (Jan→Déc). On peut modifier `start` et `end` dans la section `__main__`.  
- **Fuseau horaire** : Europe/Paris. On prend l’heure locale *midi* pour éviter les transitions de date, puis on convertit en UTC pour Skyfield :  
  ```python
  TZ = pytz.timezone("Europe/Paris")
  local_noon = TZ.localize(datetime(year,month,day,12))
  t = ts.utc(local_noon.astimezone(pytz.utc))
  ```  
  Ceci garantit que chaque date du calendrier correspond bien au jour solaire local.  

- **Phases exactes** :  
  ```python
  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().astimezone(TZ).date()
      phase_by_day[local_day] = ["Nouvelle Lune","Premier Quartier","Pleine Lune","Dernier Quartier"][int(ev)]
  ```  
  On récupère ainsi les jours (par date locale) où surviennent exactement la NL, PQ, PL, DQ. Ces étiquettes sont stockées dans `phase_by_day`.

- **Illumination et montante/descendante** : Pour chaque jour `d`, on calcule :  
  ```python
  e = earth.at(t)                      # position de la Terre à midi UTC
  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       # fraction (0..1) éclairée
  ```  
  Puis pour le lendemain, même calcul (`illum2`, `dec2`). On définit :  
  ```python
  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"
  ```  
  C’est-à-dire la Lune est “montante” si sa déclinaison augmente.  

- **Signe zodiacal → type de jour** : Toujours à midi, on récupère la longitude écliptique :  
  ```python
  lat, lon, dist = v_moon.ecliptic_latlon()
  signe = SIGN_NAMES[int(lon.degrees // 30) % 12]
  type_jour = SIGN_TO_TYPE[signe]
  ```  
  Ainsi on remplit `signe` (ex. “Taureau”) et `type_jour` (“Racine”, etc) pour chaque date.

- **Périgée/Apogée manuel** : Après avoir construit une liste quotidienne de distances (voir ci-dessus), on parcourt les valeurs : si `dist[i] < dist[i-1]` et `< dist[i+1]`, c’est un **périgée** (jour local minimal). Inversement pour un **apogée**. Ce repérage simple identifie un périgée et un apogée par lunaison. Exemple :  
  ```python
  if distances[i] < distances[i-1] and distances[i] < distances[i+1]:
      perigee_days.add(all_days[i])
  if distances[i] > distances[i-1] and distances[i] > distances[i+1]:
      apogee_days.add(all_days[i])
  ```  
  Ces jours sont marqués dans l’export pour information.  

- **Nœuds lunaires** : On utilise directement `almanac.moon_nodes(eph)` et `find_discrete` entre `t0` et `t1`. On convertit chaque instant en date locale pour obtenir `node_days`.

**Limitations et précision** :  
- Le calcul se fait au pas d’un jour (midi). Il n’est donc pas d’une précision horaire au-delà du jour (assez pour un calendrier de plantation).  
- Le passage entre heures d’été/hiver est géré par `pytz`.  
- Les assignations *racine/feuille/fleur/fruit* reposent sur des conventions astrologiques. Elles sont cohérentes avec la littérature francophone (Semencemag【24†L44-L53】, Rustica, etc.) mais non scientifiques.  
- Les algorithmes Skyfield sont précautionneusement utilisés pour donner des résultats très fiables sur plusieurs décennies.  

## Installation et tests

1. **Python 3.9+** : Vérifier (`python3 --version`).  
2. **Environnement virtuel** (optionnel mais recommandé) :  
   ```bash
   cd /path/to/projet
   python3 -m venv .venv
   source .venv/bin/activate  # prompt indique (.venv)
   ```  
3. **Installer les dépendances** :  
   ```bash
   pip install --upgrade pip
   pip install skyfield numpy pytz
   ```  
   Vérifier : `pip list` doit lister `skyfield`, `numpy`, `pytz`.  
4. **Lancer le script** (`lunar_calendar.py`) :  
   ```bash
   python lunar_calendar.py
   ```  
   – Au premier lancement, `skyfield` télécharge automatiquement `de421.bsp`.  
   – Un message “Calendrier lunaire généré” doit s’afficher. Le fichier `calendrier_lunaire_2026.json` (ou défini dans le script) est créé.  
5. **Vérifier le résultat** :  
   ```bash
   head -n 5 calendrier_lunaire_2026.json
   ```  
   ou  
   ```bash
   cat calendrier_lunaire_2026.json | jq .
   ```  
   Exemple de ligne JSON produite :  
   ```json
   {
     "date": "2026-03-14",
     "phase": "",
     "illumination": 67.34,
     "croissante_decroissante": "Croissante",
     "montante_descendante": "Montante",
     "signe": "Taureau",
     "type_jour": "Racine",
     "perigee": false,
     "apogee": false,
     "noeud_lunaire": false
   }
   ```  
   Cette ligne indique qu’au 14/03/2026, la Lune est en *Taureau* (Jour Racine), croissante et montante, sans phase particulière ni événement spécial.

**Commandes utiles** :  
- Tester l’import Skyfield : `python -c "from skyfield.api import load; print('Skyfield OK')"`  
- Debug : ajouter `print` pour les valeurs (illumination, décli, etc.) si nécessaire.  

## Exemples d’usage et sorties

Le script génère un **JSON** (tableau d’objets quotidiens). On peut facilement adapter pour un **CSV**. Par exemple, le module Python `csv` est prêt à l’emploi (démontré dans le code source). Les champs exportés sont : date, phase, « croissante/décroissante », « montante/descendante », signe, type de jour, booleans périgée/apogée/nœud.  

Un exemple de format CSV (séparateur `;`) :  
```csv
date;phase_exacte;croissante_décroissante;montante_descendante;signe;type_jour;perigee;apogee;noeud
2026-03-14;;Croissante;Montante;Taureau;Racine;0;0;0
2026-03-15;Dernier Quartier;Décroissante;Descendante;Bélier;Fruit;0;0;0
...
```  
Ce fichier peut être importé en base de données (SQLite) ou servi via une API (FastAPI) pour alimenter une interface web/mobile.  

## Améliorations possibles et pièges à éviter  

- **Arguments en ligne de commande** : utiliser `argparse` pour accepter `--start`, `--end`, `--format` (JSON/CSV).  
- **FastAPI ou Flask** : créer un endpoint `/api/lune/{year}` qui lit le JSON pré-calculé ou exécute dynamiquement le calcul. Attention à la latence du calcul si fait à la volée (mieux pré-calculer).  
- **Base de données** : pré-calculer plusieurs années (5–10 ans) et stocker en SQLite avec une table indexée sur date. Permet d’interroger rapidement pour une date donnée.  
- **Timezones** : toujours utiliser `pytz` et `ASTimezone` pour éviter les décalages DST erronés. Tester en hiver/été.  
- **Précision** : le calcul d’événements précis (phase à l’heure près) est assuré par Skyfield. Pour le quotidien, on s’en tient au repère “jour où l’événement tombe (UTC→local)”.  
- **Interface graphique** : ajouter un calendrier réactif (HTML/CSS/JS) coloré par type de jour (ex. : orange racine, vert feuille, violet fleur, jaune fruit), marquer les événements spéciaux (noeuds en rouge discret, périgée/apogée en gris). Gruvbox ou autre thème sombre/contrasté pour développeurs.  
- **Stockage des données** : suggestions JSON/CSV ci-dessus, ou génération de JSON à partir de SQLite. Ex:  
  ```sql
  CREATE TABLE lune (
    date TEXT PRIMARY KEY,
    phase TEXT, lumiere REAL,
    croiss_dec TEXT, mont_dec TEXT,
    signe TEXT, type_jour TEXT,
    perigee INTEGER, apogee INTEGER, noeud INTEGER
  );
  ```  
- **Documentation** : ajouter des tests unitaires, du logging, et un README (vous êtes ici !).  

## Dictons et proverbes populaires du jardinage  

La tradition française regorge de **dictons et proverbes** relatifs aux saisons et au jardinage. En voici quelques exemples :

- « À chaque plante son temps, à chaque temps sa plante » – on plante/sème selon la saison appropriée【32†L118-L121】.  
- « Tel est le jardinier, tel est le jardin » – l’état du potager reflète les soins du jardinier【32†L105-L109】.  
- « En avril, ne te découvre pas d’un fil » – prudence contre les dernières gelées tardives.  
- « Jamais trop tôt pour semer, jamais trop tard pour récolter » – planter semis précoces et récolter tardivement.  
- « La patience est la mère des jardiniers » – la réussite vient avec l’observation et le temps【32†L158-L161】.  

Ces dictons reflètent l’observation empirique. Aucune librairie Python spécifique aux proverbes français n’est connue. On peut les stocker dans un fichier JSON ou CSV pour usage interne. Par exemple, un format JSON possible :  
```json
[
  {
    "dicton": "En avril, ne te découvre pas d'un fil",
    "signification": "Ne pas ôter les protections trop tôt car les gelées peuvent revenir tardivement.",
    "source": "Proverbe populaire"
  },
  {
    "dicton": "À chaque plante son temps, à chaque temps sa plante",
    "signification": "Chaque semis/plantation doit se faire en fonction de la saison appropriée.",
    "source": "Santamaria Motoculture【32†L118-L121】"
  }
]
```  
On ajoutera «source» ou «conseil associé» selon besoins. Si besoin de proverbes automatiques, on utilisera plutôt une API publique de citations (ex. «Proverbes français» non automatique) plutôt qu’une librairie locale. 

## Calendrier des saints de glace (France)  

En France, de nombreux dictons s’appuient sur le **calendrier des saints**. Les plus célèbres pour le jardinage sont les **Saints de Glace** (traditionnellement 11, 12, 13 mai – Mamert, Pancrace, Servais) et les saints qui les prolongent (Yves 19/5, Urbain 25/5). Ces dates marquent la fin présumée des gelées printanières. Exemples de dictons associés【39†L155-L164】【42†L209-L212】 :

- **11 mai (St Mamert), 12 mai (St Pancrace), 13 mai (St Servais)** : *« Avant Saint-Servais, point d’été ; après Saint-Servais, plus de gelée. »*【39†L155-L164】 conseille d’attendre la mi-mai.  
- **Saint-Urbain (25 mai)** : *« Quand la Saint-Urbain est passée, le vigneron est rassuré. »*【42†L209-L212】 (fin définitive du risque de gel).  
- Variante : *« Mamert, Pancrace, Servais sont trois saints de glace, mais Saint-Urbain les tient tous dans sa main. »*【42†L209-L212】.  
- **Saint-Pancrace (12/5), St-Servais (13/5), St-Boniface (14/5)** : *« Saints Pancrace, Servais et Boniface apportent souvent de la glace. »*【42†L209-L212】.  

Le *calendrier des saints* est large : on trouve par région d’autres saints réputés «glaçants» en avril (Georges 23/4, Marc 25/4, etc.). Mais pour la France métropolitaine, c’est la période mi-mai qui domine ces dictons. En résumé : mieux vaut repousser l’installation des cultures sensibles au froid (tomates, etc.) jusqu’à fin mai【39†L155-L164】【40†L81-L88】. 

## Références et lectures suggérées

- **Skyfield API** – Exemples de calculs astronomiques (phases, positions)【14†L123-L131】.  
- **Documentation SO/USNO** – Éphémérides officielles pour la Lune (phases, illumination)【18†L108-L112】.  
- **Journaux et blogs FR** – Articles de vulgarisation : Semencemag (juin 2025) sur l’usage du calendrier lunaire【24†L44-L53】, Rustica, Gerbeaud.  
- **Sources historiques** – Dictons et fêtes des saints : «Les saints de glace» sur le Potager Permacole【42†L209-L212】, revue Science et Vie (SNHF) pour le scepticisme scientifique【6†L373-L381】.  
- **Ressources additionnelles** : RFC et documentation FastAPI, tutoriels Skyfield (rhodesmill.org), bases de données open (p. ex. base de dictons BotAccess).  

Ce README est prêt à être sauvegardé comme document `README.md`. Il offre un point de départ complet pour un projet de **webapp jardinage** incorporant un calendrier lunaire.