feat(M6): agenda théorique JSON avec parité des semaines et vacances scolaires

Implémentation complète de la source d'agenda théorique :

- model.py : modèles Pydantic de parsing JSON (TheoreticalLessonEntry,
  TheoreticalAgendaFile) avec validation des formats d'heure et de l'ordre
  début/fin.
- parity.py : WeekParityService déterministe calculant la parité d'une
  semaine (paire/impaire) à partir d'une date de référence.
- holidays.py : SchoolHolidayCalendar lisant un fichier JSON de vacances
  scolaires (zone A) avec bornes inclusives.
- provider.py : protocole TheoreticalAgendaProvider (get_lessons,
  get_lessons_for_range).
- file.py : JsonTheoreticalAgendaProvider implémentant le protocole :
  filtrage par parité et vacances, génération d'IDs déterministes
  incluant le type de semaine, validation de l'unicité des IDs,
  tri stable par identifiant.
- __init__.py : factory get_theoretical_provider câblant la
  configuration (None si désactivé, erreur si config de parité partielle).
- Fixtures : theoretical.json (9 leçons all/even/odd) et
  school_holidays.json (zone A, 4 périodes).
- 57 tests unitaires couvrant parsing, parité, vacances, provider,
  factory, déduplication de range, collisions d'IDs.
- Guide : §8 et §12 alignés avec le format JSON.

Co-authored-by: opencode/coder <coder@agents.invalid>
Co-authored-by: opencode/test-engineer <test-engineer@agents.invalid>

.env.example

@@ -22,7 +22,10 @@ SYNC_PAST_DAYS=7
 SYNC_FUTURE_DAYS=30
 
 # --- Agenda théorique ---
-THEORETICAL_AGENDA_PATH=./data/theoretical.ics
+THEORETICAL_AGENDA_PATH=./data/theoretical.json
+SCHOOL_HOLIDAYS_PATH=./data/school_holidays.json
+THEORETICAL_WEEK_ANCHOR_DATE=2026-09-01
+THEORETICAL_WEEK_ANCHOR_TYPE=even
 
 # --- XMPP ---
 XMPP_ENABLED=false

.gitignore

@@ -49,6 +49,10 @@ Thumbs.db
 .caldav_sync_state.json
 *.state.json
 
+# --- Local scratch / WIP files ---
+FIXME_*
+TEST_*
+
 # --- Logs ---
 *.log
 

.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
         name: mypy
         entry: mypy
         language: python
-        additional_dependencies: ["mypy>=1.10.0", "pydantic>=2.0.0", "pydantic-settings>=2.0.0", "pytest>=8.0.0", "types-requests>=2.31.0", "icalendar>=5.0.0", "pronotepy>=2.15.0", "responses>=0.25.0", "pytest-mock>=3.10.0"]
+        additional_dependencies: ["mypy>=1.10.0", "pydantic>=2.0.0", "pydantic-settings>=2.0.0", "pytest>=8.0.0", "types-requests>=2.31.0", "icalendar>=5.0.0", "pronotepy>=2.15.0", "responses>=0.25.0", "pytest-mock>=3.10.0", "feedparser>=6.0.0"]
         types: [python]
         pass_filenames: true
 

.secrets.baseline

@@ -140,10 +140,10 @@
         "filename": "GUIDE_DEV_PYTHON.md",
         "hashed_secret": "90bd1b48e958257948487b90bee080ba5ed00caa",
         "is_verified": true,
-        "line_number": 5124,
+        "line_number": 5046,
         "is_secret": false
       }
     ]
   },
-  "generated_at": "2026-09-06T13:36:29Z"
+  "generated_at": "2026-09-06T21:06:14Z"
 }

AGENTS.md

@@ -14,9 +14,10 @@
 ## 2. Stack technique
 
 ### Langage et dépendances
-- **Python** : ≥ 3.13 (actuellement 3.14 dans `.venv/`)
+- **Python** : ≥ 3.13.5 (actuellement 3.14 dans `.venv/`)
 - **Dépendances principales** :
-  `pydantic>=2.0`, `pydantic-settings`, `icalendar`, `caldav`, `slixmpp`, `pronotepy`, `feedparser`, `requests`, `httpx`
+  `pydantic>=2.0`, `pydantic-settings`, `icalendar`, `caldav`, `slixmpp`, `pronotepy`,
+  `feedparser`, `beautifulsoup4`, `requests`, `httpx`, `openai`
 
 ### Outils de développement
 - **Linter** : `ruff` (longueur de ligne : 100)
@@ -36,6 +37,7 @@
 ```
 pronote_sync/
 ├── config/          # Configuration et paramètres
+├── errors.py        # Hiérarchie canonique des erreurs du pipeline
 ├── models/          # Modèles de données (Pydantic v2)
 ├── sources/         # Connecteurs (Pronote, iCal, etc.)
 ├── sync/            # Logique de synchronisation
@@ -110,6 +112,8 @@ pronote-sync --dry-run
 
 ### Architecture
 - **Injection de dépendances** : Utiliser `typing.Protocol` et une **composition root** dans `pipeline/run.py`. **Interdiction** des singletons globaux.
+- **Erreurs** : Conserver une seule hiérarchie dans `pronote_sync/errors.py` ; ne pas créer de
+  doublon dans `pipeline/steps/errors.py`.
 
 ### Style
 - **Longueur de ligne** : 100 caractères maximum (configuré dans `ruff`).
@@ -123,12 +127,30 @@ pronote-sync --dry-run
 - **Idempotence** : Deux exécutions identiques sans changement externe doivent produire le **même résultat**.
 - **Mode dégradé** :
   - Si l'IA échoue → retourner un message **sans synthèse**.
-  - Si `pronotepy` échoue → fallback vers le parsing **iCal**.
+  - En mode source `auto`, essayer iCal puis utiliser `pronotepy` uniquement si iCal lève une
-  - Si tout échoue → lever une **erreur explicite**.
+    exception.
+  - En mode source explicite (`ical` ou `pronotepy`), ne pas changer silencieusement de source.
+  - En mode `auto`, si iCal et `pronotepy` échouent → lever une erreur critique explicite.
+  - Une liste vide est un succès valide ; elle ne doit pas être assimilée à une panne.
+
+### Contrat des sources Pronote
+- `PRONOTE_URL` (connexion API) et `PRONOTE_ICAL_URL` (flux iCal sensible) sont deux paramètres
+  distincts ; ne pas déduire l'un de l'autre.
+- Le compte actuellement visé est un compte parent : utiliser
+  `pronotepy.ParentClient(pronote_url, username, password, ent=ent_function)`.
+- Résoudre le slug `PRONOTE_ENT` vers une fonction de `pronotepy.ent` au moyen d'une liste fermée.
+- Exposer séparément les cours et les devoirs dans le client ; filtrer les devoirs `pronotepy` sur
+  la date cible.
+- Les récupérations critiques agenda/devoirs propagent une erreur expurgée ; seuls les messages et
+  informations non critiques peuvent se dégrader en liste vide avec warning.
+- Réutiliser un téléchargement/parsing iCal pour l'agenda et les devoirs pendant un même run, sans
+  cache global ni persistant.
 
 ### Documentation (docstrings)
 - **Obligatoire** : **Toute** fonction, méthode et classe publique doit avoir une docstring.
 - **Format** : Utiliser le format **Sphinx/reST** (pas Google ou NumPy) pour une compatibilité native avec Sphinx.
+- **Priorité** : Les blocs historiques de `GUIDE_DEV_PYTHON.md` utilisant `Args:`/`Returns:` sont
+  illustratifs ; le format Sphinx/reST défini ici prévaut pour le code de production.
 - **Contenu** :
   - Une ligne de résumé courte (une phrase).
   - Une description étendue optionnelle.
@@ -157,6 +179,11 @@ def fetch_ical(url: str) -> str:
 ### Règles absolues
 - **Aucun secret en clair** : Ni dans le code, ni dans les logs, ni dans les erreurs, ni dans les fixtures.
 - **Masquage** : Utiliser systématiquement `redact_url()`, `redact_secrets()`, et `redact_exception()` depuis `utils/redaction.py`.
+- **Chaînage d'exceptions** : Ne jamais conserver comme `__cause__` ou `__context__` une exception
+  externe brute susceptible de contenir un secret. Journaliser la version expurgée puis utiliser
+  `raise ... from None`, ou chaîner une cause elle-même expurgée.
+- **Tests de non-fuite** : Vérifier les messages, les logs, `__cause__`, `__context__` et le
+  traceback complet avec des sentinelles distinctes pour chaque secret.
 
 ### Bonnes pratiques
 - **Types sécurisés** : Les mots de passe et clés API doivent utiliser `pydantic.SecretStr`.
@@ -225,14 +252,17 @@ Les rôles d'agents disponibles pour ce projet sont les suivants :
 
 ## 10. Workflow de modification
 
-1. Lire la demande, [`TODO.md`](./TODO.md), `git status` et les fichiers concernés.
+1. Lire la demande, [`TODO.md`](./TODO.md), les sections pertinentes de
+   [`GUIDE_DEV_PYTHON.md`](./GUIDE_DEV_PYTHON.md), `git status` et les fichiers concernés.
 2. Préserver les changements existants de l'utilisateur.
 3. Pour une correction, reproduire d'abord le défaut avec un test automatisé lorsque c'est raisonnable.
-4. Faire une modification étroite et cohérente, en respectant les conventions du projet (idempotence, mode dégradé, repli iCal/pronotepy).
+4. Faire une modification étroite et cohérente, en respectant les conventions du projet
+   (idempotence, modes explicites stricts et repli iCal → `pronotepy` uniquement en mode `auto`).
 5. Faire vérifier le comportement par `@verifier` (ruff, mypy, pytest, bandit) et les cas d'erreur, notamment :
    - Succès de la synchronisation Pronote → CalDAV/XMPP.
-   - Repli vers iCal en cas d'échec de `pronotepy`.
+   - Repli d'iCal vers `pronotepy` en mode `auto`, sans repli dans les modes explicites.
-   - Gestion des erreurs explicites.
+   - Distinction entre résultat vide et échec des sources.
+   - Gestion des erreurs explicites sans fuite dans les causes ou tracebacks.
 6. Mettre à jour la documentation et les exemples dans le même changement si leur comportement public évolue.
 7. Cocher dans [`TODO.md`](./TODO.md) uniquement les éléments entièrement réalisés et validés.
 8. Terminer avec un *handoff* concis : fichiers modifiés, validations exécutées, limites et prochaine étape.
@@ -277,7 +307,8 @@ Les rôles d'agents disponibles pour ce projet sont les suivants :
 
 Un changement est considéré comme **terminé** lorsque :
 
-- Le cas nominal et les échecs pertinents sont testés (ex. : synchronisation réussie, repli iCal, erreurs explicites).
+- Le cas nominal et les échecs pertinents sont testés (ex. : synchronisation réussie, repli
+  iCal → `pronotepy` en mode `auto`, modes explicites stricts, erreurs explicites).
 - Les outils de validation (`ruff`, `mypy`, `pytest`, `bandit`) passent sans erreur.
 - Aucun secret ni configuration locale n'apparaît dans le diff ou les fichiers suivis.
 - La documentation reste cohérente avec le code (ex. : mise à jour des exemples, des contrats ou des décisions d'architecture).

TODO.md

@@ -74,18 +74,22 @@ Définir tous les modèles de domaine, immuables pour les contrats, mutables pou
 Récupérer et normaliser l'agenda, les devoirs et les messages Pronote, avec repli entre iCal et pronotepy.
 
 - [x] Créer `sources/pronote/ical.py` : `fetch_ical(url)` (HTTP via `requests`, erreurs redactées) et parsing iCal → `Lesson`/`Homework`/`SchoolEvent` (`icalendar`).
-- [x] Extraire les blocs de devoirs (`HomeworkBlock`) depuis `DESCRIPTION` et dédupliquer les devoirs (clé normalisée par date).
+- [x] Extraire les blocs de devoirs (`HomeworkBlock`) depuis `DESCRIPTION` dans une séquence qui préserve plusieurs blocs à la même date ; dédupliquer ensuite via `collect_homeworks(lessons, target_date)`.
 - [x] Détecter les statuts (`CANCELLED`/`MOVED`) via `CATEGORIES` et `STATUS:CANCELLED`.
-- [x] Créer `sources/pronote/client.py` : client `pronotepy` (messages, informations, discussions, sondages, et devoirs en repli) avec masquage des erreurs.
+- [x] Ajouter `PRONOTE_URL` à la configuration et créer `sources/pronote/client.py` autour de `pronotepy.ParentClient(pronote_url, username, password, ent=ent_function)` ; résoudre le slug ENT par liste fermée.
+- [x] Exposer séparément les cours, devoirs, messages et informations dans le client `pronotepy` ; filtrer les devoirs sur `due_on == target_date`.
 - [x] Créer `sources/pronote/fallback.py` : sélection de source selon `PRONOTE_*_SOURCE` (auto/ical/pronotepy) et `PronoteFetcher` unifiant `fetch_agenda`/`fetch_homework`/`fetch_messages`.
-- [x] Implémenter le repli unique : source primaire + un seul repli (l'autre source si configurée) ; les deux échouent → `PipelineCriticalError`.
+- [x] Implémenter le contrat de source : modes `ical`/`pronotepy` stricts ; mode `auto` = iCal puis repli `pronotepy` uniquement sur exception ; deux échecs en `auto` → `PipelineCriticalError`.
+- [x] Distinguer un succès vide d'un échec : les récupérations critiques agenda/devoirs propagent une erreur expurgée ; seuls les messages/informations non critiques peuvent se dégrader en liste vide avec warning.
 - [x] Normaliser les UID via `utils/uid.normalize_pronote_uid` pour la stabilité des événements.
 
 ### Critères d'acceptation
-- `fetch_ical` parse `tests/fixtures/pronote-4e.ics` en leçons/devoirs/événements corrects (cours annulé détecté).
+- `parse_ical` parse `tests/fixtures/pronote-4e.ics` en leçons/événements corrects, conserve les blocs bruts et retourne une liste de `Homework` vide ; `collect_homeworks` retourne ensuite le devoir attendu pour la date cible.
-- Le client pronotepy récupère messages/devoirs (mocké).
+- Les cours annulés sont détectés aussi bien par catégorie que par `STATUS:CANCELLED` ; plusieurs blocs de devoirs partageant une date sont tous conservés avant déduplication.
-- Le repli bascule correctement et lève une erreur critique si aucune source disponible.
+- Le constructeur `ParentClient` est testé avec l'ordre réel de ses paramètres, l'URL Pronote et une fonction ENT autorisée.
-- Aucun secret dans les messages d'erreur de fetch.
+- Le client `pronotepy` récupère messages/cours/devoirs (mocké) et ne retourne que les devoirs de la date cible.
+- Le mode `auto` bascule uniquement après une exception et lève une erreur critique si les deux sources échouent ; un résultat vide reste un succès.
+- Aucun secret n'apparaît dans le message, les logs, la cause, le contexte ou le traceback complet d'une erreur de source.
 
 ---
 
@@ -93,11 +97,11 @@ Récupérer et normaliser l'agenda, les devoirs et les messages Pronote, avec re
 
 Récupérer le flux RSS du blog du collège, parser et dédupliquer les articles.
 
-- [ ] Créer `sources/blog/rss.py` : `BlogRSSClient.fetch_and_parse(known_guids)` avec `feedparser` (§5 bis.7.1).
+- [x] Créer `sources/blog/rss.py` : `BlogRSSClient.fetch_and_parse(known_guids)` avec `feedparser` (§5 bis.7.1).
-- [ ] Parser les dates (RFC 822 / ISO 8601) et convertir le HTML en texte brut (`BeautifulSoup` + `html.unescape`).
+- [x] Parser les dates (RFC 822 / ISO 8601) et convertir le HTML en texte brut (`BeautifulSoup` + `html.unescape`).
-- [ ] Créer `sources/blog/state.py` (ou `sync/blog_state.py`) : `BlogRSSState` (JSON : `known_guids`, `etag`, `last_modified`).
+- [x] Créer `sources/blog/state.py` (ou `sync/blog_state.py`) : `BlogRSSState` (JSON : `known_guids`, `etag`, `last_modified`).
-- [ ] Implémenter la déduplication par GUID et le cache HTTP (`If-Modified-Since` / `etag`).
+- [x] Implémenter la déduplication par GUID et le cache HTTP (`If-Modified-Since` / `etag`).
-- [ ] Gérer un flux invalide (`bozo`) et les exceptions sans fuite de secret (retour `[]`/warning).
+- [x] Gérer un flux invalide (`bozo`) et les exceptions sans fuite de secret (retour `[]`/warning).
 
 ### Critères d'acceptation
 - `fetch_and_parse` renvoie les nouveaux articles triés par date décroissante, sans doublons.
@@ -108,16 +112,23 @@ Récupérer le flux RSS du blog du collège, parser et dédupliquer les articles
 
 ## M6. Source agenda théorique — Priorité : Moyenne
 
-Lire l'agenda théorique (iCal ou CSV) via une interface de provider extensible.
+Lire l'agenda théorique (JSON) via une interface de provider extensible, avec gestion de la parité des semaines (paire/impaire) et des vacances scolaires.
 
 - [ ] Créer `sources/theoretical/provider.py` : protocole `TheoreticalAgendaProvider` (§8.2).
-- [ ] Créer `sources/theoretical/file.py` : lecture fichier iCal/CSV → liste de `TheoreticalLesson` (§8.3).
+- [ ] Créer `sources/theoretical/file.py` : parser JSON → liste de `TheoreticalLesson` avec filtrage par parité de semaine (paire/impaire/toutes).
+- [ ] Créer `sources/theoretical/parity.py` : service `WeekParityService` déterminant la parité d'une date à partir d'une date de référence configurée.
+- [ ] Créer `sources/theoretical/holidays.py` : service `SchoolHolidayCalendar` lisant un fichier JSON de vacances scolaires (zone A) et exposant `is_holiday(date)`.
+- [ ] Implémenter le provider JSON : filtrage par parité + vacances, génération d'identifiants déterministes incluant le type de semaine.
+- [ ] Ajouter la configuration : `SCHOOL_HOLIDAYS_PATH`, `THEORETICAL_WEEK_ANCHOR_DATE`, `THEORETICAL_WEEK_ANCHOR_TYPE` dans `AppSettings`.
 - [ ] Normaliser les matières et créneaux pour le matching déterministe.
-- [ ] Supporter les deux formats (iCal et CSV) derrière la même interface.
+- [ ] Créer les fixtures : `tests/fixtures/theoretical.json` et `tests/fixtures/school_holidays.json`.
 
 ### Critères d'acceptation
-- `file.py` lit `tests/fixtures/theoretical.ics` et `theoretical.csv` en `TheoreticalLesson`.
+- `file.py` lit `tests/fixtures/theoretical.json` en `TheoreticalLesson` avec filtrage par parité.
+- Le provider renvoie une liste vide pendant les vacances scolaires.
 - Le provider renvoie une liste stable et déterministe (tri par identifiant).
+- Les identifiants sont distincts pour des leçons de parité différente sur le même créneau.
+- Une configuration incomplète (ancre de parité manquante alors que des leçons `even`/`odd` existent) produit une erreur explicite.
 
 ---
 
@@ -128,12 +139,14 @@ Synchroniser différentiellement les événements Pronote vers le calendrier Cal
 - [ ] Créer `sync/caldav.py` : `CalDAVClient` (connexion, liste/ajout/MAJ/suppression, marqueur `X-PRONOTE-SYNC-MANAGED: v1`).
 - [ ] Créer `sync/state.py` : état local de sync (SQLite ou JSON) assurant l'idempotence (UID connus).
 - [ ] Calculer le `CalDAVSyncPlan` (to_add / to_update / to_remove) par UID stable.
+- [ ] Avant de figer le plan de sync, vérifier sur fixture anonymisée que le même cours provenant d'iCal et de `pronotepy` possède le même identifiant canonique ; corriger la normalisation à la frontière des sources si nécessaire.
 - [ ] Implémenter la sync différentielle : conserver les cours annulés (`STATUS:CANCELLED`), ne pas supprimer.
 - [ ] Garantir l'idempotence (2 exécutions identiques → même `CalDAVSyncResult`).
 - [ ] Réutiliser `BlogRSSState` pour l'état blog si pertinent (sinon `sync/blog_state.py`).
 
 ### Critères d'acceptation
 - Le plan de sync est correctement calculé (PronoteData vs état local).
+- Un changement de source iCal ↔ `pronotepy` ne crée ni doublon ni suppression/ajout artificiel pour un cours équivalent.
 - Un run dry-run n'écrit rien ; deux runs identiques donnent un résultat identique.
 - Les événements annulés restent (`STATUS:CANCELLED`) et sont marqués `MANAGED`.
 
@@ -194,15 +207,17 @@ Construire et envoyer le message XMPP structuré via un compte bot dédié (mess
 
 Composer et orchestrer toutes les étapes avec gestion d'erreurs dégradée et mode dry-run.
 
-- [ ] Créer `pipeline/steps/errors.py` : `ErrorSeverity`, `PipelineError`, `PipelineWarning`, `PipelineCriticalError`.
+- [ ] Compléter si nécessaire la hiérarchie canonique dans `pronote_sync/errors.py` (`ErrorSeverity`, `PipelineError`, `PipelineWarning`, `PipelineCriticalError`) ; ne pas créer de doublon dans `pipeline/steps/errors.py`.
 - [ ] Créer les étapes `pipeline/steps/` : `fetch.py`, `normalize.py`, `compare.py`, `caldav_sync.py`, `synthesis.py`, `send.py`, `fetch_blog.py`.
 - [ ] Créer `pipeline/run.py` : `PipelineRunner` (composition root) orchestrant fetch → normalize → fetch_blog → compare → caldav_sync → synthesis → send.
 - [ ] Gérer les erreurs dégradées (continuer sauf critique) et renvoyer `(PronoteData, erreurs + warns)`.
 - [ ] Implémenter le mode `dry_run` (aucune écriture CalDAV/XMPP).
 - [ ] Câbler l'injection des dépendances (Protocol + composition root), sans singleton global.
+- [ ] Réutiliser, dans une même exécution, un unique téléchargement/parsing iCal pour l'agenda et les devoirs lorsque les sources sélectionnées le permettent ; rester sur un cache local au run, sans cache global ni persistant.
 
 ### Critères d'acceptation
 - Le pipeline complet s'exécute de bout en bout (mocks) dans le bon ordre.
+- Une sélection iCal commune à l'agenda et aux devoirs ne déclenche qu'un téléchargement/parsing du flux par run.
 - Une erreur non critique (ex : synthèse IA) n'empêche pas l'envoi XMPP.
 - `dry_run=True` n'effectue aucune écriture ; aucune source disponible → erreur critique explicite.
 
@@ -220,7 +235,7 @@ Exposer le lancement du pipeline via une interface en ligne de commande.
 ### Critères d'acceptation
 - `pronote-sync --dry-run --log-level DEBUG` s'exécute sans effet de bord.
 - Le script console est installable (`[project.scripts]` dans `pyproject.toml`).
-- Les erreurs affichées ne contiennent aucun secret.
+- Les erreurs affichées ne contiennent aucun secret, y compris avec l'affichage d'un traceback complet en mode debug.
 
 ---
 
@@ -228,13 +243,14 @@ Exposer le lancement du pipeline via une interface en ligne de commande.
 
 Couvrir l'ensemble du code par des tests sans réseau, avec fixtures anonymisées, jusqu'à ≥ 90 %.
 
-- [ ] Créer `tests/fixtures/` : `pronote-4e.ics`, `pronote-6e.ics`, `theoretical.ics`, `theoretical.csv`, `blog_rss.xml` (anonymisés, sans `icalsecurise`).
+- [ ] Créer `tests/fixtures/` : `pronote-4e.ics`, `pronote-6e.ics`, `theoretical.json`, `school_holidays.json`, `blog_rss.xml` (anonymisés, sans `icalsecurise`).
 - [ ] Créer `tests/conftest.py` : fixtures partagées (sample_lesson, sample_cancelled_lesson, sample_homework, sample_school_event, sample_message, sample_pronote_data…).
 - [ ] Écrire `tests/unit/` : `test_models`, `test_parsing` (iCal), `test_uid`, `test_redaction`, `test_diff`, `test_sync`.
+- [ ] Couvrir les régressions M4 : signature réelle de `ParentClient`, ENT autorisé/inconnu, erreur vs résultat vide, `STATUS:CANCELLED` sans catégorie, plusieurs devoirs à la même date, filtrage `pronotepy` sur la date cible et stabilité d'identité entre sources.
 - [ ] Écrire `tests/integration/` : `test_pipeline`, `test_caldav` (mocké), `test_xmpp` (mocké).
 - [ ] Écrire `tests/e2e/test_cli.py` : exécution CLI en dry-run.
 - [ ] Tests sans réseau (mocks `responses`/`aioresponses`/`pytest-mock`) ; couverture ≥ 90 %.
-- [ ] Ajouter un test négatif : les messages d'erreur ne fuient pas de secrets (`icalsecurise`, clés API, mots de passe).
+- [ ] Ajouter un test négatif : les messages, logs, causes, contextes et tracebacks complets ne fuient pas de secrets (`icalsecurise`, clés API, mots de passe).
 
 ### Critères d'acceptation
 - `pytest` passe et `pytest --cov` atteint ≥ 90 % (`fail_under = 90`).

pronote_sync/config/settings.py

@@ -8,6 +8,7 @@ depuis les variables d'environnement (préfixées par groupe) et le fichier
 
 from __future__ import annotations
 
+from datetime import date
 from typing import Literal
 
 from pydantic import Field, SecretStr, field_serializer
@@ -114,7 +115,10 @@ class AppSettings(BaseSettings):
     """Paramètres généraux de l'application, sans préfixe d'environnement.
 
     Contient notamment la fenêtre de synchronisation en jours
-    (``SYNC_PAST_DAYS`` / ``SYNC_FUTURE_DAYS``).
+    (``SYNC_PAST_DAYS`` / ``SYNC_FUTURE_DAYS``) et la configuration de
+    l'agenda théorique (``THEORETICAL_AGENDA_PATH``,
+    ``THEORETICAL_WEEK_ANCHOR_DATE``, ``THEORETICAL_WEEK_ANCHOR_TYPE`` ainsi
+    que ``SCHOOL_HOLIDAYS_PATH`` pour les vacances scolaires).
     """
 
     model_config = SettingsConfigDict(env_file=".env", extra="ignore")
@@ -122,6 +126,9 @@ class AppSettings(BaseSettings):
     dry_run: bool = False
     log_level: str = "INFO"
     theoretical_agenda_path: str | None = None
+    school_holidays_path: str | None = None
+    theoretical_week_anchor_date: date | None = None
+    theoretical_week_anchor_type: Literal["even", "odd"] | None = None
     sync_past_days: int = 7
     sync_future_days: int = 30
 

pronote_sync/sources/blog/__init__.py

@@ -0,0 +1,21 @@
+"""Source du blog du collège : récupération et suivi du flux RSS.
+
+Ce package expose l'API publique du connecteur du blog du collège :
+
+- :class:`BlogRSSClient` (:mod:`pronote_sync.sources.blog.rss`) : télécharge
+  et parse le flux RSS, déduplique les entrées par GUID et renvoie les
+  nouveaux articles dans un :class:`BlogRSSFetchResult`.
+- :class:`BlogRSSFetchResult` (:mod:`pronote_sync.sources.blog.result`) :
+  type de retour figé d'une récupération : nouveaux articles, en-têtes
+  HTTP de cache (``ETag``/``Last-Modified``) et indicateur ``304 Not
+  Modified``.
+- :class:`BlogRSSState` (:mod:`pronote_sync.sources.blog.state`) : état
+  local persistant (GUID connus et en-têtes de cache) pour la
+  déduplication et les requêtes conditionnelles.
+"""
+
+from pronote_sync.sources.blog.result import BlogRSSFetchResult
+from pronote_sync.sources.blog.rss import BlogRSSClient
+from pronote_sync.sources.blog.state import BlogRSSState
+
+__all__ = ["BlogRSSClient", "BlogRSSFetchResult", "BlogRSSState"]

pronote_sync/sources/blog/result.py

@@ -0,0 +1,54 @@
+"""Résultat de la récupération du flux RSS du blog du collège.
+
+Ce module définit :class:`BlogRSSFetchResult`, le type de retour figé du
+client RSS du blog (:mod:`pronote_sync.sources.blog`).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from pronote_sync.models.blog import BlogArticle
+
+
+class BlogRSSFetchResult(BaseModel):
+    """Résultat d'une récupération du flux RSS du blog du collège.
+
+    Modèle figé (``frozen``) : les instances sont immuables après création.
+    Il regroupe les nouveaux articles, triés par date de publication
+    décroissante puis par identifiant croissant, ainsi que les en-têtes
+    HTTP utiles aux requêtes conditionnelles (``ETag`` et
+    ``Last-Modified``).
+
+    :param articles: Nouveaux articles absents de ``known_guids``, triés
+        par date de publication décroissante puis par identifiant
+        croissant. Vide par défaut.
+    :param etag: Valeur de l'en-tête ``ETag`` de la réponse RSS, si elle
+        est disponible. ``None`` par défaut.
+    :param last_modified: Valeur de l'en-tête ``Last-Modified`` de la
+        réponse RSS, si elle est disponible. ``None`` par défaut.
+    :param not_modified: Vaut ``True`` si le serveur a répondu avec le
+        statut ``304 Not Modified``, ``False`` sinon.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    articles: tuple[BlogArticle, ...] = Field(
+        default=(),
+        description=(
+            "Nouveaux articles absents de known_guids, triés par date de "
+            "publication décroissante puis par identifiant croissant"
+        ),
+    )
+    etag: str | None = Field(
+        default=None,
+        description="Valeur de l'en-tête ETag de la réponse RSS, si disponible",
+    )
+    last_modified: str | None = Field(
+        default=None,
+        description="Valeur de l'en-tête Last-Modified de la réponse RSS, si disponible",
+    )
+    not_modified: bool = Field(
+        default=False,
+        description="Vaut True si le serveur a répondu 304 Not Modified",
+    )

pronote_sync/sources/blog/rss.py

@@ -0,0 +1,293 @@
+"""Client de récupération et de parsing du flux RSS du blog du collège.
+
+Ce module définit :class:`BlogRSSClient`, un client sans état qui
+télécharge le flux RSS du blog via ``requests``, le parse via
+``feedparser``, déduplique les entrées par GUID et les convertit en
+:class:`~pronote_sync.models.blog.BlogArticle`.
+
+Le résultat d'une récupération est un
+:class:`~pronote_sync.sources.blog.result.BlogRSSFetchResult` : les
+nouveaux articles (triés par date de publication décroissante, puis par
+identifiant croissant) accompagnés des en-têtes HTTP ``ETag`` et
+``Last-Modified`` de la réponse. Toute erreur de récupération ou de
+parsing est journalisée (URL et exception rédigées) puis dégradée en
+résultat vide : une liste vide est un succès valide, pas une panne.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import UTC, datetime
+from html import unescape
+
+import feedparser  # type: ignore[import-untyped]
+import requests
+from bs4 import BeautifulSoup
+
+from pronote_sync.models.blog import BlogArticle
+from pronote_sync.sources.blog.result import BlogRSSFetchResult
+from pronote_sync.utils.redaction import redact_exception, redact_url
+
+logger = logging.getLogger(__name__)
+
+
+class BlogRSSClient:
+    """Client de récupération et de parsing du flux RSS du blog du collège.
+
+    Client sans état : aucune E/S n'est effectuée à la construction et
+    aucune donnée n'est conservée entre deux appels à
+    :meth:`fetch_and_parse`. Toute erreur de récupération ou de parsing
+    est journalisée puis dégradée en résultat vide.
+
+    :param rss_url: URL du flux RSS du blog du collège.
+    :param timeout: Timeout HTTP en secondes (défaut : 20).
+    """
+
+    def __init__(self, rss_url: str, timeout: int = 20) -> None:
+        """Initialise le client RSS du blog.
+
+        Aucune opération d'E/S n'est réalisée ici : le téléchargement et
+        le parsing n'ont lieu qu'à l'appel de :meth:`fetch_and_parse`.
+
+        :param rss_url: URL du flux RSS du blog du collège.
+        :param timeout: Timeout HTTP en secondes (défaut : 20).
+        """
+        self.rss_url = rss_url
+        self.timeout = timeout
+
+    def fetch_and_parse(
+        self,
+        *,
+        known_guids: frozenset[str] | None = None,
+        etag: str | None = None,
+        last_modified: str | None = None,
+    ) -> BlogRSSFetchResult:
+        """Télécharge et parse le flux RSS du blog en nouveaux articles.
+
+        Le flux est téléchargé par ``requests`` avec les en-têtes de
+        requête conditionnelle fournis (``ETag``/``Last-Modified``), puis
+        parsé par ``feedparser``. Si le serveur répond ``304 Not Modified``,
+        le résultat est vide avec
+        ``not_modified=True`` et les en-têtes passés en entrée sont
+        restitués tels quels. Chaque entrée est dédupliquée par GUID,
+        convertie en :class:`~pronote_sync.models.blog.BlogArticle`, puis
+        l'ensemble est trié par date de publication décroissante puis par
+        identifiant croissant. Toute erreur est journalisée (URL et
+        exception rédigées) et dégradée en résultat vide : aucune
+        exception n'est propagée.
+
+        :param known_guids: Ensemble des GUID d'articles déjà traités ; les
+            entrées correspondantes sont ignorées. ``None`` pour tout
+            conserver (défaut).
+        :param etag: Valeur de l'en-tête ``ETag`` mémorisée pour la requête
+            conditionnelle, ou ``None`` (défaut).
+        :param last_modified: Valeur de l'en-tête ``Last-Modified`` mémorisée
+            pour la requête conditionnelle, ou ``None`` (défaut).
+        :return: Résultat de la récupération : nouveaux articles (tuple vide
+            si aucun nouvel article, réponse ``304`` ou erreur), en-têtes de
+            cache de la réponse et indicateur ``not_modified``.
+        :rtype: :class:`~pronote_sync.sources.blog.result.BlogRSSFetchResult`
+        """
+        try:
+            # Téléchargement HTTP explicite via requests : feedparser 6.x
+            # n'accepte aucun paramètre de transport ; les requêtes
+            # conditionnelles sont gérées avec les en-têtes HTTP standards.
+            headers: dict[str, str] = {"user-agent": "pronote-sync"}
+            if etag is not None:
+                headers["If-None-Match"] = etag
+            if last_modified is not None:
+                headers["If-Modified-Since"] = last_modified
+            response = requests.get(self.rss_url, headers=headers, timeout=self.timeout)
+
+            # Réponse 304 Not Modified : rien n'a changé, on restitue les
+            # en-têtes mémorisés tels quels pour les conserver.
+            if response.status_code == 304:
+                return BlogRSSFetchResult(
+                    articles=(),
+                    etag=etag,
+                    last_modified=last_modified,
+                    not_modified=True,
+                )
+
+            # Les statuts 4xx/5xx lèvent une exception HTTP, attrapée par le
+            # gestionnaire général et dégradée en résultat vide.
+            response.raise_for_status()
+
+            response_etag: str | None = response.headers.get("ETag", None)
+            if response_etag is None:
+                response_etag = response.headers.get("etag", None)
+            response_last_modified: str | None = response.headers.get("Last-Modified", None)
+            if response_last_modified is None:
+                response_last_modified = response.headers.get("last-modified", None)
+
+            # feedparser ne reçoit que le contenu brut de la réponse.
+            feed = feedparser.parse(response.content)
+
+            # Flux invalide (XML malformé, etc.) : avertissement puis résultat
+            # vide, sans propager l'exception brute. Les validateurs de cache
+            # d'entrée sont conservés : on ne fait pas confiance aux en-têtes
+            # d'une réponse au contenu invalide.
+            if getattr(feed, "bozo", None):
+                bozo_exception = getattr(feed, "bozo_exception", None)
+                if bozo_exception is not None:
+                    logger.warning(
+                        "Flux RSS du blog invalide (%s), ignoré : %s",
+                        redact_exception(bozo_exception),
+                        redact_url(self.rss_url),
+                    )
+                else:
+                    logger.warning(
+                        "Flux RSS du blog invalide, ignoré : %s",
+                        redact_url(self.rss_url),
+                    )
+                return BlogRSSFetchResult(
+                    articles=(),
+                    etag=etag,
+                    last_modified=last_modified,
+                    not_modified=False,
+                )
+
+            articles: list[BlogArticle] = []
+            # Déduplication silencieuse des GUID déjà connus (exécutions
+            # précédentes) et détection des doublons au sein de la réponse.
+            known_set = set(known_guids) if known_guids is not None else None
+            seen_in_feed: set[str] = set()
+            for entry in getattr(feed, "entries", []):
+                guid_source = entry.get("id") or entry.get("link")
+                if not guid_source:
+                    logger.warning(
+                        "Entrée RSS sans GUID ni lien, ignorée : %s",
+                        redact_url(self.rss_url),
+                    )
+                    continue
+                guid = str(guid_source)
+
+                if known_set is not None and guid in known_set:
+                    # Déduplication normale (GUID connu d'une exécution
+                    # précédente) : aucun journal n'est nécessaire.
+                    continue
+
+                if guid in seen_in_feed:
+                    logger.warning(
+                        "Entrée RSS en double dans le flux, ignorée : %s",
+                        redact_url(self.rss_url),
+                    )
+                    continue
+
+                seen_in_feed.add(guid)
+
+                published_at = self._parse_date(
+                    entry.get("published_parsed") or entry.get("pubdate_parsed")
+                )
+                if published_at is None:
+                    logger.warning(
+                        "Entrée RSS sans date de publication valide, ignorée : %s",
+                        redact_url(self.rss_url),
+                    )
+                    continue
+
+                updated_at = self._parse_date(entry.get("updated_parsed"))
+
+                raw_content = entry.get("content")
+                if raw_content:
+                    content_html = str(raw_content[0].get("value") or "")
+                else:
+                    content_html = str(entry.get("description") or "")
+
+                tags = entry.get("tags")
+                category_value = tags[0].get("term") if tags else None
+                if not category_value:
+                    category_value = entry.get("category")
+                category = str(category_value) if category_value else None
+
+                author_value = entry.get("author")
+                author = str(author_value) if author_value else None
+
+                title = str(entry.get("title") or guid)
+                url = str(entry.get("link") or guid)
+
+                articles.append(
+                    BlogArticle(
+                        id=guid,
+                        title=title,
+                        url=url,
+                        published_at=published_at,
+                        updated_at=updated_at,
+                        category=category,
+                        author=author,
+                        content_html=content_html,
+                        content_text=self._html_to_text(content_html),
+                    )
+                )
+
+            # Tri stable : d'abord par identifiant croissant, puis par date de
+            # publication décroissante ; l'ordre par identifiant est conservé
+            # entre articles de même date.
+            articles.sort(key=lambda article: article.id)
+            articles.sort(key=lambda article: article.published_at, reverse=True)
+
+            return BlogRSSFetchResult(
+                articles=tuple(articles),
+                etag=response_etag,
+                last_modified=response_last_modified,
+                not_modified=False,
+            )
+        except Exception as exc:
+            logger.error(
+                "Échec de la récupération du flux RSS du blog %s : %s",
+                redact_url(self.rss_url),
+                redact_exception(exc),
+            )
+            return BlogRSSFetchResult(
+                articles=(),
+                etag=etag,
+                last_modified=last_modified,
+                not_modified=False,
+            )
+
+    @staticmethod
+    def _parse_date(date_tuple: tuple[int, ...] | None) -> datetime | None:
+        """Convertit un tuple de date ``struct_time`` en :class:`datetime` UTC.
+
+        :param date_tuple: Tuple horodaté au format ``time.struct_time``
+            (indices 0 à 5 : année, mois, jour, heure, minute, seconde), ou
+            ``None`` si absent.
+        :return: Date/heure consciente du fuseau UTC, ou ``None`` si le
+            tuple est absent, vide ou invalide.
+        :rtype: datetime | None
+        """
+        if not date_tuple:
+            return None
+        try:
+            return datetime(
+                date_tuple[0],
+                date_tuple[1],
+                date_tuple[2],
+                date_tuple[3],
+                date_tuple[4],
+                date_tuple[5],
+                tzinfo=UTC,
+            )
+        except (ValueError, IndexError):
+            return None
+
+    @staticmethod
+    def _html_to_text(html: str) -> str:
+        """Convertit du HTML en texte brut nettoyé.
+
+        Le HTML est parsé avec BeautifulSoup, les balises sont remplacées
+        par des espaces, les entités HTML sont décodées et les suites
+        d'espaces sont unifiées.
+
+        :param html: Contenu HTML à convertir.
+        :return: Texte brut sans balises, entités décodées et espaces
+            unifiés ; chaîne vide si ``html`` est vide.
+        :rtype: str
+        """
+        if not html:
+            return ""
+        soup = BeautifulSoup(html, "html.parser")
+        text = soup.get_text(separator=" ", strip=True)
+        text = unescape(text)
+        return re.sub(r"\s+", " ", text).strip()

pronote_sync/sources/blog/state.py

@@ -0,0 +1,174 @@
+"""Gestion de l'état local du flux RSS du blog du collège.
+
+Ce module définit :class:`BlogRSSState`, un gestionnaire d'état persistant
+dans un fichier JSON local (``.blog_rss_state.json`` par défaut). Il
+mémorise les identifiants (GUID) des articles déjà traités — pour la
+déduplication — ainsi que les en-têtes HTTP ``ETag`` et ``Last-Modified``
+de la dernière réponse — pour les requêtes conditionnelles.
+
+La lecture et l'écriture sont tolérantes aux erreurs : un fichier absent,
+corrompu ou illisible ne fait jamais échouer le pipeline ; l'état vide est
+alors utilisé. La sortie JSON est déterministe (``known_guids`` triés
+alphabétiquement, champ ``version`` constant).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Iterable
+from pathlib import Path
+
+from pronote_sync.utils.redaction import redact_exception, redact_secrets
+
+logger = logging.getLogger(__name__)
+
+_STATE_VERSION = 1
+
+
+class BlogRSSState:
+    """Gère l'état local pour la déduplication des articles et le cache HTTP du flux RSS.
+
+    L'état regroupe l'ensemble des GUID d'articles déjà publiés
+    (``known_guids``) et les en-têtes de cache HTTP (``etag``,
+    ``last_modified``). Il est chargé depuis le fichier JSON à la
+    construction et sauvegardé à chaque modification. Toute erreur de
+    lecture ou d'écriture est journalisée sans être propagée.
+
+    :param state_file: Chemin du fichier d'état JSON (``str`` ou
+        :class:`~pathlib.Path`). ``".blog_rss_state.json"`` par défaut.
+    """
+
+    def __init__(self, state_file: Path | str = ".blog_rss_state.json") -> None:
+        """Initialise le gestionnaire d'état depuis le fichier JSON.
+
+        :param state_file: Chemin du fichier d'état JSON (``str`` ou
+            :class:`~pathlib.Path`). ``".blog_rss_state.json"`` par défaut.
+        """
+        self._state_file = Path(state_file)
+        self._known_guids: set[str] = set()
+        self._etag: str | None = None
+        self._last_modified: str | None = None
+        self._load()
+
+    def _load(self) -> None:
+        """Charge l'état depuis le fichier JSON.
+
+        Si le fichier n'existe pas, l'état reste vide. Si le fichier est
+        corrompu, illisible ou que la version est absente ou différente
+        de 1, un avertissement est journalisé et l'état reste vide.
+        Aucune exception n'est propagée.
+        """
+        if not self._state_file.exists():
+            return
+        try:
+            data = json.loads(self._state_file.read_text(encoding="utf-8"))
+            if not isinstance(data, dict) or data.get("version") != _STATE_VERSION:
+                logger.warning(
+                    "Fichier d'état blog RSS %s : version absente ou non supportée, "
+                    "démarrage avec un état vide.",
+                    redact_secrets(str(self._state_file)),
+                )
+                return
+            guids_data = data.get("known_guids", [])
+            if isinstance(guids_data, list):
+                self._known_guids = {guid for guid in guids_data if isinstance(guid, str)}
+            etag_data = data.get("etag")
+            if isinstance(etag_data, str):
+                self._etag = etag_data
+            last_modified_data = data.get("last_modified")
+            if isinstance(last_modified_data, str):
+                self._last_modified = last_modified_data
+        except Exception as exc:
+            logger.warning(
+                "Impossible de charger le fichier d'état blog RSS %s : %s, "
+                "démarrage avec un état vide.",
+                redact_secrets(str(self._state_file)),
+                redact_exception(exc),
+            )
+
+    def _save(self) -> None:
+        """Sauvegarde l'état dans le fichier JSON de manière atomique.
+
+        La sortie est déterministe : ``known_guids`` est trié
+        alphabétiquement et le champ ``version`` vaut 1. Le JSON est
+        d'abord écrit dans un fichier temporaire du même répertoire, puis
+        remplacé atomiquement par :meth:`~pathlib.Path.replace` afin de ne
+        jamais laisser un fichier partiel en cas d'interruption. En cas
+        d'erreur d'écriture, une erreur est journalisée sans être
+        propagée et le fichier temporaire est supprimé.
+        """
+        payload = {
+            "version": _STATE_VERSION,
+            "known_guids": sorted(self._known_guids),
+            "etag": self._etag,
+            "last_modified": self._last_modified,
+        }
+        tmp_file = self._state_file.with_suffix(".tmp")
+        try:
+            with open(tmp_file, "w", encoding="utf-8") as handle:
+                json.dump(payload, handle, indent=2)
+            tmp_file.replace(self._state_file)
+        except Exception as exc:
+            logger.error(
+                "Impossible d'écrire le fichier d'état blog RSS %s : %s.",
+                redact_secrets(str(self._state_file)),
+                redact_exception(exc),
+            )
+            try:
+                tmp_file.unlink(missing_ok=True)
+            except Exception as cleanup_exc:
+                logger.debug(
+                    "Nettoyage du fichier temporaire échoué : %s",
+                    redact_exception(cleanup_exc),
+                )
+
+    def get_known_guids(self) -> frozenset[str]:
+        """Renvoie une copie immuable des GUID d'articles déjà connus.
+
+        :return: Copie de type :class:`frozenset` des GUID connus.
+        :rtype: frozenset[str]
+        """
+        return frozenset(self._known_guids)
+
+    def add_guids(self, guids: Iterable[str]) -> None:
+        """Ajoute des GUID d'articles à l'état connu et sauvegarde.
+
+        Si l'itérable ne contient aucun GUID, l'état n'est pas modifié et
+        aucune sauvegarde n'est déclenchée.
+
+        :param guids: Itérable des GUID d'articles à enregistrer.
+        """
+        new_guids = set(guids)
+        if not new_guids:
+            return
+        self._known_guids.update(new_guids)
+        self._save()
+
+    def get_cache_headers(self) -> tuple[str | None, str | None]:
+        """Renvoie les en-têtes de cache HTTP mémorisés.
+
+        :return: Tuple ``(etag, last_modified)``, chaque valeur pouvant
+            être ``None`` si elle n'a jamais été reçue.
+        :rtype: tuple[str | None, str | None]
+        """
+        return self._etag, self._last_modified
+
+    def update_cache_headers(self, etag: str | None, last_modified: str | None) -> None:
+        """Met à jour les en-têtes de cache HTTP et sauvegarde.
+
+        :param etag: Nouvelle valeur de l'en-tête ``ETag``, ou ``None``
+            pour l'effacer.
+        :param last_modified: Nouvelle valeur de l'en-tête
+            ``Last-Modified``, ou ``None`` pour l'effacer.
+        """
+        self._etag = etag
+        self._last_modified = last_modified
+        self._save()
+
+    def clear(self) -> None:
+        """Réinitialise l'état (GUID et en-têtes de cache) et sauvegarde."""
+        self._known_guids = set()
+        self._etag = None
+        self._last_modified = None
+        self._save()

pronote_sync/sources/pronote/fallback.py

@@ -4,9 +4,9 @@ Ce module fournit l'enum :class:`AgendaSource`, le protocole
 :class:`PronoteFetcherProtocol` consommé par le pipeline ainsi que la
 classe :class:`PronoteFetcher` qui sélectionne la source selon la
 configuration (``PRONOTE_AGENDA_SOURCE`` / ``PRONOTE_HOMEWORK_SOURCE``).
-La logique applique un repli **unique** : une source primaire est
+Contrat strict : les modes explicites n'utilisent que la source
-essayée en premier et, en cas d'échec, une seule source de repli (jamais
+configurée, sans aucun repli ; seul le mode ``auto`` applique un repli
-réciproque ni itératif) est essayée si elle est configurée. Les messages
+unique iCal → pronotepy, en cas d'exception uniquement. Les messages
 et informations proviennent toujours de pronotepy. Toutes les erreurs
 sont journalisées avec des secrets masqués via
 :func:`~pronote_sync.utils.redaction.redact_exception` ; les exceptions
@@ -82,13 +82,14 @@ class PronoteFetcherProtocol(Protocol):
 
 
 class PronoteFetcher:
-    """Récupère les données Pronote via iCal ou pronotepy avec repli unique.
+    """Récupère les données Pronote via iCal ou pronotepy, repli réservé au mode ``auto``.
 
     Unifie les sources iCal et pronotepy selon la source configurée
-    (``agenda_source`` / ``homework_source``) : la source primaire est
+    (``agenda_source`` / ``homework_source``) : les modes explicites
-    essayée en premier et, si elle échoue, une seule source de repli est
+    n'utilisent que la source configurée, sans aucun repli ; seul le mode
-    essayée lorsqu'elle est configurée. Les messages et informations
+    ``auto`` essaie une source primaire puis, si elle échoue, une seule
-    proviennent toujours de pronotepy.
+    source de repli lorsqu'elle est configurée. Les messages et
+    informations proviennent toujours de pronotepy.
     """
 
     def __init__(self, settings: Settings, pronote_client: PronoteClientProtocol) -> None:
@@ -171,11 +172,10 @@ class PronoteFetcher:
     def _agenda_sources(self) -> tuple[_SourceName, _SourceName | None]:
         """Sélectionne la source primaire et le repli unique pour l'agenda.
 
-        En mode ``AUTO``, iCal est primaire si ``ical_url`` est configuré
+        Les modes explicites ``ICAL`` et ``PRONOTEPY`` désignent la seule
-        (repli pronotepy si la configuration pronotepy est complète),
+        source utilisée, sans aucun repli. En mode ``AUTO``, iCal est
-        sinon pronotepy sans repli. Les modes explicites ``ICAL`` et
+        primaire si ``ical_url`` est configuré (repli pronotepy si la
-        ``PRONOTEPY`` désignent la source primaire et tentent l'autre
+        configuration pronotepy est complète), sinon pronotepy sans repli.
-        source en repli unique si elle est configurée.
 
         :return: Tuple ``(source primaire, source de repli ou ``None``)``.
         :rtype: tuple[_SourceName, _SourceName | None]
@@ -183,9 +183,9 @@ class PronoteFetcher:
         """
         source = AgendaSource(self._settings.pronote.agenda_source)
         if source is AgendaSource.ICAL:
-            return "ical", "pronotepy" if self._is_pronotepy_configured() else None
+            return "ical", None
         if source is AgendaSource.PRONOTEPY:
-            return "pronotepy", "ical" if self._is_ical_configured() else None
+            return "pronotepy", None
         if self._is_ical_configured():
             return "ical", "pronotepy" if self._is_pronotepy_configured() else None
         if self._is_pronotepy_configured():
@@ -208,11 +208,13 @@ class PronoteFetcher:
     def fetch_agenda(self) -> tuple[list[Lesson], list[SchoolEvent]]:
         """Récupère les cours et les événements scolaires selon la source configurée.
 
-        La source primaire est essayée en premier ; si elle échoue, la
+        En mode explicite (``ical`` ou ``pronotepy``), la source désignée
-        source de repli unique (l'autre source, si configurée) est
+        est la seule tentée : si elle échoue, une erreur critique est levée
-        essayée. Si la source primaire et le repli échouent — ou si
+        sans repli. En mode ``auto``, la source primaire est essayée en
-        aucune source n'est configurée en mode ``AUTO`` — une erreur
+        premier puis, si elle échoue, la source de repli unique (l'autre
-        critique est levée.
+        source, si configurée) l'est à son tour ; si la source primaire et
+        le repli échouent — ou si aucune source n'est configurée — une
+        erreur critique est levée.
 
         :return: Tuple ``(cours, événements scolaires)``.
         :rtype: tuple[list[Lesson], list[SchoolEvent]]
@@ -289,11 +291,10 @@ class PronoteFetcher:
     def _homework_sources(self) -> tuple[_SourceName, _SourceName | None]:
         """Sélectionne la source primaire et le repli unique pour les devoirs.
 
-        En mode ``AUTO``, iCal est primaire si ``ical_url`` est configuré
+        Les modes explicites ``ICAL`` et ``PRONOTEPY`` désignent la seule
-        (repli pronotepy si la configuration pronotepy est complète),
+        source utilisée, sans aucun repli. En mode ``AUTO``, iCal est
-        sinon pronotepy sans repli. Les modes explicites ``ICAL`` et
+        primaire si ``ical_url`` est configuré (repli pronotepy si la
-        ``PRONOTEPY`` désignent la source primaire et tentent l'autre
+        configuration pronotepy est complète), sinon pronotepy sans repli.
-        source en repli unique si elle est configurée.
 
         :return: Tuple ``(source primaire, source de repli ou ``None``)``.
         :rtype: tuple[_SourceName, _SourceName | None]
@@ -301,9 +302,9 @@ class PronoteFetcher:
         """
         source = AgendaSource(self._settings.pronote.homework_source)
         if source is AgendaSource.ICAL:
-            return "ical", "pronotepy" if self._is_pronotepy_configured() else None
+            return "ical", None
         if source is AgendaSource.PRONOTEPY:
-            return "pronotepy", "ical" if self._is_ical_configured() else None
+            return "pronotepy", None
         if self._is_ical_configured():
             return "ical", "pronotepy" if self._is_pronotepy_configured() else None
         if self._is_pronotepy_configured():
@@ -327,11 +328,13 @@ class PronoteFetcher:
     def fetch_homework(self, target_date: date) -> list[Homework]:
         """Récupère les devoirs selon la source configurée.
 
-        La source primaire est essayée en premier ; si elle échoue, la
+        En mode explicite (``ical`` ou ``pronotepy``), la source désignée
-        source de repli unique (l'autre source, si configurée) est
+        est la seule tentée : si elle échoue, une erreur critique est levée
-        essayée. Si la source primaire et le repli échouent — ou si
+        sans repli. En mode ``auto``, la source primaire est essayée en
-        aucune source n'est configurée en mode ``AUTO`` — une erreur
+        premier puis, si elle échoue, la source de repli unique (l'autre
-        critique est levée.
+        source, si configurée) l'est à son tour ; si la source primaire et
+        le repli échouent — ou si aucune source n'est configurée — une
+        erreur critique est levée.
 
         :param target_date: Date cible pour laquelle collecter les devoirs.
         :return: Liste des devoirs.

pronote_sync/sources/theoretical/__init__.py

@@ -0,0 +1,75 @@
+"""Usine de construction du fournisseur d'agenda théorique.
+
+Ce module expose l'API publique du package ``theoretical`` : les classes
+:class:`~pronote_sync.sources.theoretical.provider.TheoreticalAgendaProvider`,
+:class:`~pronote_sync.sources.theoretical.file.JsonTheoreticalAgendaProvider`,
+:class:`~pronote_sync.sources.theoretical.parity.WeekParityService` et
+:class:`~pronote_sync.sources.theoretical.holidays.SchoolHolidayCalendar`, ainsi
+que la fonction :func:`get_theoretical_provider` qui assemble la configuration
+(chemin du fichier JSON, parité des semaines et vacances scolaires) pour
+produire un fournisseur d'agenda théorique prêt à l'emploi.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Literal
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.sources.theoretical.file import JsonTheoreticalAgendaProvider
+from pronote_sync.sources.theoretical.holidays import SchoolHolidayCalendar
+from pronote_sync.sources.theoretical.parity import WeekParityService
+from pronote_sync.sources.theoretical.provider import TheoreticalAgendaProvider
+
+__all__ = [
+    "TheoreticalAgendaProvider",
+    "JsonTheoreticalAgendaProvider",
+    "WeekParityService",
+    "SchoolHolidayCalendar",
+    "get_theoretical_provider",
+]
+
+
+def get_theoretical_provider(
+    agenda_path: str | None,
+    holidays_path: str | None,
+    anchor_date: date | None,
+    anchor_type: Literal["even", "odd"] | None,
+) -> TheoreticalAgendaProvider | None:
+    """Construit un fournisseur d'agenda théorique depuis la configuration.
+
+    :param agenda_path: Chemin du fichier JSON d'agenda théorique. Si None, retourne None.
+    :param holidays_path: Chemin du fichier JSON de vacances scolaires (optionnel).
+    :param anchor_date: Date de référence pour la parité des semaines.
+    :param anchor_type: Type de la semaine de référence ("even" ou "odd").
+    :return: Le fournisseur configuré, ou None si l'agenda théorique est désactivé.
+    :rtype: TheoreticalAgendaProvider | None
+    :raises PronoteSyncError: Si la configuration de parité est incomplète
+        (date sans type ou inversement) alors que l'agenda nécessite la parité.
+    """
+    if agenda_path is None:
+        return None
+
+    # Build parity service if both anchor fields are provided
+    parity_service: WeekParityService | None = None
+    if anchor_date is not None and anchor_type is not None:
+        parity_service = WeekParityService(anchor_date, anchor_type)
+    elif anchor_date is not None or anchor_type is not None:
+        # Partial parity config — one field without the other
+        raise PronoteSyncError(
+            "Configuration de parité incomplète : THEORETICAL_WEEK_ANCHOR_DATE et "
+            "THEORETICAL_WEEK_ANCHOR_TYPE doivent être fournis ensemble."
+        )
+
+    # Build holiday calendar if path is provided
+    holiday_calendar: SchoolHolidayCalendar | None = None
+    if holidays_path is not None:
+        holiday_calendar = SchoolHolidayCalendar(holidays_path)
+
+    # Build provider — the provider's __init__ will validate that parity_service
+    # is provided if the JSON contains even/odd lessons
+    return JsonTheoreticalAgendaProvider(
+        file_path=agenda_path,
+        parity_service=parity_service,
+        holiday_calendar=holiday_calendar,
+    )

pronote_sync/sources/theoretical/file.py

@@ -0,0 +1,183 @@
+"""Fournisseur d'agenda théorique basé sur un fichier JSON.
+
+Ce module fournit :class:`JsonTheoreticalAgendaProvider`, une implémentation de
+:class:`~pronote_sync.sources.theoretical.provider.TheoreticalAgendaProvider` qui charge
+un fichier JSON d'emploi du temps théorique et expose les cours applicables par date ou
+plage de dates. Le filtrage tient compte du jour de la semaine, de la parité de semaine
+(``even``/``odd``) et du calendrier des vacances scolaires.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import date, time, timedelta
+from pathlib import Path
+from typing import Literal
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.models.agenda import TheoreticalLesson
+from pronote_sync.sources.theoretical.holidays import SchoolHolidayCalendar
+from pronote_sync.sources.theoretical.model import TheoreticalAgendaFile, TheoreticalLessonEntry
+from pronote_sync.sources.theoretical.parity import WeekParityService
+from pronote_sync.utils.redaction import redact_exception, redact_secrets
+
+logger = logging.getLogger(__name__)
+
+
+def _generate_id(entry: TheoreticalLessonEntry) -> str:
+    """Génère un identifiant déterministe pour une entrée de cours.
+
+    L'identifiant intègre le type de semaine (``all``, ``even`` ou ``odd``),
+    le jour de la semaine, le créneau horaire et la matière : deux leçons
+    occupant le même créneau dans des semaines différentes (ou le même
+    créneau un autre jour) obtiennent ainsi des identifiants distincts.
+
+    :param entry: Entrée de cours du fichier JSON.
+    :return: Identifiant déterministe unique.
+    :rtype: str
+    """
+    subject_slug = entry.subject.lower().strip().replace(" ", "-")
+    return f"theoretical:{entry.week}:{entry.day_of_week}:{entry.start_time}-{entry.end_time}:{subject_slug}"
+
+
+class JsonTheoreticalAgendaProvider:
+    """Fournisseur d'agenda théorique basé sur un fichier JSON.
+
+    Charge un fichier JSON d'emploi du temps théorique au format défini par
+    :class:`~pronote_sync.sources.theoretical.model.TheoreticalAgendaFile` et expose
+    les cours théoriques pour une date ou une plage de dates. Les cours peuvent être
+    restreints à une parité de semaine (paire/impaire) via
+    :class:`~pronote_sync.sources.theoretical.parity.WeekParityService` et exclus
+    pendant les vacances scolaires via
+    :class:`~pronote_sync.sources.theoretical.holidays.SchoolHolidayCalendar`.
+
+    :param file_path: Chemin vers le fichier JSON de l'agenda théorique.
+    :param parity_service: Service optionnel de calcul de la parité de semaine.
+    :param holiday_calendar: Calendrier optionnel des vacances scolaires.
+    :raises PronoteSyncError: Si le fichier ne peut être lu ou analysé, si
+        des leçons à semaine paire/impaire sont présentes sans ancre de parité,
+        ou si plusieurs leçons partagent le même identifiant (explicite ou
+        généré).
+    """
+
+    def __init__(
+        self,
+        file_path: str,
+        parity_service: WeekParityService | None = None,
+        holiday_calendar: SchoolHolidayCalendar | None = None,
+    ) -> None:
+        """Initialise le fournisseur en chargeant et analysant le fichier JSON.
+
+        Le fichier est lu et analysé immédiatement. Toute erreur de lecture,
+        de décodage JSON ou de validation est journalisée (chemin et exception
+        expurgés) puis remontée sous forme de :class:`PronoteSyncError`. Si des
+        leçons à semaine paire/impaire sont présentes alors qu'aucun service de
+        parité n'est configuré, une :class:`PronoteSyncError` est également levée.
+
+        :param file_path: Chemin vers le fichier JSON de l'agenda théorique.
+        :param parity_service: Service optionnel de calcul de la parité de semaine.
+        :param holiday_calendar: Calendrier optionnel des vacances scolaires.
+        :raises PronoteSyncError: Si le fichier est introuvable, invalide,
+            nécessite une ancre de parité non configurée ou contient plusieurs
+            leçons partageant le même identifiant (explicite ou généré).
+        """
+        self._file_path: str = file_path
+        self._parity_service: WeekParityService | None = parity_service
+        self._holiday_calendar: SchoolHolidayCalendar | None = holiday_calendar
+        try:
+            content = Path(file_path).read_text(encoding="utf-8")
+            parsed = TheoreticalAgendaFile.model_validate_json(content)
+        except Exception as exc:
+            logger.error(
+                "Fichier d'agenda théorique invalide %s : %s.",
+                redact_secrets(str(file_path)),
+                redact_exception(exc),
+            )
+            raise PronoteSyncError(
+                f"Le fichier d'agenda théorique est invalide : {redact_secrets(str(file_path))}"
+            ) from None
+        self._lessons: tuple[TheoreticalLessonEntry, ...] = parsed.lessons
+        if self._parity_service is None and any(
+            entry.week in ("even", "odd") for entry in self._lessons
+        ):
+            raise PronoteSyncError(
+                "L'agenda théorique contient des leçons à semaine paire/impaire "
+                "mais aucune ancre de parité n'est configurée "
+                "(THEORETICAL_WEEK_ANCHOR_DATE et THEORETICAL_WEEK_ANCHOR_TYPE)"
+            ) from None
+        seen_ids: set[str] = set()
+        for entry in self._lessons:
+            effective_id = entry.id if entry.id is not None else _generate_id(entry)
+            if effective_id in seen_ids:
+                raise PronoteSyncError(
+                    f"Conflit d'identifiant dans l'agenda théorique : "
+                    f"l'identifiant '{effective_id}' est utilisé par plusieurs leçons. "
+                    f"Fournissez des identifiants explicites uniques."
+                ) from None
+            seen_ids.add(effective_id)
+
+    def get_lessons(self, target_date: date) -> list[TheoreticalLesson]:
+        """Retourne les cours théoriques applicables à la date donnée.
+
+        Si un calendrier de vacances est configuré et que la date tombe pendant
+        une période de vacances, la liste retournée est vide. La parité de la
+        semaine est déterminée via le service de parité lorsqu'il est configuré ;
+        sinon seuls les cours de type ``all`` sont conservés. Les entrées sont
+        ensuite filtrées par jour de la semaine, converties en
+        :class:`~pronote_sync.models.agenda.TheoreticalLesson` et triées par
+        identifiant.
+
+        :param target_date: Date cible.
+        :return: Liste des cours théoriques triée par identifiant.
+        :rtype: list[TheoreticalLesson]
+        """
+        if self._holiday_calendar is not None and self._holiday_calendar.is_holiday(target_date):
+            return []
+
+        week_parity: Literal["all", "even", "odd"]
+        if self._parity_service is not None:
+            week_parity = self._parity_service.parity_for(target_date)
+        else:
+            week_parity = "all"
+
+        lessons: list[TheoreticalLesson] = []
+        for entry in self._lessons:
+            if entry.week != "all" and entry.week != week_parity:
+                continue
+            if entry.day_of_week != target_date.weekday():
+                continue
+            lesson_id = entry.id if entry.id is not None else _generate_id(entry)
+            lessons.append(
+                TheoreticalLesson(
+                    id=lesson_id,
+                    day_of_week=entry.day_of_week,
+                    start_time=time.fromisoformat(entry.start_time),
+                    end_time=time.fromisoformat(entry.end_time),
+                    subject=entry.subject,
+                    teachers=entry.teachers,
+                    rooms=entry.rooms,
+                )
+            )
+        return sorted(lessons, key=lambda lesson: lesson.id)
+
+    def get_lessons_for_range(self, start_date: date, end_date: date) -> list[TheoreticalLesson]:
+        """Retourne les cours théoriques pour une plage de dates (inclusives).
+
+        Chaque date de la plage, bornes incluses, est évaluée via
+        :meth:`get_lessons`. Les cours sont dédupliqués par identifiant : pour
+        un identifiant donné, la dernière occurrence (date la plus récente)
+        écrase la précédente. Si ``start_date`` est postérieure à ``end_date``,
+        la liste retournée est vide.
+
+        :param start_date: Date de début (inclusive).
+        :param end_date: Date de fin (inclusive).
+        :return: Liste des cours théoriques triée par identifiant.
+        :rtype: list[TheoreticalLesson]
+        """
+        seen: dict[str, TheoreticalLesson] = {}
+        current_date = start_date
+        while current_date <= end_date:
+            for lesson in self.get_lessons(current_date):
+                seen[lesson.id] = lesson
+            current_date += timedelta(days=1)
+        return sorted(seen.values(), key=lambda lesson: lesson.id)

pronote_sync/sources/theoretical/holidays.py

@@ -0,0 +1,106 @@
+"""Service de calendrier des vacances scolaires.
+
+Ce module fournit les modèles de données :class:`HolidayPeriod` et
+:class:`SchoolHolidayFile`, ainsi que le service :class:`SchoolHolidayCalendar`
+qui charge un fichier JSON de périodes de vacances scolaires et permet de
+déterminer si une date donnée tombe pendant ces vacances.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import date
+from pathlib import Path
+from typing import Any, Self
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.utils.redaction import redact_exception, redact_secrets
+
+logger = logging.getLogger(__name__)
+
+
+class HolidayPeriod(BaseModel):
+    """Période de vacances scolaires, bornes incluses.
+
+    :ivar start_date: Date de début de la période (incluse).
+    :ivar end_date: Date de fin de la période (incluse).
+    :ivar label: Nom de la période (ex. « Toussaint »).
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    start_date: date
+    end_date: date
+    label: str
+
+    @model_validator(mode="after")
+    def _validate_date_order(self) -> Self:
+        """Vérifie que la date de fin n'est pas antérieure à la date de début.
+
+        :return: L'instance de période après validation.
+        :rtype: Self
+        :raises ValueError: Si ``end_date`` est strictement antérieure à ``start_date``.
+        """
+        if self.end_date < self.start_date:
+            raise ValueError("end_date doit être supérieure ou égale à start_date.")
+        return self
+
+
+class SchoolHolidayFile(BaseModel):
+    """Modèle de parsing d'un fichier JSON de vacances scolaires.
+
+    :ivar zone: Zone académique (ex. « A »).
+    :ivar school_year: Année scolaire (ex. « 2026-2027 »).
+    :ivar periods: Périodes de vacances scolaires du fichier.
+    """
+
+    zone: str
+    school_year: str
+    periods: tuple[HolidayPeriod, ...] = Field(default=())
+
+
+class SchoolHolidayCalendar:
+    """Calendrier des vacances scolaires chargé depuis un fichier JSON."""
+
+    def __init__(self, file_path: Path | str) -> None:
+        """Charge les périodes de vacances scolaires depuis un fichier JSON.
+
+        :param file_path: Chemin vers le fichier JSON.
+        :raises PronoteSyncError: Si le fichier ne peut être lu ou analysé.
+        """
+        path = Path(file_path)
+        self._periods: tuple[HolidayPeriod, ...]
+        if not path.is_file():
+            raise PronoteSyncError(
+                f"Le fichier de vacances scolaires est introuvable : {redact_secrets(str(path))}"
+            ) from None
+        try:
+            data: Any = json.loads(path.read_text(encoding="utf-8"))
+            file_model: SchoolHolidayFile = SchoolHolidayFile.model_validate(data)
+        except Exception as exc:
+            logger.error(
+                "Fichier de vacances scolaires invalide %s : %s.",
+                redact_secrets(str(path)),
+                redact_exception(exc),
+            )
+            raise PronoteSyncError(
+                f"Le fichier de vacances scolaires est invalide : {redact_secrets(str(path))}"
+            ) from None
+        self._periods = file_model.periods
+
+    def is_holiday(self, target_date: date) -> bool:
+        """Vérifie si la date donnée tombe pendant une période de vacances.
+
+        La date est considérée comme étant en vacances si elle appartient à
+        l'intervalle d'au moins une période, bornes incluses
+        (``start_date <= target_date <= end_date``).
+
+        :param target_date: Date à vérifier.
+        :return: ``True`` si la date tombe pendant les vacances scolaires,
+            ``False`` sinon.
+        :rtype: bool
+        """
+        return any(period.start_date <= target_date <= period.end_date for period in self._periods)

pronote_sync/sources/theoretical/model.py

@@ -0,0 +1,123 @@
+"""Modèles Pydantic de parsing du fichier JSON de l'agenda théorique.
+
+Ce module définit les modèles de parsing utilisés pour lire le fichier
+JSON de l'agenda théorique : :class:`TheoreticalLessonEntry` pour une
+entrée de cours et :class:`TheoreticalAgendaFile` pour le fichier
+complet.
+
+Ces modèles sont distincts du modèle de domaine
+:class:`~pronote_sync.models.agenda.TheoreticalLesson` : ils restent
+proches du format JSON brut (heures au format ``HH:MM``) et servent
+uniquement à la désérialisation, la conversion vers le modèle de domaine
+étant réalisée ensuite par le fournisseur.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+_TIME_PATTERN = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$")
+
+
+class TheoreticalLessonEntry(BaseModel):
+    """Représente une entrée de cours dans le fichier JSON de l'agenda théorique.
+
+    Modèle figé (``frozen``) : les instances sont immuables après
+    création. Le format des heures est validé (``HH:MM`` sur 24 heures,
+    avec ``HH`` entre ``00`` et ``23`` et ``MM`` entre ``00`` et ``59``)
+    ainsi que l'ordre des heures (fin postérieure au début).
+
+    :param week: Type de semaine auquel s'applique le cours
+        (``"all"``, ``"even"`` ou ``"odd"``).
+    :param day_of_week: Jour de la semaine (0 = lundi, 6 = dimanche).
+    :param start_time: Heure de début au format ``HH:MM`` sur 24 heures.
+    :param end_time: Heure de fin au format ``HH:MM`` sur 24 heures.
+    :param subject: Nom de la matière.
+    :param teachers: Noms des professeurs. Tuple vide par défaut.
+    :param rooms: Noms des salles. Tuple vide par défaut.
+    :param id: Identifiant explicite optionnel. ``None`` par défaut ; en
+        cas d'absence, le fournisseur en génère un.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    week: Literal["all", "even", "odd"] = Field(
+        ..., description="Type de semaine concerné (all, even ou odd)"
+    )
+    day_of_week: int = Field(
+        ..., ge=0, le=6, description="Jour de la semaine (0=lundi, 6=dimanche)"
+    )
+    start_time: str = Field(..., description="Heure de début au format HH:MM")
+    end_time: str = Field(..., description="Heure de fin au format HH:MM")
+    subject: str = Field(..., description="Nom de la matière")
+    teachers: tuple[str, ...] = Field(default=(), description="Noms des professeurs")
+    rooms: tuple[str, ...] = Field(default=(), description="Noms des salles")
+    id: str | None = Field(
+        default=None, description="Identifiant explicite optionnel (None si absent)"
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _validate_time_format(cls, data: Any) -> Any:
+        """Valide le format ``HH:MM`` des heures de début et de fin.
+
+        Les heures doivent être au format ``HH:MM`` sur 24 heures, avec
+        ``HH`` entre ``00`` et ``23`` et ``MM`` entre ``00`` et ``59``.
+        Cette validation précède :meth:`_validate_time_order`, dont la
+        comparaison par ordre lexicographique n'est fiable que si le
+        format est garanti.
+
+        :param data: Données brutes transmises au modèle.
+        :return: Les données brutes inchangées.
+        :rtype: Any
+        :raises ValueError: Si ``start_time`` ou ``end_time`` n'est pas
+            au format ``HH:MM``.
+        """
+        if not isinstance(data, dict):
+            return data
+        for field_name in ("start_time", "end_time"):
+            if field_name not in data:
+                continue
+            value = data[field_name]
+            if not isinstance(value, str) or _TIME_PATTERN.fullmatch(value) is None:
+                raise ValueError(
+                    f"{field_name} doit être au format HH:MM (HH entre 00 et 23, MM entre 00 et 59)"
+                )
+        return data
+
+    @model_validator(mode="after")
+    def _validate_time_order(self) -> TheoreticalLessonEntry:
+        """Valide que l'heure de fin est postérieure à l'heure de début.
+
+        La comparaison est effectuée sur les chaînes ``HH:MM`` de façon
+        lexicographique ; elle n'est fiable que parce que
+        :meth:`_validate_time_format` a déjà garanti le format à deux
+        chiffres.
+
+        :return: L'instance validée.
+        :rtype: TheoreticalLessonEntry
+        :raises ValueError: Si ``end_time`` n'est pas postérieur à
+            ``start_time``.
+        """
+        if self.end_time <= self.start_time:
+            raise ValueError("end_time doit être postérieur à start_time")
+        return self
+
+
+class TheoreticalAgendaFile(BaseModel):
+    """Représente le fichier JSON complet de l'agenda théorique.
+
+    Modèle de parsing non figé : il sert uniquement à désérialiser le
+    fichier JSON avant conversion vers les modèles de domaine.
+
+    :param version: Version du schéma du fichier (vaut ``1``).
+    :param lessons: Liste des entrées de cours du fichier.
+    """
+
+    version: Literal[1] = Field(default=1, description="Version du schéma (1)")
+    lessons: tuple[TheoreticalLessonEntry, ...] = Field(
+        ..., description="Liste des entrées de cours"
+    )

pronote_sync/sources/theoretical/parity.py

@@ -0,0 +1,55 @@
+"""Service déterministe de calcul de la parité des semaines pour l'agenda théorique.
+
+Ce module fournit :class:`WeekParityService`, un service sans état qui détermine
+si la semaine contenant une date donnée est paire ou impaire, à partir d'une
+date d'ancrage dont la parité est connue. L'algorithme repose sur le décalage
+entre les lundis des deux semaines, et non sur les numéros de semaine ISO.
+"""
+
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import Literal
+
+
+class WeekParityService:
+    """Service déterministe de calcul de la parité des semaines.
+
+    La parité d'une semaine est déduite d'une date d'ancrage fournie à la
+    construction : la semaine contenant cette date a une parité connue
+    (paire ou impaire). Le service est immuable après construction et ne
+    dépend d'aucun état global ni de l'horloge système.
+    """
+
+    def __init__(self, anchor_date: date, anchor_type: Literal["even", "odd"]) -> None:
+        """Initialise le service avec la date d'ancrage et sa parité.
+
+        :param anchor_date: Date de référence dont la semaine a une parité connue.
+        :param anchor_type: Parité de la semaine d'ancrage (``"even"`` ou ``"odd"``).
+        """
+        self._anchor_monday = anchor_date - timedelta(days=anchor_date.weekday())
+        self._anchor_type = anchor_type
+
+    def parity_for(self, target_date: date) -> Literal["even", "odd"]:
+        """Détermine la parité de la semaine contenant la date cible.
+
+        Algorithme :
+        1. Calculer le lundi de la semaine de la date cible.
+        2. Utiliser le lundi de la semaine de la date d'ancrage (stocké à
+           l'initialisation).
+        3. Calculer le nombre de semaines entre les deux lundis :
+           ``(target_monday - anchor_monday).days // 7``.
+        4. Si le décalage de semaines est pair, la cible a la même parité que
+           l'ancrage.
+        5. Si le décalage de semaines est impair, la cible a la parité opposée.
+
+        :param target_date: Date dont il faut déterminer la parité.
+        :return: ``"even"`` ou ``"odd"`` selon la parité de la semaine cible.
+        :rtype: Literal["even", "odd"]
+        """
+        target_monday = target_date - timedelta(days=target_date.weekday())
+        week_offset = (target_monday - self._anchor_monday).days // 7
+        if week_offset % 2 == 0:
+            return self._anchor_type
+        # Inverse la parité.
+        return "odd" if self._anchor_type == "even" else "even"

pronote_sync/sources/theoretical/provider.py

@@ -0,0 +1,44 @@
+"""Protocole pour les fournisseurs d'agenda théorique.
+
+Ce module définit :class:`TheoreticalAgendaProvider`, le contrat que
+tous les fournisseurs d'agenda théorique doivent respecter pour exposer
+les cours théoriques (emploi du temps attendu) par date ou plage de
+dates.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Protocol, runtime_checkable
+
+from pronote_sync.models.agenda import TheoreticalLesson
+
+
+@runtime_checkable
+class TheoreticalAgendaProvider(Protocol):
+    """Protocole pour un fournisseur d'agenda théorique.
+
+    Un fournisseur d'agenda théorique expose les cours théoriques
+    (emploi du temps attendu) pour une date ou une plage de dates.
+    L'implémentation encapsule la logique de filtrage par parité de
+    semaine et par vacances scolaires.
+    """
+
+    def get_lessons(self, target_date: date) -> list[TheoreticalLesson]:
+        """Retourne les cours théoriques applicables à la date donnée.
+
+        :param target_date: Date cible.
+        :return: Liste des cours théoriques triée par identifiant.
+        :rtype: list[TheoreticalLesson]
+        """
+        ...
+
+    def get_lessons_for_range(self, start_date: date, end_date: date) -> list[TheoreticalLesson]:
+        """Retourne les cours théoriques pour une plage de dates (inclusives).
+
+        :param start_date: Date de début (inclusive).
+        :param end_date: Date de fin (inclusive).
+        :return: Liste des cours théoriques triée par identifiant.
+        :rtype: list[TheoreticalLesson]
+        """
+        ...

tests/fixtures/blog_rss.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8"?>
+<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <channel>
+    <title>Blog du collège Les Mimosas</title>
+    <link>https://example.com/blog/</link>
+    <description>Actualités et informations du collège Les Mimosas</description>
+    <language>fr-FR</language>
+    <item>
+      <title>Information générale</title>
+      <link>https://example.com/blog/?p=1003</link>
+      <guid isPermaLink="false">https://example.com/blog/?p=1003</guid>
+      <pubDate>Wed, 12 Aug 2026 08:00:00 +0000</pubDate>
+      <description>Information générale à destination des familles.</description>
+      <content:encoded><![CDATA[
+        <p>La vie scolaire rappelle aux familles que les billets de cantine sont à commander avant le vendredi soir.</p>
+        <p>Pour toute question, consultez la page <a href="https://example.com/blog/cantine/">cantines et restauration</a> du site.</p>
+      ]]></content:encoded>
+    </item>
+    <item>
+      <title>Réunion de rentrée</title>
+      <link>https://example.com/blog/?p=1001</link>
+      <guid isPermaLink="false">https://example.com/blog/?p=1001</guid>
+      <pubDate>Mon, 10 Aug 2026 09:00:11 +0000</pubDate>
+      <category>Administration</category>
+      <dc:creator>M. Dupont</dc:creator>
+      <description>Réunion de rentrée des parents d'élèves.</description>
+      <content:encoded><![CDATA[
+        <p>La réunion de rentrée des parents d'élèves se tiendra le mardi 15 septembre à 18 h 00 dans la salle polyvalente.</p>
+        <p>L'équipe pédagogique y présentera le projet d'établissement et le calendrier des conseils de classe. Un temps d'échange est prévu avec les professeurs principaux.</p>
+        <p>Merci de confirmer votre présence en remplissant le <a href="https://example.com/blog/reunion-rentree-inscription/">formulaire d'inscription</a> avant le 10 septembre.</p>
+      ]]></content:encoded>
+    </item>
+    <item>
+      <title>Sortie pédagogique au musée</title>
+      <link>https://example.com/blog/?p=1002</link>
+      <guid isPermaLink="false">https://example.com/blog/?p=1002</guid>
+      <pubDate>Tue, 11 Aug 2026 14:30:00 +0000</pubDate>
+      <category>Pédagogie</category>
+      <description>Sortie pédagogique des élèves de 4e au musée d'art moderne.</description>
+      <content:encoded><![CDATA[
+        <p>Les élèves de 4e se rendront au musée d'art moderne le jeudi 8 octobre dans le cadre du cours d'arts plastiques.</p>
+        <p>La visite guidée portera sur la période impressionniste. Les élèves devront apporter un carnet de croquis et leur pique-nique.</p>
+        <p>Le détail de l'organisation figure dans la <a href="https://example.com/blog/sortie-musee-autorisation/">note d'autorisation</a> à retourner signée avant le 25 septembre.</p>
+      ]]></content:encoded>
+    </item>
+  </channel>
+</rss>

tests/fixtures/school_holidays.json

@@ -0,0 +1,26 @@
+{
+  "zone": "A",
+  "school_year": "2026-2027",
+  "periods": [
+    {
+      "start_date": "2026-10-17",
+      "end_date": "2026-11-02",
+      "label": "Toussaint"
+    },
+    {
+      "start_date": "2026-12-19",
+      "end_date": "2027-01-04",
+      "label": "Noël"
+    },
+    {
+      "start_date": "2027-02-06",
+      "end_date": "2027-02-22",
+      "label": "Hiver"
+    },
+    {
+      "start_date": "2027-04-03",
+      "end_date": "2027-04-19",
+      "label": "Printemps"
+    }
+  ]
+}

tests/fixtures/theoretical.json

@@ -0,0 +1,87 @@
+{
+  "version": 1,
+  "lessons": [
+    {
+      "id": "theoretical-maths-monday-1",
+      "week": "all",
+      "day_of_week": 0,
+      "start_time": "08:00",
+      "end_time": "09:00",
+      "subject": "Mathématiques",
+      "teachers": ["Mme Martin"],
+      "rooms": ["101"]
+    },
+    {
+      "week": "all",
+      "day_of_week": 0,
+      "start_time": "09:00",
+      "end_time": "10:00",
+      "subject": "Français",
+      "teachers": ["M. Dupont"],
+      "rooms": ["102"]
+    },
+    {
+      "week": "all",
+      "day_of_week": 0,
+      "start_time": "11:00",
+      "end_time": "12:00",
+      "subject": "Histoire-Géographie",
+      "teachers": ["Mme Petit"],
+      "rooms": ["103"]
+    },
+    {
+      "week": "even",
+      "day_of_week": 1,
+      "start_time": "10:00",
+      "end_time": "11:00",
+      "subject": "Anglais",
+      "teachers": ["Mme Bernard"],
+      "rooms": ["201"]
+    },
+    {
+      "week": "even",
+      "day_of_week": 1,
+      "start_time": "10:00",
+      "end_time": "11:00",
+      "subject": "Technologie",
+      "teachers": [],
+      "rooms": []
+    },
+    {
+      "week": "odd",
+      "day_of_week": 1,
+      "start_time": "10:00",
+      "end_time": "11:00",
+      "subject": "Espagnol",
+      "teachers": ["M. Garcia"],
+      "rooms": ["202"]
+    },
+    {
+      "week": "odd",
+      "day_of_week": 1,
+      "start_time": "10:00",
+      "end_time": "11:00",
+      "subject": "Éducation musicale",
+      "teachers": [],
+      "rooms": []
+    },
+    {
+      "week": "all",
+      "day_of_week": 2,
+      "start_time": "14:00",
+      "end_time": "15:00",
+      "subject": "Sciences",
+      "teachers": [],
+      "rooms": ["203"]
+    },
+    {
+      "week": "all",
+      "day_of_week": 4,
+      "start_time": "09:00",
+      "end_time": "10:00",
+      "subject": "Arts plastiques",
+      "teachers": [],
+      "rooms": []
+    }
+  ]
+}

tests/unit/test_blog_state.py

@@ -0,0 +1,350 @@
+"""Tests unitaires pour le gestionnaire d'état du flux RSS du blog.
+
+Ce module valide le comportement de :class:`BlogRSSState` dans
+:mod:`pronote_sync.sources.blog.state`. Les tests couvrent :
+
+- La persistance des GUID connus et des en-têtes de cache HTTP,
+- La tolérance aux erreurs (fichier absent, corrompu, version incompatible),
+- Le tri alphabétique des GUID lors de la sauvegarde,
+- La réinitialisation complète de l'état.
+
+Tous les tests utilisent des fichiers temporaires via la fixture ``tmp_path``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from pronote_sync.sources.blog.state import BlogRSSState
+
+
+def test_state_file_absent_empty_state(tmp_path: Path) -> None:
+    """Vérifie qu'un fichier d'état absent initialise un état vide.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "nonexistent.json"
+    state = BlogRSSState(state_file)
+
+    assert state.get_known_guids() == frozenset()
+    assert state.get_cache_headers() == (None, None)
+
+
+def test_add_guids_persists(tmp_path: Path) -> None:
+    """Vérifie que l'ajout de GUID persiste dans le fichier JSON.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["guid-2", "guid-1", "guid-3"])
+
+    assert state.get_known_guids() == frozenset({"guid-1", "guid-2", "guid-3"})
+
+    # Vérification du contenu du fichier
+    saved_data = json.loads(state_file.read_text(encoding="utf-8"))
+    assert saved_data["known_guids"] == ["guid-1", "guid-2", "guid-3"]
+
+
+def test_add_guids_empty_noop(tmp_path: Path) -> None:
+    """Vérifie que l'ajout d'une liste vide ne modifie pas le fichier.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    # Ajout initial de GUID
+    state.add_guids(["guid-1"])
+    original_content = state_file.read_text(encoding="utf-8")
+
+    # Ajout d'une liste vide
+    state.add_guids([])
+
+    # Vérification que le fichier n'a pas été modifié (comparaison par contenu)
+    assert state_file.read_text(encoding="utf-8") == original_content
+
+
+def test_state_load_persisted_guids(tmp_path: Path) -> None:
+    """Vérifie que les GUID persistés sont rechargés dans une nouvelle instance.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+
+    # Création et sauvegarde de l'état initial
+    state1 = BlogRSSState(state_file)
+    state1.add_guids(["guid-1", "guid-2"])
+
+    # Création d'une nouvelle instance avec le même fichier
+    state2 = BlogRSSState(state_file)
+
+    assert state2.get_known_guids() == frozenset({"guid-1", "guid-2"})
+
+
+def test_state_load_cache_headers(tmp_path: Path) -> None:
+    """Vérifie que les en-têtes de cache persistés sont rechargés.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+
+    # Création et sauvegarde des en-têtes de cache
+    state1 = BlogRSSState(state_file)
+    state1.update_cache_headers("etag-123", "Wed, 01 Sep 2026 GMT")
+
+    # Création d'une nouvelle instance avec le même fichier
+    state2 = BlogRSSState(state_file)
+
+    assert state2.get_cache_headers() == ("etag-123", "Wed, 01 Sep 2026 GMT")
+
+
+def test_corrupt_json_warning(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'un fichier JSON corrompu déclenche un avertissement et initialise un état vide.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "corrupt.json"
+    state_file.write_text("not json{", encoding="utf-8")
+
+    with caplog.at_level("WARNING"):
+        state = BlogRSSState(state_file)
+
+    assert state.get_known_guids() == frozenset()
+    assert state.get_cache_headers() == (None, None)
+    assert "Impossible de charger le fichier d'état blog RSS" in caplog.text
+
+
+def test_wrong_version_warning(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'une version incompatible déclenche un avertissement et initialise un état vide.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "wrong_version.json"
+    state_file.write_text(
+        json.dumps({"version": 99, "known_guids": ["x"], "etag": None, "last_modified": None}),
+        encoding="utf-8",
+    )
+
+    with caplog.at_level("WARNING"):
+        state = BlogRSSState(state_file)
+
+    assert state.get_known_guids() == frozenset()
+    assert state.get_cache_headers() == (None, None)
+    assert "version absente ou non supportée" in caplog.text
+
+
+def test_missing_version_warning(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Vérifie qu'un fichier sans champ version déclenche un avertissement et initialise un état vide.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :param caplog: Fixture pytest pour capturer les logs.
+    :return: None
+    """
+    state_file = tmp_path / "missing_version.json"
+    state_file.write_text(
+        json.dumps({"known_guids": ["x"], "etag": None, "last_modified": None}),
+        encoding="utf-8",
+    )
+
+    with caplog.at_level("WARNING"):
+        state = BlogRSSState(state_file)
+
+    assert state.get_known_guids() == frozenset()
+    assert state.get_cache_headers() == (None, None)
+    assert "version absente ou non supportée" in caplog.text
+
+
+def test_known_guids_sorted_on_save(tmp_path: Path) -> None:
+    """Vérifie que les GUID sont triés alphabétiquement lors de la sauvegarde.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["c-guid", "a-guid", "b-guid"])
+
+    saved_data = json.loads(state_file.read_text(encoding="utf-8"))
+    assert saved_data["known_guids"] == ["a-guid", "b-guid", "c-guid"]
+
+
+def test_clear_resets_state(tmp_path: Path) -> None:
+    """Vérifie que la méthode clear réinitialise complètement l'état.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    # Ajout de GUID et d'en-têtes de cache
+    state.add_guids(["guid-1", "guid-2"])
+    state.update_cache_headers("etag-123", "Wed, 01 Sep 2026 GMT")
+
+    # Réinitialisation
+    state.clear()
+
+    assert state.get_known_guids() == frozenset()
+    assert state.get_cache_headers() == (None, None)
+
+    # Vérification du contenu du fichier
+    saved_data = json.loads(state_file.read_text(encoding="utf-8"))
+    assert saved_data["known_guids"] == []
+    assert saved_data["etag"] is None
+    assert saved_data["last_modified"] is None
+
+
+def test_clear_persists_to_file(tmp_path: Path) -> None:
+    """Vérifie que la réinitialisation est persistée dans le fichier.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+
+    # Création, ajout de données et réinitialisation
+    state1 = BlogRSSState(state_file)
+    state1.add_guids(["guid-1"])
+    state1.update_cache_headers("etag-123", "Wed, 01 Sep 2026 GMT")
+    state1.clear()
+
+    # Création d'une nouvelle instance avec le même fichier
+    state2 = BlogRSSState(state_file)
+
+    assert state2.get_known_guids() == frozenset()
+    assert state2.get_cache_headers() == (None, None)
+
+
+def test_str_path_converted_to_path(tmp_path: Path) -> None:
+    """Vérifie qu'un chemin de type str est converti en Path.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = str(tmp_path / "state.json")
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["guid-1"])
+
+    assert Path(state_file).exists()
+
+
+def test_update_cache_headers_none_values(tmp_path: Path) -> None:
+    """Vérifie que la mise à jour avec des valeurs None fonctionne correctement.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.update_cache_headers(None, None)
+
+    assert state.get_cache_headers() == (None, None)
+
+    # Vérification du contenu du fichier
+    saved_data = json.loads(state_file.read_text(encoding="utf-8"))
+    assert saved_data["etag"] is None
+    assert saved_data["last_modified"] is None
+
+
+def test_add_guids_multiple_calls(tmp_path: Path) -> None:
+    """Vérifie que plusieurs appels à add_guids accumulent les GUID.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["guid-1"])
+    state.add_guids(["guid-2"])
+
+    assert state.get_known_guids() == frozenset({"guid-1", "guid-2"})
+
+
+def test_version_in_saved_file(tmp_path: Path) -> None:
+    """Vérifie que le champ version est présent dans le fichier sauvegardé.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["guid-1"])
+
+    saved_data = json.loads(state_file.read_text(encoding="utf-8"))
+    assert saved_data["version"] == 1
+
+
+def test_get_known_guids_returns_frozenset(tmp_path: Path) -> None:
+    """Vérifie que get_known_guids retourne un frozenset.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+    state = BlogRSSState(state_file)
+
+    state.add_guids(["guid-1", "guid-2"])
+
+    result = state.get_known_guids()
+    assert type(result) is frozenset
+
+
+def test_atomic_save_preserves_on_error(tmp_path: Path) -> None:
+    """Vérifie que l'état original est préservé en cas d'erreur lors de la sauvegarde atomique.
+
+    Si une erreur survient pendant le remplacement atomique du fichier,
+    le fichier original doit rester intact et le fichier temporaire doit être nettoyé.
+
+    :param tmp_path: Fixture pytest pour un répertoire temporaire.
+    :return: None
+    """
+    state_file = tmp_path / "state.json"
+
+    # Créer un état initial avec des GUID
+    state = BlogRSSState(state_file)
+    state.add_guids(["original-guid-1", "original-guid-2"])
+
+    # Lire le contenu original
+    original_content = state_file.read_text(encoding="utf-8")
+
+    # Mock Path.replace pour simuler une erreur pendant le remplacement atomique
+    with patch.object(Path, "replace") as mock_replace:
+        mock_replace.side_effect = OSError("Simulated atomic replace failure")
+
+        # Essayer d'ajouter de nouveaux GUID, ce qui déclenchera _save()
+        state.add_guids(["new-guid"])
+
+    # Vérifier que le fichier original est toujours intact
+    assert state_file.read_text(encoding="utf-8") == original_content
+
+    # Vérifier que le fichier temporaire a été nettoyé
+    tmp_file = state_file.with_suffix(".tmp")
+    assert not tmp_file.exists()
+
+    # Vérifier que l'état en mémoire n'a pas été modifié (car la sauvegarde a échoué)
+    # Note: En réalité, l'état en mémoire est modifié mais pas persistant
+    # C'est le fichier qui doit rester intact
+    assert state.get_known_guids() == frozenset({"original-guid-1", "original-guid-2", "new-guid"})
+
+
+# Ensure trailing newline

tests/unit/test_fallback.py

@@ -85,6 +85,7 @@ def test_fetch_agenda_ical_mode(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     start_dt = datetime(2025, 9, 1, 8, 0)
     end_dt = datetime(2025, 9, 1, 9, 30)
@@ -133,6 +134,7 @@ def test_fetch_agenda_pronotepy_mode(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     start_dt = datetime(2025, 9, 1, 8, 0)
     end_dt = datetime(2025, 9, 1, 9, 30)
@@ -168,6 +170,7 @@ def test_fetch_agenda_auto_ical_success(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     start_dt = datetime(2025, 9, 1, 8, 0)
     end_dt = datetime(2025, 9, 1, 9, 30)
@@ -204,6 +207,7 @@ def test_fetch_agenda_auto_fallback_to_pronotepy(mock_fetcher: PronoteFetcher) -
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     start_dt = datetime(2025, 9, 1, 8, 0)
     end_dt = datetime(2025, 9, 1, 9, 30)
@@ -244,6 +248,7 @@ def test_fetch_agenda_auto_both_fail(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     # Disable pronotepy so fallback is None
     mock_fetcher._settings.pronote.pronote_url = None
@@ -271,6 +276,7 @@ def test_fetch_agenda_ical_mode_failure(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     # Override settings to use ical mode explicitly and disable fallback
     mock_fetcher._settings.pronote.agenda_source = "ical"
@@ -301,6 +307,7 @@ def test_fetch_agenda_pronotepy_mode_failure(mock_fetcher: PronoteFetcher) -> No
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     # Override settings to use pronotepy mode explicitly and disable fallback
     mock_fetcher._settings.pronote.agenda_source = "pronotepy"
@@ -324,6 +331,7 @@ def test_fetch_homework_ical_mode(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 5)
 
@@ -385,6 +393,7 @@ def test_fetch_homework_auto_fallback(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 10)
     homeworks = [
@@ -424,6 +433,7 @@ def test_fetch_homework_auto_both_fail(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 10)
 
@@ -453,6 +463,7 @@ def test_fetch_messages(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     messages = [
         Message(
@@ -483,6 +494,7 @@ def test_fetch_informations(mock_fetcher: PronoteFetcher) -> None:
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     infos = [
         Message(
@@ -516,6 +528,7 @@ def test_no_secrets_in_error_messages(
     :param mock_fetcher: Fetcher de test.
     :param caplog: Fixture pytest pour capturer les logs.
     :return: None
+    :rtype: None
     """
     # Disable pronotepy so fallback is None to trigger PipelineCriticalError
     mock_fetcher._settings.pronote.pronote_url = None
@@ -541,30 +554,18 @@ def test_no_secrets_in_error_messages(
         assert "icalsecurise=REDACTED" in caplog.text or "icalsecurise" not in caplog.text
 
 
-def test_fetch_agenda_ical_mode_fallback_to_pronotepy(mock_fetcher: PronoteFetcher) -> None:
+def test_fetch_agenda_ical_mode_does_not_fallback_to_pronotepy(
-    """Test le mode ICAL : échec iCal, repli sur pronotepy.
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode ICAL : échec iCal, PAS de repli sur pronotepy.
 
-    On mock iCal pour échouer, pronotepy pour réussir. On vérifie que pronotepy est appelé.
+    On mock iCal pour échouer. On vérifie que pronotepy n'est PAS appelé
+    et qu'une PipelineCriticalError est levée.
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
-    start_dt = datetime(2025, 9, 1, 8, 0)
-    end_dt = datetime(2025, 9, 1, 9, 30)
-    lessons = [
-        Lesson(
-            id="l1",
-            start=start_dt,
-            end=end_dt,
-            subject="Maths",
-            teachers=("Dupont",),
-            rooms=("S1",),
-            group="2ndeA",
-            status=LessonStatus.NORMAL,
-            content=None,
-        )
-    ]
-
     # Override settings to use ical mode explicitly
     mock_fetcher._settings.pronote.agenda_source = "ical"
 
@@ -575,40 +576,28 @@ def test_fetch_agenda_ical_mode_fallback_to_pronotepy(mock_fetcher: PronoteFetch
         m_fetch_ical.side_effect = OSError("iCal unreachable")
         m_parse_ical.side_effect = OSError("iCal parse error")
         client = MagicMock()
-        client.get_lessons.return_value = lessons
         mock_fetcher._pronote_client = client
 
-        result_lessons, result_events = mock_fetcher.fetch_agenda()
+        with pytest.raises(PipelineCriticalError) as exc_info:
+            mock_fetcher.fetch_agenda()
 
-        assert result_lessons == lessons
+        assert "la source ical a échoué" in str(exc_info.value)
-        assert result_events == []
+        # Vérifie que pronotepy n'a PAS été appelé
-        client.get_lessons.assert_called_once()
+        client.get_lessons.assert_not_called()
 
 
-def test_fetch_agenda_pronotepy_mode_fallback_to_ical(mock_fetcher: PronoteFetcher) -> None:
+def test_fetch_agenda_pronotepy_mode_does_not_fallback_to_ical(
-    """Test le mode PRONOTEPY : échec pronotepy, repli sur iCal.
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode PRONOTEPY : échec pronotepy, PAS de repli sur iCal.
 
-    On mock pronotepy pour échouer, iCal pour réussir. On vérifie que iCal est appelé.
+    On mock pronotepy pour échouer. On vérifie que iCal n'est PAS appelé
+    et qu'une PipelineCriticalError est levée.
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
-    start_dt = datetime(2025, 9, 1, 8, 0)
-    end_dt = datetime(2025, 9, 1, 9, 30)
-    lessons = [
-        Lesson(
-            id="l1",
-            start=start_dt,
-            end=end_dt,
-            subject="SVT",
-            teachers=("Durand",),
-            rooms=("S2",),
-            group="3emeC",
-            status=LessonStatus.NORMAL,
-            content=None,
-        )
-    ]
-
     # Override settings to use pronotepy mode explicitly
     mock_fetcher._settings.pronote.agenda_source = "pronotepy"
 
@@ -619,15 +608,14 @@ def test_fetch_agenda_pronotepy_mode_fallback_to_ical(mock_fetcher: PronoteFetch
         client = MagicMock()
         client.get_lessons.side_effect = OSError("Pronote API error")
         mock_fetcher._pronote_client = client
-        m_fetch_ical.return_value = "BEGIN:VCALENDAR\n..."
-        m_parse_ical.return_value = (lessons, [], [])
 
-        result_lessons, result_events = mock_fetcher.fetch_agenda()
+        with pytest.raises(PipelineCriticalError) as exc_info:
+            mock_fetcher.fetch_agenda()
 
-        assert result_lessons == lessons
+        assert "la source pronotepy a échoué" in str(exc_info.value)
-        assert result_events == []
+        # Vérifie que iCal n'a PAS été appelé
-        m_fetch_ical.assert_called_once()
+        m_fetch_ical.assert_not_called()
-        m_parse_ical.assert_called_once()
+        m_parse_ical.assert_not_called()
 
 
 def test_fetch_agenda_no_source_configured_raises(mock_fetcher: PronoteFetcher) -> None:
@@ -637,6 +625,7 @@ def test_fetch_agenda_no_source_configured_raises(mock_fetcher: PronoteFetcher)
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     # Disable both sources
     mock_fetcher._settings.pronote.ical_url = None
@@ -648,6 +637,130 @@ def test_fetch_agenda_no_source_configured_raises(mock_fetcher: PronoteFetcher)
     assert "ni la source iCal ni pronotepy n'est configurée" in str(exc_info.value)
 
 
+def test_fetch_agenda_ical_mode_empty_list_is_success(mock_fetcher: PronoteFetcher) -> None:
+    """Test le mode ICAL : liste vide = succès valide, sans repli.
+
+    On mock iCal pour retourner une liste vide. On vérifie que le résultat
+    est ([], []) et qu'aucun repli n'est tenté.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    mock_fetcher._settings.pronote.agenda_source = "ical"
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+    ):
+        m_fetch_ical.return_value = "BEGIN:VCALENDAR\n..."
+        m_parse_ical.return_value = ([], [], [])
+        client = MagicMock()
+        mock_fetcher._pronote_client = client
+
+        result_lessons, result_events = mock_fetcher.fetch_agenda()
+
+        assert result_lessons == []
+        assert result_events == []
+        # Vérifie que pronotepy n'a PAS été appelé
+        client.get_lessons.assert_not_called()
+
+
+def test_fetch_agenda_pronotepy_mode_empty_list_is_success(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode PRONOTEPY : liste vide = succès valide, sans repli.
+
+    On mock pronotepy pour retourner une liste vide. On vérifie que le résultat
+    est ([], []) et qu'aucun repli n'est tenté.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    mock_fetcher._settings.pronote.agenda_source = "pronotepy"
+
+    client = MagicMock()
+    client.get_lessons.return_value = []
+    mock_fetcher._pronote_client = client
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+    ):
+        result_lessons, result_events = mock_fetcher.fetch_agenda()
+
+        assert result_lessons == []
+        assert result_events == []
+        # Vérifie que iCal n'a PAS été appelé
+        m_fetch_ical.assert_not_called()
+        m_parse_ical.assert_not_called()
+
+
+def test_fetch_homework_ical_mode_empty_list_is_success(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode ICAL des devoirs : liste vide = succès valide, sans repli.
+
+    On mock iCal pour retourner une liste vide. On vérifie que le résultat
+    est [] et qu'aucun repli n'est tenté.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    target_date = date(2025, 9, 10)
+    mock_fetcher._settings.pronote.homework_source = "ical"
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+        patch("pronote_sync.sources.pronote.fallback.collect_homeworks") as m_collect,
+    ):
+        m_fetch_ical.return_value = "BEGIN:VCALENDAR\n..."
+        m_parse_ical.return_value = ([], [], [])
+        m_collect.return_value = []
+        client = MagicMock()
+        mock_fetcher._pronote_client = client
+
+        result = mock_fetcher.fetch_homework(target_date)
+
+        assert result == []
+        # Vérifie que pronotepy n'a PAS été appelé
+        client.get_homeworks.assert_not_called()
+
+
+def test_fetch_homework_pronotepy_mode_empty_list_is_success(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode PRONOTEPY des devoirs : liste vide = succès valide, sans repli.
+
+    On mock pronotepy pour retourner une liste vide. On vérifie que le résultat
+    est [] et qu'aucun repli n'est tenté.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    target_date = date(2025, 9, 10)
+    mock_fetcher._settings.pronote.homework_source = "pronotepy"
+
+    client = MagicMock()
+    client.get_homeworks.return_value = []
+    mock_fetcher._pronote_client = client
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+    ):
+        result = mock_fetcher.fetch_homework(target_date)
+
+        assert result == []
+        # Vérifie que iCal n'a PAS été appelé
+        m_fetch_ical.assert_not_called()
+        m_parse_ical.assert_not_called()
+
+
 def test_fetch_homework_filters_by_target_date(mock_fetcher: PronoteFetcher) -> None:
     """Test que les devoirs sont filtrés par date cible en mode pronotepy.
 
@@ -656,6 +769,7 @@ def test_fetch_homework_filters_by_target_date(mock_fetcher: PronoteFetcher) ->
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 10)
     other_date = date(2025, 9, 11)
@@ -693,6 +807,72 @@ def test_fetch_homework_filters_by_target_date(mock_fetcher: PronoteFetcher) ->
     client.get_homeworks.assert_called_once()
 
 
+def test_fetch_homework_ical_mode_does_not_fallback_to_pronotepy(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode ICAL des devoirs : échec iCal, PAS de repli sur pronotepy.
+
+    On mock iCal pour échouer. On vérifie que pronotepy n'est PAS appelé
+    et qu'une PipelineCriticalError est levée.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    target_date = date(2025, 9, 10)
+    mock_fetcher._settings.pronote.homework_source = "ical"
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+        patch("pronote_sync.sources.pronote.fallback.collect_homeworks") as m_collect,
+    ):
+        m_fetch_ical.side_effect = OSError("iCal unreachable")
+        m_parse_ical.side_effect = OSError("iCal parse error")
+        client = MagicMock()
+        mock_fetcher._pronote_client = client
+        m_collect.side_effect = OSError("collect error")
+
+        with pytest.raises(PipelineCriticalError) as exc_info:
+            mock_fetcher.fetch_homework(target_date)
+
+        assert "la source ical a échoué" in str(exc_info.value)
+        # Vérifie que pronotepy n'a PAS été appelé
+        client.get_homeworks.assert_not_called()
+
+
+def test_fetch_homework_pronotepy_mode_does_not_fallback_to_ical(
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test le mode PRONOTEPY des devoirs : échec pronotepy, PAS de repli sur iCal.
+
+    On mock pronotepy pour échouer. On vérifie que iCal n'est PAS appelé
+    et qu'une PipelineCriticalError est levée.
+
+    :param mock_fetcher: Fetcher de test.
+    :return: None
+    :rtype: None
+    """
+    target_date = date(2025, 9, 10)
+    mock_fetcher._settings.pronote.homework_source = "pronotepy"
+
+    with (
+        patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
+        patch("pronote_sync.sources.pronote.fallback.parse_ical") as m_parse_ical,
+    ):
+        client = MagicMock()
+        client.get_homeworks.side_effect = OSError("Pronote API error")
+        mock_fetcher._pronote_client = client
+
+        with pytest.raises(PipelineCriticalError) as exc_info:
+            mock_fetcher.fetch_homework(target_date)
+
+        assert "la source pronotepy a échoué" in str(exc_info.value)
+        # Vérifie que iCal n'a PAS été appelé
+        m_fetch_ical.assert_not_called()
+        m_parse_ical.assert_not_called()
+
+
 def test_fetch_messages_logs_and_re_raises(
     mock_fetcher: PronoteFetcher, caplog: pytest.LogCaptureFixture
 ) -> None:
@@ -704,6 +884,7 @@ def test_fetch_messages_logs_and_re_raises(
     :param mock_fetcher: Fetcher de test.
     :param caplog: Fixture pytest pour capturer les logs.
     :return: None
+    :rtype: None
     """
     client = MagicMock()
     error_msg = "Erreur Pronote : impossible de récupérer les messages https://pronote.example.com/messages?token=SECRET_TOKEN_456"
@@ -729,6 +910,7 @@ def test_fetch_agenda_ical_url_none_raises_value_error(mock_fetcher: PronoteFetc
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.ical_url = None
     with pytest.raises(ValueError, match="PRONOTE_ICAL_URL est requis pour la source iCal"):
@@ -743,6 +925,7 @@ def test_agenda_sources_auto_only_pronotepy_configured(mock_fetcher: PronoteFetc
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.agenda_source = "auto"
     mock_fetcher._settings.pronote.ical_url = None
@@ -754,13 +937,14 @@ def test_agenda_sources_auto_only_pronotepy_configured(mock_fetcher: PronoteFetc
 def test_fetch_agenda_fallback_both_fail_raises_pipeline_critical_error(
     mock_fetcher: PronoteFetcher,
 ) -> None:
-    """Test que fetch_agenda lève PipelineCriticalError si ICAL échoue et pronotepy aussi.
+    """Test que fetch_agenda lève PipelineCriticalError en mode explicite ical.
 
-    On mock ICAL pour échouer, on garde pronotepy configuré mais on mock son échec.
+    On mock ICAL pour échouer. On vérifie que l'erreur critique est levée
-    On vérifie que l'erreur PipelineCriticalError est levée.
+    et que pronotepy n'est PAS appelé (pas de repli en mode explicite).
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.agenda_source = "ical"
 
@@ -777,21 +961,26 @@ def test_fetch_agenda_fallback_both_fail_raises_pipeline_critical_error(
         with pytest.raises(PipelineCriticalError) as exc_info:
             mock_fetcher.fetch_agenda()
 
-        assert "les sources ical et pronotepy ont échoué" in str(exc_info.value)
+        # En mode explicite, seul l'échec de la source primaire est rapporté
+        assert "la source ical a échoué" in str(exc_info.value)
+        # Vérifie que pronotepy n'a PAS été appelé (pas de repli en mode explicite)
+        client.get_lessons.assert_not_called()
 
 
-def test_fetch_agenda_fallback_returns_empty_logs_warning(
+def test_fetch_agenda_auto_fallback_returns_empty_logs_warning(
     mock_fetcher: PronoteFetcher, caplog: pytest.LogCaptureFixture
 ) -> None:
     """Test que fetch_agenda retourne ([], []) et journalise un avertissement si le repli retourne vide.
 
     On mock ICAL pour échouer, pronotepy configuré et retourne vide. On vérifie le retour et le log.
+    Ce test utilise le mode AUTO pour tester le comportement de repli.
 
     :param mock_fetcher: Fetcher de test.
     :param caplog: Fixture pytest pour capturer les logs.
     :return: None
+    :rtype: None
     """
-    mock_fetcher._settings.pronote.agenda_source = "ical"
+    mock_fetcher._settings.pronote.agenda_source = "auto"
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -813,21 +1002,22 @@ def test_fetch_agenda_fallback_returns_empty_logs_warning(
         assert "a retourné un résultat vide après l'échec de ical" in caplog.text
 
 
-def test_homework_sources_explicit_ical_mode(mock_fetcher: PronoteFetcher) -> None:
+def test_homework_sources_explicit_ical_mode_strict(mock_fetcher: PronoteFetcher) -> None:
-    """Test _homework_sources en mode ICAL.
+    """Test _homework_sources en mode ICAL : strict, sans repli.
 
-    On vérifie que la source primaire est ical et que le repli est pronotepy si configuré,
+    On vérifie que la source primaire est ical et que le repli est TOUJOURS None,
-    ou None sinon.
+    même si pronotepy est configuré.
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.homework_source = "ical"
 
     # With pronotepy configured
     primary, fallback = mock_fetcher._homework_sources()
     assert primary == "ical"
-    assert fallback == "pronotepy"
+    assert fallback is None
 
     # Without pronotepy configured
     mock_fetcher._settings.pronote.pronote_url = None
@@ -836,21 +1026,24 @@ def test_homework_sources_explicit_ical_mode(mock_fetcher: PronoteFetcher) -> No
     assert fallback is None
 
 
-def test_homework_sources_explicit_pronotepy_mode(mock_fetcher: PronoteFetcher) -> None:
+def test_homework_sources_explicit_pronotepy_mode_strict(
-    """Test _homework_sources en mode PRONOTEPY.
+    mock_fetcher: PronoteFetcher,
+) -> None:
+    """Test _homework_sources en mode PRONOTEPY : strict, sans repli.
 
-    On vérifie que la source primaire est pronotepy et que le repli est ical si configuré,
+    On vérifie que la source primaire est pronotepy et que le repli est TOUJOURS None,
-    ou None sinon.
+    même si iCal est configuré.
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.homework_source = "pronotepy"
 
     # With ical configured
     primary, fallback = mock_fetcher._homework_sources()
     assert primary == "pronotepy"
-    assert fallback == "ical"
+    assert fallback is None
 
     # Without ical configured
     mock_fetcher._settings.pronote.ical_url = None
@@ -867,6 +1060,7 @@ def test_homework_sources_auto_only_pronotepy_configured(mock_fetcher: PronoteFe
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.homework_source = "auto"
     mock_fetcher._settings.pronote.ical_url = None
@@ -882,6 +1076,7 @@ def test_homework_sources_auto_no_source_configured_raises(mock_fetcher: Pronote
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     mock_fetcher._settings.pronote.homework_source = "auto"
     mock_fetcher._settings.pronote.ical_url = None
@@ -896,13 +1091,14 @@ def test_homework_sources_auto_no_source_configured_raises(mock_fetcher: Pronote
 def test_fetch_homework_fallback_both_fail_raises_pipeline_critical_error(
     mock_fetcher: PronoteFetcher,
 ) -> None:
-    """Test que fetch_homework lève PipelineCriticalError si ICAL échoue et pronotepy aussi.
+    """Test que fetch_homework lève PipelineCriticalError en mode explicite ical.
 
-    On mock ICAL pour échouer, on garde pronotepy configuré mais on mock son échec.
+    On mock ICAL pour échouer. On vérifie que l'erreur critique est levée
-    On vérifie que l'erreur PipelineCriticalError est levée.
+    et que pronotepy n'est PAS appelé (pas de repli en mode explicite).
 
     :param mock_fetcher: Fetcher de test.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 10)
     mock_fetcher._settings.pronote.homework_source = "ical"
@@ -922,22 +1118,27 @@ def test_fetch_homework_fallback_both_fail_raises_pipeline_critical_error(
         with pytest.raises(PipelineCriticalError) as exc_info:
             mock_fetcher.fetch_homework(target_date)
 
-        assert "les sources ical et pronotepy ont échoué" in str(exc_info.value)
+        # En mode explicite, seul l'échec de la source primaire est rapporté
+        assert "la source ical a échoué" in str(exc_info.value)
+        # Vérifie que pronotepy n'a PAS été appelé (pas de repli en mode explicite)
+        client.get_homeworks.assert_not_called()
 
 
-def test_fetch_homework_fallback_returns_empty_logs_warning(
+def test_fetch_homework_auto_fallback_returns_empty_logs_warning(
     mock_fetcher: PronoteFetcher, caplog: pytest.LogCaptureFixture
 ) -> None:
     """Test que fetch_homework retourne [] et journalise un avertissement si le repli retourne vide.
 
     On mock ICAL pour échouer, pronotepy configuré et retourne vide. On vérifie le retour et le log.
+    Ce test utilise le mode AUTO pour tester le comportement de repli.
 
     :param mock_fetcher: Fetcher de test.
     :param caplog: Fixture pytest pour capturer les logs.
     :return: None
+    :rtype: None
     """
     target_date = date(2025, 9, 10)
-    mock_fetcher._settings.pronote.homework_source = "ical"
+    mock_fetcher._settings.pronote.homework_source = "auto"
 
     with (
         patch("pronote_sync.sources.pronote.fallback.fetch_ical") as m_fetch_ical,
@@ -967,6 +1168,7 @@ def test_fetch_informations_logs_and_re_raises_secret(
     :param mock_fetcher: Fetcher de test.
     :param caplog: Fixture pytest pour capturer les logs.
     :return: None
+    :rtype: None
     """
     client = MagicMock()
     error_msg = "Erreur Pronote : impossible de récupérer les informations https://pronote.example.com/infos?token=SECRET_TOKEN_789"

tests/unit/test_theoretical_factory.py

@@ -0,0 +1,146 @@
+"""Tests unitaires pour l'usine de construction du fournisseur d'agenda théorique.
+
+Ce module contient les tests pour la fonction :func:`get_theoretical_provider`
+du module :mod:`pronote_sync.sources.theoretical`.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.sources.theoretical import (
+    TheoreticalAgendaProvider,
+    get_theoretical_provider,
+)
+
+
+class TestGetTheoreticalProvider:
+    """Tests pour la fonction get_theoretical_provider."""
+
+    @pytest.fixture
+    def fixture_path(self) -> Path:
+        """Retourne le chemin du fichier de fixture theoretical.json."""
+        return Path(__file__).parent.parent / "fixtures" / "theoretical.json"
+
+    @pytest.fixture
+    def holidays_path(self) -> Path:
+        """Retourne le chemin du fichier de fixture school_holidays.json."""
+        return Path(__file__).parent.parent / "fixtures" / "school_holidays.json"
+
+    @pytest.fixture
+    def all_only_path(self, tmp_path: Path) -> Path:
+        """Crée un fichier JSON avec uniquement des cours "all"."""
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Test",
+                }
+            ],
+        }
+        file_path = tmp_path / "all_only.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+        return file_path
+
+    def test_factory_returns_none_when_path_none(self) -> None:
+        """Teste que l'usine retourne None quand agenda_path est None.
+
+        :assert: get_theoretical_provider(None, None, None, None) retourne None.
+        """
+        result = get_theoretical_provider(None, None, None, None)
+        assert result is None
+
+    def test_factory_returns_provider_with_full_config(
+        self, fixture_path: Path, holidays_path: Path
+    ) -> None:
+        """Teste que l'usine retourne un fournisseur avec une configuration complète.
+
+        :assert: Un fournisseur est retourné avec tous les paramètres.
+        """
+        result = get_theoretical_provider(
+            agenda_path=str(fixture_path),
+            holidays_path=str(holidays_path),
+            anchor_date=date(2026, 9, 1),
+            anchor_type="even",
+        )
+        assert result is not None
+        assert isinstance(result, TheoreticalAgendaProvider)
+
+    def test_factory_partial_parity_config_error(self, fixture_path: Path) -> None:
+        """Teste qu'une configuration de parité partielle lève une PronoteSyncError.
+
+        :assert: PronoteSyncError est levée quand anchor_date est fourni sans anchor_type.
+        """
+        with pytest.raises(PronoteSyncError) as exc_info:
+            get_theoretical_provider(
+                agenda_path=str(fixture_path),
+                holidays_path=None,
+                anchor_date=date(2026, 9, 1),
+                anchor_type=None,
+            )
+        assert "incomplète" in str(exc_info.value)
+
+    def test_factory_partial_parity_config_error_type_only(self, fixture_path: Path) -> None:
+        """Teste qu'une configuration de parité partielle (type seulement) lève une PronoteSyncError.
+
+        :assert: PronoteSyncError est levée quand anchor_type est fourni sans anchor_date.
+        """
+        with pytest.raises(PronoteSyncError) as exc_info:
+            get_theoretical_provider(
+                agenda_path=str(fixture_path),
+                holidays_path=None,
+                anchor_date=None,
+                anchor_type="even",
+            )
+        assert "incomplète" in str(exc_info.value)
+
+    def test_factory_no_holidays(self, fixture_path: Path) -> None:
+        """Teste que l'usine retourne un fournisseur sans calendrier de vacances.
+
+        :assert: Un fournisseur est retourné sans calendrier de vacances.
+        """
+        result = get_theoretical_provider(
+            agenda_path=str(fixture_path),
+            holidays_path=None,
+            anchor_date=date(2026, 9, 1),
+            anchor_type="even",
+        )
+        assert result is not None
+        assert isinstance(result, TheoreticalAgendaProvider)
+
+    def test_factory_no_parity(self, all_only_path: Path) -> None:
+        """Teste que l'usine retourne un fournisseur sans service de parité pour des cours "all".
+
+        :assert: Un fournisseur est retourné sans service de parité.
+        """
+        result = get_theoretical_provider(
+            agenda_path=str(all_only_path),
+            holidays_path=None,
+            anchor_date=None,
+            anchor_type=None,
+        )
+        assert result is not None
+        assert isinstance(result, TheoreticalAgendaProvider)
+
+    def test_factory_protocol_compliance(self, fixture_path: Path, holidays_path: Path) -> None:
+        """Teste que le fournisseur retourné respecte le protocole TheoreticalAgendaProvider.
+
+        :assert: Le fournisseur satisfait isinstance(provider, TheoreticalAgendaProvider).
+        """
+        result = get_theoretical_provider(
+            agenda_path=str(fixture_path),
+            holidays_path=str(holidays_path),
+            anchor_date=date(2026, 9, 1),
+            anchor_type="even",
+        )
+        assert result is not None
+        assert isinstance(result, TheoreticalAgendaProvider)

tests/unit/test_theoretical_holidays.py

@@ -0,0 +1,188 @@
+"""Tests unitaires pour le calendrier des vacances scolaires.
+
+Ce module contient les tests pour les classes :class:`SchoolHolidayCalendar`,
+:class:`HolidayPeriod` et :class:`SchoolHolidayFile` du module
+:mod:`pronote_sync.sources.theoretical.holidays`.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.sources.theoretical.holidays import SchoolHolidayCalendar
+
+
+class TestSchoolHolidayCalendar:
+    """Tests pour la classe SchoolHolidayCalendar."""
+
+    def test_load_valid_file(self, tmp_path: Path) -> None:
+        """Teste le chargement d'un fichier JSON valide.
+
+        :assert: is_holiday retourne True pour une date dans une période.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {
+                    "start_date": "2026-10-17",
+                    "end_date": "2026-11-02",
+                    "label": "Toussaint",
+                }
+            ],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        calendar = SchoolHolidayCalendar(file_path)
+        # Date dans la période de Toussaint
+        assert calendar.is_holiday(date(2026, 10, 20)) is True
+
+    def test_date_outside_periods(self, tmp_path: Path) -> None:
+        """Teste qu'une date en dehors des périodes retourne False.
+
+        :assert: is_holiday retourne False pour une date hors période.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {
+                    "start_date": "2026-10-17",
+                    "end_date": "2026-11-02",
+                    "label": "Toussaint",
+                }
+            ],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        calendar = SchoolHolidayCalendar(file_path)
+        # Date en dehors de la période
+        assert calendar.is_holiday(date(2026, 9, 1)) is False
+
+    def test_start_date_inclusive(self, tmp_path: Path) -> None:
+        """Teste que la date de début est incluse dans la période.
+
+        :assert: is_holiday retourne True pour une date égale à start_date.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {
+                    "start_date": "2026-10-17",
+                    "end_date": "2026-11-02",
+                    "label": "Toussaint",
+                }
+            ],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        calendar = SchoolHolidayCalendar(file_path)
+        assert calendar.is_holiday(date(2026, 10, 17)) is True
+
+    def test_end_date_inclusive(self, tmp_path: Path) -> None:
+        """Teste que la date de fin est incluse dans la période.
+
+        :assert: is_holiday retourne True pour une date égale à end_date.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {
+                    "start_date": "2026-10-17",
+                    "end_date": "2026-11-02",
+                    "label": "Toussaint",
+                }
+            ],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        calendar = SchoolHolidayCalendar(file_path)
+        assert calendar.is_holiday(date(2026, 11, 2)) is True
+
+    def test_file_not_found(self, tmp_path: Path) -> None:
+        """Teste qu'un fichier introuvable lève une PronoteSyncError.
+
+        :assert: PronoteSyncError est levée pour un fichier introuvable.
+        """
+        file_path = tmp_path / "nonexistent.json"
+        with pytest.raises(PronoteSyncError) as exc_info:
+            SchoolHolidayCalendar(file_path)
+        assert "introuvable" in str(exc_info.value)
+        # Vérifier qu'aucun secret n'est fuité dans le message d'erreur
+        assert "nonexistent" not in str(exc_info.value) or "introuvable" in str(exc_info.value)
+
+    def test_invalid_json(self, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+        """Teste qu'un fichier JSON invalide lève une PronoteSyncError.
+
+        :assert: PronoteSyncError est levée pour un JSON invalide.
+        """
+        file_path = tmp_path / "invalid.json"
+        file_path.write_text("{ invalid json }", encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError) as exc_info:
+            SchoolHolidayCalendar(file_path)
+        assert "invalide" in str(exc_info.value)
+
+    def test_invalid_period_dates(self, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+        """Teste qu'une période avec end_date < start_date lève une ValidationError.
+
+        :assert: PronoteSyncError est levée pour des dates de période invalides.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {
+                    "start_date": "2026-11-02",
+                    "end_date": "2026-10-17",  # Inversé
+                    "label": "Toussaint",
+                }
+            ],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError):
+            SchoolHolidayCalendar(file_path)
+
+    def test_empty_periods(self, tmp_path: Path) -> None:
+        """Teste qu'un fichier avec des périodes vides retourne toujours False.
+
+        :assert: is_holiday retourne False pour toutes les dates.
+        """
+        holiday_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [],
+        }
+        file_path = tmp_path / "holidays.json"
+        file_path.write_text(json.dumps(holiday_data), encoding="utf-8")
+
+        calendar = SchoolHolidayCalendar(file_path)
+        assert calendar.is_holiday(date(2026, 10, 20)) is False
+        assert calendar.is_holiday(date(2026, 1, 1)) is False
+
+    def test_load_from_fixture(self) -> None:
+        """Teste le chargement du fichier de fixture et vérifie une date connue.
+
+        :assert: is_holiday retourne True pour une date de vacances connue.
+        """
+        fixture_path = Path(__file__).parent.parent / "fixtures" / "school_holidays.json"
+        calendar = SchoolHolidayCalendar(fixture_path)
+        # Date dans les vacances de Toussaint (17 oct - 2 nov 2026)
+        assert calendar.is_holiday(date(2026, 10, 20)) is True
+        # Date dans les vacances de Noël (19 déc 2026 - 4 janv 2027)
+        assert calendar.is_holiday(date(2026, 12, 25)) is True
+        # Date en dehors des vacances
+        assert calendar.is_holiday(date(2026, 9, 1)) is False

tests/unit/test_theoretical_model.py

@@ -0,0 +1,201 @@
+"""Tests unitaires pour les modèles de parsing de l'agenda théorique.
+
+Ce module contient les tests pour les classes :class:`TheoreticalLessonEntry`
+et :class:`TheoreticalAgendaFile` du module
+:mod:`pronote_sync.sources.theoretical.model`.
+"""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from pronote_sync.sources.theoretical.model import (
+    TheoreticalAgendaFile,
+    TheoreticalLessonEntry,
+)
+
+
+class TestTheoreticalLessonEntry:
+    """Tests pour la classe TheoreticalLessonEntry."""
+
+    def test_valid_lesson_entry(self) -> None:
+        """Teste la construction d'une entrée de cours valide.
+
+        :assert: Tous les champs sont correctement initialisés.
+        """
+        entry = TheoreticalLessonEntry(
+            week="all",
+            day_of_week=0,
+            start_time="08:00",
+            end_time="09:00",
+            subject="Mathématiques",
+            teachers=("Mme Martin",),
+            rooms=("101",),
+            id="math-1",
+        )
+        assert entry.week == "all"
+        assert entry.day_of_week == 0
+        assert entry.start_time == "08:00"
+        assert entry.end_time == "09:00"
+        assert entry.subject == "Mathématiques"
+        assert entry.teachers == ("Mme Martin",)
+        assert entry.rooms == ("101",)
+        assert entry.id == "math-1"
+
+    def test_invalid_time_format(self) -> None:
+        """Teste qu'une heure invalide (25:00) lève une ValidationError.
+
+        :assert: ValidationError est levée pour start_time="25:00".
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=0,
+                start_time="25:00",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "start_time" in str(exc_info.value)
+
+    def test_invalid_time_format_minutes(self) -> None:
+        """Teste qu'une minute invalide (60) lève une ValidationError.
+
+        :assert: ValidationError est levée pour start_time="08:60".
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=0,
+                start_time="08:60",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "start_time" in str(exc_info.value)
+
+    def test_end_before_start(self) -> None:
+        """Teste qu'une fin avant le début lève une ValidationError.
+
+        :assert: ValidationError est levée pour end_time < start_time.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=0,
+                start_time="10:00",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "end_time" in str(exc_info.value)
+
+    def test_end_equal_start(self) -> None:
+        """Teste qu'une fin égale au début lève une ValidationError.
+
+        :assert: ValidationError est levée pour end_time == start_time.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=0,
+                start_time="09:00",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "end_time" in str(exc_info.value)
+
+    def test_invalid_week(self) -> None:
+        """Teste qu'une semaine invalide lève une ValidationError.
+
+        :assert: ValidationError est levée pour week="weekly".
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="weekly",  # type: ignore[arg-type]
+                day_of_week=0,
+                start_time="08:00",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "week" in str(exc_info.value)
+
+    def test_invalid_day_of_week(self) -> None:
+        """Teste qu'un jour de semaine invalide (7) lève une ValidationError.
+
+        :assert: ValidationError est levée pour day_of_week=7.
+        """
+        with pytest.raises(ValidationError) as exc_info:
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=7,
+                start_time="08:00",
+                end_time="09:00",
+                subject="Test",
+            )
+        assert "day_of_week" in str(exc_info.value)
+
+    def test_optional_fields_defaults(self) -> None:
+        """Teste que les champs optionnels ont des valeurs par défaut.
+
+        :assert: teachers et rooms valent () par défaut.
+        """
+        entry = TheoreticalLessonEntry(
+            week="all",
+            day_of_week=0,
+            start_time="08:00",
+            end_time="09:00",
+            subject="Test",
+        )
+        assert entry.teachers == ()
+        assert entry.rooms == ()
+
+    def test_frozen_model(self) -> None:
+        """Teste que le modèle est immuable (frozen).
+
+        :assert: La tentative de mutation lève une exception.
+        """
+        entry = TheoreticalLessonEntry(
+            week="all",
+            day_of_week=0,
+            start_time="08:00",
+            end_time="09:00",
+            subject="Test",
+        )
+        with pytest.raises((ValidationError, AttributeError)):
+            entry.subject = "Nouveau"
+
+
+class TestTheoreticalAgendaFile:
+    """Tests pour la classe TheoreticalAgendaFile."""
+
+    def test_agenda_file_valid(self) -> None:
+        """Teste la construction d'un fichier d'agenda valide.
+
+        :assert: version == 1 et lessons a le bon nombre d'entrées.
+        """
+        lessons = [
+            TheoreticalLessonEntry(
+                week="all",
+                day_of_week=0,
+                start_time="08:00",
+                end_time="09:00",
+                subject="Mathématiques",
+            ),
+            TheoreticalLessonEntry(
+                week="even",
+                day_of_week=1,
+                start_time="10:00",
+                end_time="11:00",
+                subject="Anglais",
+            ),
+        ]
+        agenda = TheoreticalAgendaFile(version=1, lessons=tuple(lessons))
+        assert agenda.version == 1
+        assert len(agenda.lessons) == 2
+
+    def test_agenda_file_default_version(self) -> None:
+        """Teste que la version par défaut est 1.
+
+        :assert: version vaut 1 par défaut.
+        """
+        agenda = TheoreticalAgendaFile(lessons=())
+        assert agenda.version == 1

tests/unit/test_theoretical_parity.py

@@ -0,0 +1,116 @@
+"""Tests unitaires pour le service de parité des semaines.
+
+Ce module contient les tests pour la classe :class:`WeekParityService`
+du module :mod:`pronote_sync.sources.theoretical.parity`.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+
+from pronote_sync.sources.theoretical.parity import WeekParityService
+
+
+class TestWeekParityService:
+    """Tests pour la classe WeekParityService."""
+
+    def test_same_week_as_anchor_even(self) -> None:
+        """Teste qu'une date dans la même semaine que l'ancrage pair retourne "even".
+
+        :assert: parity_for retourne "even" pour une date dans la même semaine.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # Même semaine (lundi 31 août 2026)
+        target_date = date(2026, 9, 1)
+        assert service.parity_for(target_date) == "even"
+
+    def test_one_week_after_anchor_even(self) -> None:
+        """Teste qu'une date une semaine après l'ancrage pair retourne "odd".
+
+        :assert: parity_for retourne "odd" pour une date une semaine après.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # Une semaine après (mardi 8 septembre 2026)
+        target_date = date(2026, 9, 8)
+        assert service.parity_for(target_date) == "odd"
+
+    def test_two_weeks_after_anchor_even(self) -> None:
+        """Teste qu'une date deux semaines après l'ancrage pair retourne "even".
+
+        :assert: parity_for retourne "even" pour une date deux semaines après.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # Deux semaines après (mardi 15 septembre 2026)
+        target_date = date(2026, 9, 15)
+        assert service.parity_for(target_date) == "even"
+
+    def test_same_week_as_anchor_odd(self) -> None:
+        """Teste qu'une date dans la même semaine que l'ancrage impair retourne "odd".
+
+        :assert: parity_for retourne "odd" pour une date dans la même semaine.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "odd")
+        target_date = date(2026, 9, 1)
+        assert service.parity_for(target_date) == "odd"
+
+    def test_one_week_before_anchor(self) -> None:
+        """Teste qu'une date une semaine avant l'ancrage retourne la parité opposée.
+
+        :assert: parity_for retourne la parité opposée pour une date une semaine avant.
+        """
+        anchor_date = date(2026, 9, 8)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # Une semaine avant (mardi 1er septembre 2026)
+        target_date = date(2026, 9, 1)
+        assert service.parity_for(target_date) == "odd"
+
+    def test_many_weeks_later(self) -> None:
+        """Teste qu'une date 10 semaines après l'ancrage pair retourne "even".
+
+        :assert: parity_for retourne "even" pour une date 10 semaines après.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # 10 semaines après (70 jours)
+        target_date = date(2026, 11, 10)
+        assert service.parity_for(target_date) == "even"
+
+    def test_negative_offset(self) -> None:
+        """Teste qu'une date loin avant l'ancrage calcule correctement la parité.
+
+        :assert: parity_for retourne la parité correcte pour une date loin dans le passé.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # 10 semaines avant (70 jours)
+        target_date = date(2026, 6, 23)
+        assert service.parity_for(target_date) == "even"
+
+    def test_different_day_in_same_week(self) -> None:
+        """Teste que lundi et vendredi de la même semaine ont la même parité.
+
+        :assert: parity_for retourne la même parité pour lundi et vendredi de la même semaine.
+        """
+        anchor_date = date(2026, 9, 1)  # Mardi
+        service = WeekParityService(anchor_date, "even")
+        # Lundi de la même semaine
+        monday = date(2026, 8, 31)
+        # Vendredi de la même semaine
+        friday = date(2026, 9, 4)
+        assert service.parity_for(monday) == "even"
+        assert service.parity_for(friday) == "even"
+
+    def test_crosses_year_boundary(self) -> None:
+        """Teste que le calcul de parité fonctionne à cheval sur une année.
+
+        :assert: parity_for retourne la parité correcte à cheval sur une année.
+        """
+        anchor_date = date(2026, 12, 29)  # Mardi (semaine 53)
+        service = WeekParityService(anchor_date, "even")
+        # Date dans la semaine suivante (année 2027)
+        target_date = date(2027, 1, 5)  # Mardi de la semaine suivante
+        assert service.parity_for(target_date) == "odd"

tests/unit/test_theoretical_provider.py

@@ -0,0 +1,591 @@
+"""Tests unitaires pour le fournisseur d'agenda théorique basé sur fichier JSON.
+
+Ce module contient les tests pour la classe :class:`JsonTheoreticalAgendaProvider`
+du module :mod:`pronote_sync.sources.theoretical.file`.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from pronote_sync.errors import PronoteSyncError
+from pronote_sync.sources.theoretical.file import JsonTheoreticalAgendaProvider
+from pronote_sync.sources.theoretical.holidays import SchoolHolidayCalendar
+from pronote_sync.sources.theoretical.parity import WeekParityService
+
+
+class TestJsonTheoreticalAgendaProvider:
+    """Tests pour la classe JsonTheoreticalAgendaProvider."""
+
+    @pytest.fixture
+    def fixture_path(self) -> Path:
+        """Retourne le chemin du fichier de fixture theoretical.json."""
+        return Path(__file__).parent.parent / "fixtures" / "theoretical.json"
+
+    @pytest.fixture
+    def holidays_path(self) -> Path:
+        """Retourne le chemin du fichier de fixture school_holidays.json."""
+        return Path(__file__).parent.parent / "fixtures" / "school_holidays.json"
+
+    @pytest.fixture
+    def all_only_path(self, tmp_path: Path) -> Path:
+        """Crée un fichier JSON avec uniquement des cours "all"."""
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "id": "theoretical-maths-monday-1",
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Mathématiques",
+                    "teachers": ["Mme Martin"],
+                    "rooms": ["101"],
+                },
+                {
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "09:00",
+                    "end_time": "10:00",
+                    "subject": "Français",
+                    "teachers": ["M. Dupont"],
+                    "rooms": ["102"],
+                },
+                {
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "11:00",
+                    "end_time": "12:00",
+                    "subject": "Histoire-Géographie",
+                    "teachers": ["Mme Petit"],
+                    "rooms": ["103"],
+                },
+                {
+                    "week": "all",
+                    "day_of_week": 2,
+                    "start_time": "14:00",
+                    "end_time": "15:00",
+                    "subject": "Sciences",
+                    "teachers": [],
+                    "rooms": ["203"],
+                },
+                {
+                    "week": "all",
+                    "day_of_week": 4,
+                    "start_time": "09:00",
+                    "end_time": "10:00",
+                    "subject": "Arts plastiques",
+                    "teachers": [],
+                    "rooms": [],
+                },
+            ],
+        }
+        file_path = tmp_path / "all_only.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+        return file_path
+
+    @pytest.fixture
+    def provider_no_parity_no_holidays(self, all_only_path: Path) -> JsonTheoreticalAgendaProvider:
+        """Fournisseur sans service de parité ni calendrier de vacances."""
+        return JsonTheoreticalAgendaProvider(
+            file_path=str(all_only_path),
+            parity_service=None,
+            holiday_calendar=None,
+        )
+
+    @pytest.fixture
+    def provider_with_parity(self, fixture_path: Path) -> JsonTheoreticalAgendaProvider:
+        """Fournisseur avec service de parité (ancrage sur 2026-09-01, even)."""
+        parity_service = WeekParityService(date(2026, 9, 1), "even")
+        return JsonTheoreticalAgendaProvider(
+            file_path=str(fixture_path),
+            parity_service=parity_service,
+            holiday_calendar=None,
+        )
+
+    @pytest.fixture
+    def provider_with_holidays(
+        self, fixture_path: Path, holidays_path: Path
+    ) -> JsonTheoreticalAgendaProvider:
+        """Fournisseur avec calendrier de vacances."""
+        holiday_calendar = SchoolHolidayCalendar(holidays_path)
+        return JsonTheoreticalAgendaProvider(
+            file_path=str(fixture_path),
+            parity_service=None,
+            holiday_calendar=holiday_calendar,
+        )
+
+    @pytest.fixture
+    def provider_full(
+        self, fixture_path: Path, holidays_path: Path
+    ) -> JsonTheoreticalAgendaProvider:
+        """Fournisseur avec service de parité et calendrier de vacances."""
+        parity_service = WeekParityService(date(2026, 9, 1), "even")
+        holiday_calendar = SchoolHolidayCalendar(holidays_path)
+        return JsonTheoreticalAgendaProvider(
+            file_path=str(fixture_path),
+            parity_service=parity_service,
+            holiday_calendar=holiday_calendar,
+        )
+
+    def test_get_lessons_all_weeks(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste la récupération des cours pour un lundi (jour 0) sans parité.
+
+        :assert: Les cours "all" pour le lundi sont retournés.
+        """
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons = provider_no_parity_no_holidays.get_lessons(target_date)
+        # Le fichier all_only a 3 cours "all" pour le lundi (day_of_week=0)
+        assert len(lessons) == 3
+        subjects = [lesson.subject for lesson in lessons]
+        assert "Mathématiques" in subjects
+        assert "Français" in subjects
+        assert "Histoire-Géographie" in subjects
+
+    def test_get_lessons_even_week(
+        self, provider_with_parity: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste la récupération des cours pour une semaine paire.
+
+        :assert: Les cours "even" pour le mardi sont retournés.
+        """
+        # Mardi 2026-09-01 (weekday = 1), semaine paire (ancrage 2026-09-01 even)
+        # Note: 2026-09-01 est mardi (weekday=1)
+        target_date = date(2026, 9, 1)
+        lessons = provider_with_parity.get_lessons(target_date)
+        # Le fixture a 2 cours "even" pour le mardi (day_of_week=1)
+        subjects = [lesson.subject for lesson in lessons]
+        assert "Anglais" in subjects
+        assert "Technologie" in subjects
+
+    def test_get_lessons_odd_week(
+        self, provider_with_parity: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste la récupération des cours pour une semaine impaire.
+
+        :assert: Les cours "odd" pour le mardi sont retournés.
+        """
+        # Mardi 2026-09-08 (weekday = 1), semaine impaire (1 semaine après l'ancrage 2026-09-01)
+        target_date = date(2026, 9, 8)
+        lessons = provider_with_parity.get_lessons(target_date)
+        # Le fixture a 2 cours "odd" pour le mardi (day_of_week=1)
+        subjects = [lesson.subject for lesson in lessons]
+        assert "Espagnol" in subjects
+        assert "Éducation musicale" in subjects
+
+    def test_get_lessons_holiday_returns_empty(
+        self, provider_full: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste qu'une date en vacances retourne une liste vide.
+
+        :assert: get_lessons retourne [] pour une date en vacances.
+        """
+        # Date pendant les vacances de Toussaint (17 oct - 2 nov 2026)
+        target_date = date(2026, 10, 20)
+        lessons = provider_full.get_lessons(target_date)
+        assert lessons == []
+
+    def test_get_lessons_no_holiday_calendar(
+        self, provider_with_parity: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste que sans calendrier de vacances, les cours sont retournés même en vacances.
+
+        :assert: Les cours sont retournés pour une date en vacances.
+        """
+        # Date pendant les vacances de Toussaint, mais sans calendrier de vacances
+        target_date = date(2026, 10, 20)  # Mardi (weekday = 1)
+        lessons = provider_with_parity.get_lessons(target_date)
+        # Sans calendrier de vacances, les cours "even" pour le mardi sont retournés
+        assert len(lessons) == 2
+
+    def test_get_lessons_sorted_by_id(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste que les cours sont triés par identifiant.
+
+        :assert: Les cours sont triés par id.
+        """
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons = provider_no_parity_no_holidays.get_lessons(target_date)
+        ids = [lesson.id for lesson in lessons]
+        assert ids == sorted(ids)
+
+    def test_get_lessons_deterministic(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste que get_lessons retourne des résultats identiques pour la même date.
+
+        :assert: Deux appels avec la même date retournent des résultats identiques.
+        """
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons1 = provider_no_parity_no_holidays.get_lessons(target_date)
+        lessons2 = provider_no_parity_no_holidays.get_lessons(target_date)
+        assert lessons1 == lessons2
+
+    def test_even_odd_same_slot_different_ids(
+        self, provider_with_parity: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste que les cours even/odd sur le même créneau ont des IDs différents.
+
+        :assert: Les IDs des cours even et odd sont différents.
+        """
+        # Mardi 2026-09-01 (semaine paire, même semaine que l'ancrage)
+        even_lessons = provider_with_parity.get_lessons(date(2026, 9, 1))
+        # Mardi 2026-09-08 (semaine impaire, 1 semaine après l'ancrage)
+        odd_lessons = provider_with_parity.get_lessons(date(2026, 9, 8))
+
+        # Les deux semaines ont des cours sur le même créneau (10:00-11:00)
+        # mais avec des matières différentes (Anglais/Technologie vs Espagnol/Éducation musicale)
+        even_subjects = {lesson.subject for lesson in even_lessons}
+        odd_subjects = {lesson.subject for lesson in odd_lessons}
+
+        # Les matières doivent être différentes
+        assert "Anglais" in even_subjects
+        assert "Espagnol" in odd_subjects
+        # Les IDs ne doivent pas être identiques
+        even_ids = {lesson.id for lesson in even_lessons}
+        odd_ids = {lesson.id for lesson in odd_lessons}
+        assert even_ids.isdisjoint(odd_ids)
+
+    def test_explicit_id_preserved(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste qu'un ID explicite est préservé.
+
+        :assert: L'ID explicite "theoretical-maths-monday-1" est utilisé.
+        """
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons = provider_no_parity_no_holidays.get_lessons(target_date)
+        ids = [lesson.id for lesson in lessons]
+        assert "theoretical-maths-monday-1" in ids
+
+    def test_generated_id_includes_week(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste qu'un ID généré inclut le type de semaine.
+
+        :assert: L'ID généré contient le type de semaine.
+        """
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons = provider_no_parity_no_holidays.get_lessons(target_date)
+        # Trouver un cours sans ID explicite (Français ou Histoire-Géographie)
+        for lesson in lessons:
+            if lesson.subject in ("Français", "Histoire-Géographie"):
+                assert "all" in lesson.id
+                break
+
+    def test_no_parity_service_with_all_only_lessons(self, all_only_path: Path) -> None:
+        """Teste qu'un fournisseur sans service de parité fonctionne avec des cours "all".
+
+        :assert: Les cours "all" sont retournés correctement.
+        """
+        provider = JsonTheoreticalAgendaProvider(
+            file_path=str(all_only_path),
+            parity_service=None,
+            holiday_calendar=None,
+        )
+        # Lundi 2026-08-31 (weekday = 0)
+        target_date = date(2026, 8, 31)
+        lessons = provider.get_lessons(target_date)
+        assert len(lessons) == 3
+
+    def test_even_lessons_without_parity_service_error(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Teste qu'un fichier avec des cours even/odd sans service de parité lève une erreur.
+
+        :assert: PronoteSyncError est levée.
+        """
+        # Créer un fichier JSON avec uniquement des cours even/odd
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "week": "even",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Test",
+                }
+            ],
+        }
+        file_path = tmp_path / "even_only.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError) as exc_info:
+            JsonTheoreticalAgendaProvider(
+                file_path=str(file_path),
+                parity_service=None,
+                holiday_calendar=None,
+            )
+        assert "ancre de parité" in str(exc_info.value)
+
+    def test_invalid_json_file(self, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+        """Teste qu'un fichier JSON invalide lève une PronoteSyncError.
+
+        :assert: PronoteSyncError est levée pour un JSON invalide.
+        """
+        file_path = tmp_path / "invalid.json"
+        file_path.write_text("{ invalid json }", encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError) as exc_info:
+            JsonTheoreticalAgendaProvider(
+                file_path=str(file_path),
+                parity_service=None,
+                holiday_calendar=None,
+            )
+        assert "invalide" in str(exc_info.value)
+
+    def test_get_lessons_for_range(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste la récupération des cours pour une plage de 5 jours.
+
+        :assert: Tous les cours uniques sont retournés, triés par ID.
+        """
+        # Lundi 2026-08-31 à Vendredi 2026-09-04
+        start_date = date(2026, 8, 31)  # Lundi
+        end_date = date(2026, 9, 4)  # Vendredi
+        lessons = provider_no_parity_no_holidays.get_lessons_for_range(start_date, end_date)
+
+        # Le fichier all_only a des cours pour lundi (3), mercredi (1), vendredi (1)
+        # Total: 3 + 1 + 1 = 5 cours uniques
+        assert len(lessons) == 5
+        ids = [lesson.id for lesson in lessons]
+        assert ids == sorted(ids)
+
+    def test_get_lessons_for_range_with_holidays(
+        self, provider_full: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste la récupération des cours pour une plage incluant des jours de vacances.
+
+        :assert: Les jours de vacances ne contribuent pas de cours.
+        """
+        # Plage incluant des vacances de Toussaint (17 oct - 2 nov 2026)
+        # Le 15 oct 2026 est un mercredi (day_of_week=2), le fixture a un cours "all" pour mercredi
+        # Le 16 oct 2026 est un jeudi (day_of_week=3), pas de cours dans le fixture
+        # Le 17 oct 2026 est un vendredi (day_of_week=4), le fixture a un cours "all" pour vendredi
+        # Mais le 17 oct est le début des vacances, donc pas de cours
+        start_date = date(2026, 10, 15)  # Mercredi (avant vacances)
+        end_date = date(2026, 10, 16)  # Jeudi (avant vacances)
+        lessons = provider_full.get_lessons_for_range(start_date, end_date)
+
+        # Le 15 oct (mercredi) devrait avoir un cours "all" pour Sciences
+        # Le 16 oct (jeudi) n'a pas de cours dans le fixture
+        # Donc on devrait avoir au moins 1 cours
+        assert len(lessons) >= 1
+
+    def test_get_lessons_for_range_empty(
+        self, provider_full: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste qu'une plage où tous les jours sont en vacances retourne une liste vide.
+
+        :assert: get_lessons_for_range retourne [] pour une plage entièrement en vacances.
+        """
+        # Plage entièrement pendant les vacances de Toussaint
+        start_date = date(2026, 10, 17)
+        end_date = date(2026, 10, 24)
+        lessons = provider_full.get_lessons_for_range(start_date, end_date)
+        assert lessons == []
+
+    def test_get_lessons_sunday(
+        self, provider_no_parity_no_holidays: JsonTheoreticalAgendaProvider
+    ) -> None:
+        """Teste qu'un dimanche retourne une liste vide.
+
+        :assert: get_lessons retourne [] pour un dimanche.
+        """
+        # Dimanche 2026-09-06 (weekday = 6)
+        target_date = date(2026, 9, 6)
+        lessons = provider_no_parity_no_holidays.get_lessons(target_date)
+        # Aucun cours n'est prévu pour le dimanche dans le fichier all_only
+        assert lessons == []
+
+    def test_get_lessons_for_range_dedup_across_weeks(self, tmp_path: Path) -> None:
+        """Vérifie que get_lessons_for_range déduplique les leçons récurrentes.
+
+        :assert: Une leçon récurrente sur plusieurs semaines n'apparaît qu'une fois.
+        """
+        # Créer un fichier JSON avec une seule leçon "all" le lundi 08:00-09:00 "Maths"
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "week": "all",
+                    "day_of_week": 0,  # Lundi
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Maths",
+                    "teachers": [],
+                    "rooms": [],
+                }
+            ],
+        }
+        file_path = tmp_path / "dedup_test.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+
+        provider = JsonTheoreticalAgendaProvider(
+            file_path=str(file_path),
+            parity_service=None,
+            holiday_calendar=None,
+        )
+
+        # Plage du 31 août 2026 (lundi) au 11 septembre 2026 (vendredi)
+        # Cela couvre 2 lundis (31 août et 7 septembre)
+        start_date = date(2026, 8, 31)
+        end_date = date(2026, 9, 11)
+        lessons = provider.get_lessons_for_range(start_date, end_date)
+
+        # La leçon récurrente devrait apparaître une seule fois
+        assert len(lessons) == 1
+        assert lessons[0].subject == "Maths"
+
+    def test_duplicate_explicit_ids_rejected(self, tmp_path: Path) -> None:
+        """Vérifie que les IDs explicites dupliqués sont rejetés.
+
+        :assert: PronoteSyncError est levée pour des IDs explicites dupliqués.
+        """
+        # Créer un fichier JSON avec 2 leçons ayant le même ID explicite
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "id": "dup-id",
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Maths",
+                    "teachers": [],
+                    "rooms": [],
+                },
+                {
+                    "id": "dup-id",
+                    "week": "all",
+                    "day_of_week": 1,
+                    "start_time": "09:00",
+                    "end_time": "10:00",
+                    "subject": "Français",
+                    "teachers": [],
+                    "rooms": [],
+                },
+            ],
+        }
+        file_path = tmp_path / "duplicate_ids.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError) as exc_info:
+            JsonTheoreticalAgendaProvider(
+                file_path=str(file_path),
+                parity_service=None,
+                holiday_calendar=None,
+            )
+        assert "Conflit d'identifiant" in str(exc_info.value) or "identifiant" in str(
+            exc_info.value
+        )
+
+    def test_generated_id_collision_rejected(self, tmp_path: Path) -> None:
+        """Vérifie que les collisions d'IDs générés sont détectées.
+
+        :assert: PronoteSyncError est levée pour des IDs générés identiques.
+        """
+        # Créer un fichier JSON avec 2 leçons qui produisent le même ID généré
+        # Même week, day_of_week, start_time, end_time, subject mais enseignants différents
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Maths",
+                    "teachers": ["Prof1"],
+                    "rooms": [],
+                },
+                {
+                    "week": "all",
+                    "day_of_week": 0,
+                    "start_time": "08:00",
+                    "end_time": "09:00",
+                    "subject": "Maths",
+                    "teachers": ["Prof2"],
+                    "rooms": [],
+                },
+            ],
+        }
+        file_path = tmp_path / "generated_id_collision.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+
+        with pytest.raises(PronoteSyncError) as exc_info:
+            JsonTheoreticalAgendaProvider(
+                file_path=str(file_path),
+                parity_service=None,
+                holiday_calendar=None,
+            )
+        assert "Conflit d'identifiant" in str(exc_info.value) or "identifiant" in str(
+            exc_info.value
+        )
+
+    def test_get_lessons_for_range_mixed_holidays_and_normal(self, tmp_path: Path) -> None:
+        """Vérifie qu'une plage mixte (jours normaux et vacances) retourne les leçons des jours non vacanciers.
+
+        :assert: Les leçons des jours non vacanciers sont retournées, les jours de vacances sont ignorés.
+        """
+        # Créer un fichier JSON avec une leçon "all" le jeudi 14:00-15:00 "Sciences"
+        # Note: 2026-10-15 est un jeudi (weekday=3)
+        data = {
+            "version": 1,
+            "lessons": [
+                {
+                    "week": "all",
+                    "day_of_week": 3,  # Jeudi
+                    "start_time": "14:00",
+                    "end_time": "15:00",
+                    "subject": "Sciences",
+                    "teachers": [],
+                    "rooms": [],
+                }
+            ],
+        }
+        file_path = tmp_path / "mixed_holidays.json"
+        file_path.write_text(json.dumps(data), encoding="utf-8")
+
+        # Créer un fichier de vacances avec une période du 16 au 20 octobre 2026
+        holidays_data = {
+            "zone": "A",
+            "school_year": "2026-2027",
+            "periods": [
+                {"start_date": "2026-10-16", "end_date": "2026-10-20", "label": "Test Vacances"}
+            ],
+        }
+        holidays_path = tmp_path / "test_holidays.json"
+        holidays_path.write_text(json.dumps(holidays_data), encoding="utf-8")
+
+        holiday_calendar = SchoolHolidayCalendar(holidays_path)
+        provider = JsonTheoreticalAgendaProvider(
+            file_path=str(file_path),
+            parity_service=None,
+            holiday_calendar=holiday_calendar,
+        )
+
+        # Plage du 15 octobre (jeudi, pas en vacances) au 17 octobre (samedi, en vacances)
+        start_date = date(2026, 10, 15)  # Jeudi
+        end_date = date(2026, 10, 17)  # Samedi
+        lessons = provider.get_lessons_for_range(start_date, end_date)
+
+        # Seule la leçon du 15 octobre (jeudi) devrait être retournée
+        assert len(lessons) == 1
+        assert lessons[0].subject == "Sciences"