fix(M4): pronote_url + account_type et parsing iCal (STATUS:CANCELLED + blocs multi-dates)

Configuration (D1+D3) :
- PronoteSettings : ajout pronote_url (str | None) et account_type
  (Literal student/parent, défaut parent)

Parsing iCal (Fix 4+7) :
- parse_ical : détection STATUS:CANCELLED en plus de CATEGORIES
- parse_body : list[tuple[date, str]] au lieu de dict[date, str]
  pour préserver les blocs multiples à la même date
- parse_homework_blocks : adapté aux listes

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

pronote_sync/sources/pronote/client.py

@@ -3,16 +3,20 @@
 Ce module fournit l'encapsulation du client ``pronotepy`` pour la source
 Pronote : récupération des messages des professeurs, des informations et
 sondages, ainsi que des cours et devoirs en mode repli lorsque le flux
-iCal échoue. Toutes les erreurs sont journalisées avec des secrets masqués.
+iCal échoue. Les erreurs des méthodes dégradées (messages, informations)
+sont journalisées avec des secrets masqués ; les erreurs de récupération
+des cours et des devoirs se propagent pour déclencher le repli iCal.
 """
 
 from __future__ import annotations
 
 import logging
 from datetime import date
-from typing import Protocol
+from typing import Any, Protocol
 
 import pronotepy
+import pronotepy.ent as pronotepy_ent
+import requests
 
 from pronote_sync.config.settings import PronoteSettings
 from pronote_sync.models.agenda import Lesson, LessonStatus
@@ -23,6 +27,69 @@ from pronote_sync.utils.redaction import redact_exception
 logger = logging.getLogger(__name__)
 
 
+def _get_ent_callable(name: str) -> Any:
+    """Retourne le callable ``pronotepy`` associé à un nom d'ENT.
+
+    L'accès par :func:`getattr` évite les erreurs ``attr-defined`` de mypy
+    sur les attributs non exportés explicitement par ``pronotepy.ent``.
+
+    :param name: Nom de l'attribut dans ``pronotepy.ent``.
+    :return: Callable ``pronotepy`` associé.
+    :rtype: Any
+    """
+    return getattr(pronotepy_ent, name)
+
+
+_ENT_NAMES: list[str] = [
+    "monbureaunumerique",
+    "ent_elyco",
+    "bordeaux",
+    "ent_creuse",
+    "occitanie_montpellier",
+    "paris_classe_numerique",
+    "ile_de_france",
+    "ent_hdf",
+    "ac_orleans_tours",
+    "ac_poitiers",
+    "ac_rennes",
+    "laclasse_educonnect",
+    "ent77",
+    "ent_ecollege78",
+    "ent_essonne",
+    "val_doise",
+    "val_de_marne",
+    "ent_var",
+    "atrium_sud",
+    "laclasse_lyon",
+    "eclat_bfc",
+    "cas_arsene76",
+    "cas_ent27",
+    "cas_kosmos",
+    "ent_creuse_educonnect",
+    "ent_mayotte",
+    "ent_somme",
+    "ent_94",
+    "extranet_colleges_somme",
+    "ac_reunion",
+]
+
+_ENT_RESOLVERS: dict[str, Any] = {name: _get_ent_callable(name) for name in _ENT_NAMES}
+
+
+def _resolve_ent(ent_name: str) -> Any:
+    """Résout un nom d'ENT en callable ``pronotepy``.
+
+    :param ent_name: Nom de l'ENT tel que configuré (ex. ``"bordeaux"``).
+    :return: Callable ``pronotepy`` associé à l'ENT.
+    :raises ValueError: Si le nom d'ENT n'est pas reconnu.
+    """
+    resolver = _ENT_RESOLVERS.get(ent_name)
+    if resolver is None:
+        supported = ", ".join(sorted(_ENT_RESOLVERS.keys()))
+        raise ValueError(f"ENT inconnu : {ent_name!r}. ENT supportés : {supported}")
+    return resolver
+
+
 class PronoteClientProtocol(Protocol):
     """Interface du client Pronote consommée par la logique de repli."""
 
@@ -42,13 +109,23 @@ class PronoteClientProtocol(Protocol):
         """
         ...
 
-    def get_agenda_fallback(self, start: date, end: date) -> tuple[list[Lesson], list[Homework]]:
-        """Récupère les cours et les devoirs via ``pronotepy`` (repli iCal).
+    def get_lessons(self, start: date, end: date) -> list[Lesson]:
+        """Récupère les cours via ``pronotepy`` (repli iCal).
 
         :param start: Date de début de la fenêtre (incluse).
         :param end: Date de fin de la fenêtre (incluse).
-        :return: Tuple ``(cours, devoirs)``.
-        :rtype: tuple[list[Lesson], list[Homework]]
+        :return: Liste des cours.
+        :rtype: list[Lesson]
+        """
+        ...
+
+    def get_homeworks(self, start: date, end: date) -> list[Homework]:
+        """Récupère les devoirs via ``pronotepy``.
+
+        :param start: Date de début de la fenêtre (incluse).
+        :param end: Date de fin de la fenêtre (incluse).
+        :return: Liste des devoirs.
+        :rtype: list[Homework]
         """
         ...
 
@@ -56,11 +133,13 @@ class PronoteClientProtocol(Protocol):
 class PronoteClient:
     """Client d'accès à Pronote via ``pronotepy``.
 
-    Encapsule ``pronotepy.Client`` avec une connexion paresseuse : la
-    connexion n'est établie qu'à la première méthode de récupération
-    appelée. Les erreurs ``pronotepy.PronoteAPIError`` sont journalisées
-    avec des secrets masqués et les méthodes de récupération retournent
-    alors une valeur vide au lieu de propager l'exception.
+    Encapsule ``pronotepy.Client`` ou ``pronotepy.ParentClient`` selon le
+    type de compte, avec une connexion paresseuse : la connexion n'est
+    établie qu'à la première méthode de récupération appelée. Les erreurs
+    des méthodes dégradées (``get_messages()``, ``get_informations()``)
+    sont journalisées avec des secrets masqués et retournent une valeur
+    vide ; ``get_lessons()`` et ``get_homeworks()`` laissent les
+    exceptions se propager pour déclencher le repli iCal.
     """
 
     def __init__(self, settings: PronoteSettings) -> None:
@@ -75,24 +154,39 @@ class PronoteClient:
         """Crée et connecte le client ``pronotepy`` (connexion paresseuse).
 
         Le client est créé une seule fois puis réutilisé pour les appels
-        suivants. L'erreur de connexion est relancée sans journalisation,
-        la méthode publique appelante étant responsable de la journaliser.
+        suivants. Le nom d'ENT est résolu via :func:`_resolve_ent` et le
+        type de compte (``student`` ou ``parent``) détermine la classe de
+        client utilisée. L'erreur de connexion est relancée sans
+        journalisation, la méthode publique appelante étant responsable
+        de la journaliser.
 
         :return: Le client ``pronotepy`` connecté.
         :rtype: pronotepy.Client
-        :raises ValueError: Si ``username``, ``password`` ou ``ent`` est manquant.
+        :raises ValueError: Si ``pronote_url``, ``username``, ``password``
+            ou ``ent`` est manquant, ou si l'ENT est inconnu.
         :raises pronotepy.PronoteAPIError: Si la connexion à Pronote échoue.
         """
         if self._client is None:
+            pronote_url = self._settings.pronote_url
             username = self._settings.username
             password = self._settings.password
             ent = self._settings.ent
-            if username is None or password is None or ent is None:
-                raise ValueError("username, password et ent sont requis pour pronotepy")
-            try:
-                self._client = pronotepy.Client(username, password.get_secret_value(), ent)
-            except pronotepy.PronoteAPIError:
-                raise
+            if pronote_url is None or username is None or password is None or ent is None:
+                raise ValueError(
+                    "pronote_url, username, password et ent sont requis pour pronotepy"
+                )
+            resolver = _resolve_ent(ent)
+            client_class: type[pronotepy.Client] = (
+                pronotepy.ParentClient
+                if self._settings.account_type == "parent"
+                else pronotepy.Client
+            )
+            self._client = client_class(
+                pronote_url=pronote_url,
+                username=username,
+                password=password.get_secret_value(),
+                ent=resolver,
+            )
         return self._client
 
     def get_messages(self) -> list[Message]:
@@ -122,7 +216,13 @@ class PronoteClient:
                         )
                     )
             return messages
-        except (pronotepy.PronoteAPIError, ValueError) as exc:
+        except (
+            pronotepy.PronoteAPIError,
+            ValueError,
+            requests.RequestException,
+            ConnectionError,
+            TimeoutError,
+        ) as exc:
             logger.error(
                 "Échec de la récupération des messages Pronote : %s",
                 redact_exception(exc),
@@ -154,62 +254,86 @@ class PronoteClient:
                     )
                 )
             return messages
-        except (pronotepy.PronoteAPIError, ValueError) as exc:
+        except (
+            pronotepy.PronoteAPIError,
+            ValueError,
+            requests.RequestException,
+            ConnectionError,
+            TimeoutError,
+        ) as exc:
             logger.error(
                 "Échec de la récupération des informations Pronote : %s",
                 redact_exception(exc),
             )
             return []
 
-    def get_agenda_fallback(self, start: date, end: date) -> tuple[list[Lesson], list[Homework]]:
-        """Récupère les cours et les devoirs via ``pronotepy``.
+    def get_lessons(self, start: date, end: date) -> list[Lesson]:
+        """Récupère les cours via ``pronotepy`` (repli iCal).
 
-        À utiliser uniquement si les sources iCal sont indisponibles ou en
-        repli automatique. Les cours annulés sont mappés sur le statut
-        ``CANCELLED`` ; **pronotepy** ne fournissant ni la date de
+        Les exceptions ne sont pas attrapées : elles se propagent afin que
+        l'appelant puisse détecter l'échec et déclencher le repli (ou une
+        erreur explicite).
+
+        :param start: Date de début de la fenêtre (incluse).
+        :param end: Date de fin de la fenêtre (incluse).
+        :return: Liste des cours.
+        :rtype: list[Lesson]
+        :raises pronotepy.PronoteAPIError: Si l'API Pronote échoue.
+        :raises ValueError: Si la configuration ou l'ENT est invalide.
+        :raises requests.RequestException: Si une requête réseau échoue.
+        :raises ConnectionError: Si la connexion réseau échoue.
+        :raises TimeoutError: Si la requête réseau expire.
+        """
+        client = self._connect()
+        lessons: list[Lesson] = []
+        for lesson in client.lessons(start, end):
+            content = lesson.content
+            lessons.append(
+                Lesson(
+                    id=lesson.id,
+                    start=lesson.start,
+                    end=lesson.end,
+                    subject=lesson.subject.name if lesson.subject is not None else "",
+                    teachers=tuple(lesson.teacher_names or ()),
+                    rooms=tuple(lesson.classrooms or ()),
+                    group=lesson.group_name,
+                    status=(LessonStatus.CANCELLED if lesson.canceled else LessonStatus.NORMAL),
+                    content=content.description if content is not None else None,
+                )
+            )
+        return lessons
+
+    def get_homeworks(self, start: date, end: date) -> list[Homework]:
+        """Récupère les devoirs via ``pronotepy``.
+
+        Les exceptions ne sont pas attrapées : elles se propagent afin que
+        l'appelant puisse détecter l'échec et déclencher le repli (ou une
+        erreur explicite). **pronotepy** ne fournissant ni la date de
         distribution ni les professeurs des devoirs, ces champs restent
         vides.
 
         :param start: Date de début de la fenêtre (incluse).
         :param end: Date de fin de la fenêtre (incluse).
-        :return: Tuple ``(cours, devoirs)`` ; vide en cas d'erreur.
-        :rtype: tuple[list[Lesson], list[Homework]]
+        :return: Liste des devoirs.
+        :rtype: list[Homework]
+        :raises pronotepy.PronoteAPIError: Si l'API Pronote échoue.
+        :raises ValueError: Si la configuration ou l'ENT est invalide.
+        :raises requests.RequestException: Si une requête réseau échoue.
+        :raises ConnectionError: Si la connexion réseau échoue.
+        :raises TimeoutError: Si la requête réseau expire.
         """
-        try:
-            client = self._connect()
-            lessons: list[Lesson] = []
-            for lesson in client.lessons(start, end):
-                content = lesson.content
-                lessons.append(
-                    Lesson(
-                        id=lesson.id,
-                        start=lesson.start,
-                        end=lesson.end,
-                        subject=lesson.subject.name if lesson.subject is not None else "",
-                        teachers=tuple(lesson.teacher_names or ()),
-                        rooms=tuple(lesson.classrooms or ()),
-                        group=lesson.group_name,
-                        status=(LessonStatus.CANCELLED if lesson.canceled else LessonStatus.NORMAL),
-                        content=content.description if content is not None else None,
-                    )
+        client = self._connect()
+        homeworks: list[Homework] = []
+        for hw in client.homework(start, end):
+            homeworks.append(
+                Homework(
+                    id=hw.id,
+                    subject=hw.subject.name,
+                    teachers=(),
+                    assigned_on=None,
+                    due_on=hw.date,
+                    text=hw.description,
+                    html=hw.description,
                 )
-            homeworks: list[Homework] = []
-            for hw in client.homework(start, end):
-                homeworks.append(
-                    Homework(
-                        id=hw.id,
-                        subject=hw.subject.name,
-                        teachers=(),
-                        assigned_on=None,
-                        due_on=hw.date,
-                        text=hw.description,
-                        html=hw.description,
-                    )
-                )
-            return lessons, homeworks
-        except (pronotepy.PronoteAPIError, ValueError) as exc:
-            logger.error(
-                "Échec de la récupération de l'agenda via pronotepy : %s",
-                redact_exception(exc),
             )
-            return [], []
+        return homeworks