fix(security): neutraliser le contexte des erreurs expurgées

pronote_sync/sources/pronote/auth_state.py

@@ -218,6 +218,7 @@ class PronoteAuthState:
         }
         tmp_file = self._state_file.with_suffix(".tmp")
         fd: int | None = None
+        write_error: PronoteSyncError | None = None
         try:
             # Nettoie un éventuel fichier temporaire stale laissé par une exécution interrompue.
             if tmp_file.exists():
@@ -259,10 +260,12 @@ class PronoteAuthState:
                     "Nettoyage du fichier temporaire d'état d'authentification Pronote échoué : %s",
                     redact_exception(cleanup_exc),
                 )
-            raise PronoteSyncError(
+            write_error = PronoteSyncError(
                 f"Impossible d'écrire le fichier d'état d'authentification Pronote "
                 f"{redact_secrets(str(self._state_file))}."
-            ) from None
+            )
+        if write_error is not None:
+            raise write_error from None
 
     def clear(self) -> None:
         """Supprime le fichier d'état d'authentification.

pronote_sync/sources/pronote/fallback.py

@@ -269,34 +269,36 @@ class PronoteFetcher:
                 primary,
                 redact_exception(exc),
             )
-            if fallback is None:
-                raise PipelineCriticalError(
-                    f"Impossible de récupérer l'agenda : la source {primary} a échoué"
-                ) from None
-            logger.info("Repli sur %s pour l'agenda.", fallback)
-            try:
-                lessons, school_events = self._fetch_agenda_source(fallback)
-            except PronoteAuthRotationError:
-                raise
-            except Exception as exc:
-                logger.error(
-                    "Échec de la récupération %s pour l'agenda : %s",
-                    fallback,
-                    redact_exception(exc),
-                )
-                raise PipelineCriticalError(
-                    f"Impossible de récupérer l'agenda : les sources {primary}"
-                    f" et {fallback} ont échoué"
-                ) from None
-            if not lessons:
-                logger.warning(
-                    "Le repli %s pour l'agenda a retourné un résultat vide après l'échec "
-                    "de %s : impossible de distinguer une absence de cours d'un échec "
-                    "silencieux.",
-                    fallback,
-                    primary,
-                )
-            return lessons, school_events
+        if fallback is None:
+            raise PipelineCriticalError(
+                f"Impossible de récupérer l'agenda : la source {primary} a échoué"
+            ) from None
+        logger.info("Repli sur %s pour l'agenda.", fallback)
+        fallback_result: tuple[list[Lesson], list[SchoolEvent]] | None = None
+        try:
+            fallback_result = self._fetch_agenda_source(fallback)
+        except PronoteAuthRotationError:
+            raise
+        except Exception as exc:
+            logger.error(
+                "Échec de la récupération %s pour l'agenda : %s",
+                fallback,
+                redact_exception(exc),
+            )
+        if fallback_result is None:
+            raise PipelineCriticalError(
+                f"Impossible de récupérer l'agenda : les sources {primary} et {fallback} ont échoué"
+            ) from None
+        lessons, school_events = fallback_result
+        if not lessons:
+            logger.warning(
+                "Le repli %s pour l'agenda a retourné un résultat vide après l'échec "
+                "de %s : impossible de distinguer une absence de cours d'un échec "
+                "silencieux.",
+                fallback,
+                primary,
+            )
+        return lessons, school_events
 
     def _fetch_homework_ical(self, target_date: date) -> list[Homework]:
         """Récupère les devoirs depuis le flux iCal pour la date cible.
@@ -396,34 +398,37 @@ class PronoteFetcher:
                 primary,
                 redact_exception(exc),
             )
-            if fallback is None:
-                raise PipelineCriticalError(
-                    f"Impossible de récupérer les devoirs : la source {primary} a échoué"
-                ) from None
-            logger.info("Repli sur %s pour les devoirs.", fallback)
-            try:
-                homeworks = self._fetch_homework_source(fallback, target_date)
-            except PronoteAuthRotationError:
-                raise
-            except Exception as exc:
-                logger.error(
-                    "Échec de la récupération %s pour les devoirs : %s",
-                    fallback,
-                    redact_exception(exc),
-                )
-                raise PipelineCriticalError(
-                    f"Impossible de récupérer les devoirs : les sources {primary}"
-                    f" et {fallback} ont échoué"
-                ) from None
-            if not homeworks:
-                logger.warning(
-                    "Le repli %s pour les devoirs a retourné un résultat vide après "
-                    "l'échec de %s : impossible de distinguer une absence de devoirs "
-                    "d'un échec silencieux.",
-                    fallback,
-                    primary,
-                )
-            return homeworks
+        if fallback is None:
+            raise PipelineCriticalError(
+                f"Impossible de récupérer les devoirs : la source {primary} a échoué"
+            ) from None
+        logger.info("Repli sur %s pour les devoirs.", fallback)
+        fallback_result: list[Homework] | None = None
+        try:
+            fallback_result = self._fetch_homework_source(fallback, target_date)
+        except PronoteAuthRotationError:
+            raise
+        except Exception as exc:
+            logger.error(
+                "Échec de la récupération %s pour les devoirs : %s",
+                fallback,
+                redact_exception(exc),
+            )
+        if fallback_result is None:
+            raise PipelineCriticalError(
+                f"Impossible de récupérer les devoirs : les sources {primary}"
+                f" et {fallback} ont échoué"
+            ) from None
+        homeworks = fallback_result
+        if not homeworks:
+            logger.warning(
+                "Le repli %s pour les devoirs a retourné un résultat vide après "
+                "l'échec de %s : impossible de distinguer une absence de devoirs "
+                "d'un échec silencieux.",
+                fallback,
+                primary,
+            )
+        return homeworks
 
     def fetch_messages(self) -> list[Message]:
         """Récupère les messages des discussions Pronote (toujours via pronotepy).

pronote_sync/sources/theoretical/file.py

@@ -85,6 +85,7 @@ class JsonTheoreticalAgendaProvider:
         self._file_path: str = file_path
         self._parity_service: WeekParityService | None = parity_service
         self._holiday_calendar: SchoolHolidayCalendar | None = holiday_calendar
+        load_error: PronoteSyncError | None = None
         try:
             content = Path(file_path).read_text(encoding="utf-8")
             parsed = TheoreticalAgendaFile.model_validate_json(content)
@@ -94,9 +95,11 @@ class JsonTheoreticalAgendaProvider:
                 redact_secrets(str(file_path)),
                 redact_exception(exc),
             )
-            raise PronoteSyncError(
+            load_error = PronoteSyncError(
                 f"Le fichier d'agenda théorique est invalide : {redact_secrets(str(file_path))}"
-            ) from None
+            )
+        if load_error is not None:
+            raise load_error 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

pronote_sync/sources/theoretical/holidays.py

@@ -77,6 +77,7 @@ class SchoolHolidayCalendar:
             raise PronoteSyncError(
                 f"Le fichier de vacances scolaires est introuvable : {redact_secrets(str(path))}"
             ) from None
+        load_error: PronoteSyncError | None = None
         try:
             data: Any = json.loads(path.read_text(encoding="utf-8"))
             file_model: SchoolHolidayFile = SchoolHolidayFile.model_validate(data)
@@ -86,9 +87,11 @@ class SchoolHolidayCalendar:
                 redact_secrets(str(path)),
                 redact_exception(exc),
             )
-            raise PronoteSyncError(
+            load_error = PronoteSyncError(
                 f"Le fichier de vacances scolaires est invalide : {redact_secrets(str(path))}"
-            ) from None
+            )
+        if load_error is not None:
+            raise load_error from None
         self._periods = file_model.periods
 
     def is_holiday(self, target_date: date) -> bool: