feat: authentification QR code / token pour Pronote
Ajoute le mode d'authentification PRONOTE_AUTH_MODE=qr_token comme alternative au mode password pour les instances Pronote utilisant HubEduConnect/EduConnect où l'authentification par mot de passe échoue (CAPTCHA, MFA, flux SAML). Nouveaux éléments : - PronoteSettings : auth_mode, qr_code_file, qr_pin (SecretStr) - PronoteAuthState : persistance du token rotatif dans .pronote_auth_state.json (écriture atomique, permissions 0600, symlink-safe via O_EXCL|O_NOFOLLOW) - PronoteClient._connect_qr_token() : token_login avec creds persistés, qrcode_login pour l'enrôlement initial, export_credentials persisté après chaque login réussi - PronoteAuthRotationError : levée en cas d'échec de rotation du token, propagée sans wrapping à travers PronoteFetcher et fetch_step jusqu'à PipelineRunner.run() qui notifie via XMPP (si canal disponible et dry_run inactif) - _is_pronotepy_configured() mode-aware : qr_token ne requiert que PRONOTE_URL - _collect_auth_secrets() : redaction des secrets explicites (token, PIN, jeton QR) dans tous les logs du chemin d'authentification Documentation : - .env.example : PRONOTE_AUTH_MODE, PRONOTE_QR_CODE_FILE, PRONOTE_QR_PIN - AGENTS.md : contrat d'authentification QR code / token - Wiki GuidePronote : section enrôlement, exécutions suivantes, ré-enrôlement Tests (686 passés, couverture 94.87%) : - 5 tests config QR, 9 tests auth_state, 10 tests client QR, 3 tests propagation, 4 tests intégration rotation end-to-end, 4 tests fallback mode-aware - Tests de non-fuite : sentinelles distinctes pour token, PIN, jeton QR Co-authored-by: coder/litellm/coder <coder@agents.invalid>
This commit is contained in:
195
pronote_sync/sources/pronote/auth_state.py
Normal file
195
pronote_sync/sources/pronote/auth_state.py
Normal file
@@ -0,0 +1,195 @@
|
||||
"""Persistance des credentials d'authentification par token pronotepy.
|
||||
|
||||
Ce module fournit :class:`PronoteAuthState`, qui stocke et charge les credentials
|
||||
d'authentification par QR code / token entre les exécutions du pipeline. Le token
|
||||
pronotepy rotate à chaque session : le fichier d'état doit être mis à jour après
|
||||
chaque login réussi via :meth:`PronoteAuthState.save`.
|
||||
|
||||
Le fichier d'état est créé avec des permissions ``0600`` car il contient un token
|
||||
d'authentification vivant. Son contenu n'est jamais journalisé.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from pronote_sync.errors import PronoteSyncError
|
||||
from pronote_sync.utils.redaction import redact_exception, redact_secrets
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
_STATE_VERSION = 1
|
||||
|
||||
|
||||
class PronoteAuthState:
|
||||
"""Persiste les credentials d'authentification par token pronotepy entre
|
||||
les exécutions du pipeline.
|
||||
|
||||
Le fichier d'état contient un dict au format :
|
||||
{"version": 1, "credentials": {"pronote_url": "...", "username": "...", "password": "<token>", "uuid": "..."}}
|
||||
|
||||
Les credentials sont le retour de pronotepy.Client.export_credentials(), utilisé tel quel
|
||||
pour token_login(**credentials). Le token rotate à chaque session — le fichier doit être
|
||||
mis à jour après chaque login réussi.
|
||||
|
||||
:param state_file: Chemin du fichier d'état JSON (``str`` ou
|
||||
:class:`~pathlib.Path`). ``".pronote_auth_state.json"`` par défaut.
|
||||
"""
|
||||
|
||||
def __init__(self, state_file: Path | str = ".pronote_auth_state.json") -> None:
|
||||
"""Initialise le gestionnaire d'état d'authentification Pronote.
|
||||
|
||||
Le fichier d'état n'est pas créé à l'initialisation : il n'est écrit
|
||||
qu'à la première sauvegarde réussie via :meth:`save`.
|
||||
|
||||
:param state_file: Chemin du fichier d'état JSON (``str`` ou
|
||||
:class:`~pathlib.Path`). ``".pronote_auth_state.json"`` par défaut.
|
||||
"""
|
||||
self._state_file = Path(state_file)
|
||||
|
||||
def load(self) -> dict[str, str] | None:
|
||||
"""Charge les credentials d'authentification depuis le fichier d'état.
|
||||
|
||||
Un fichier absent renvoie ``None`` (journalisé en debug). Un fichier
|
||||
corrompu, une version absente ou non supportée, ou un champ
|
||||
``credentials`` invalide renvoient ``None`` avec un avertissement.
|
||||
Le contenu des credentials n'est jamais journalisé.
|
||||
|
||||
:return: Dict des credentials (``pronote_url``, ``username``,
|
||||
``password``, ``uuid``) prêt pour
|
||||
``pronotepy.Client.token_login(**credentials)``, ou ``None`` si
|
||||
aucun état valide n'est disponible.
|
||||
:rtype: dict[str, str] | None
|
||||
"""
|
||||
if not self._state_file.exists():
|
||||
logger.debug(
|
||||
"Fichier d'état d'authentification Pronote %s absent, aucun token à charger.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
)
|
||||
return None
|
||||
try:
|
||||
data: Any = json.loads(self._state_file.read_text(encoding="utf-8"))
|
||||
except Exception as exc:
|
||||
logger.warning(
|
||||
"Impossible de charger le fichier d'état d'authentification Pronote %s : %s, "
|
||||
"aucun token chargé.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
redact_exception(exc),
|
||||
)
|
||||
return None
|
||||
if not isinstance(data, dict) or data.get("version") != _STATE_VERSION:
|
||||
logger.warning(
|
||||
"Fichier d'état d'authentification Pronote %s : version absente ou non supportée, "
|
||||
"aucun token chargé.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
)
|
||||
return None
|
||||
credentials_data = data.get("credentials")
|
||||
if not isinstance(credentials_data, dict):
|
||||
logger.warning(
|
||||
"Fichier d'état d'authentification Pronote %s : champ credentials absent ou invalide, "
|
||||
"aucun token chargé.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
)
|
||||
return None
|
||||
credentials: dict[str, str] = {}
|
||||
for key, value in credentials_data.items():
|
||||
if not isinstance(key, str) or not isinstance(value, str):
|
||||
logger.warning(
|
||||
"Fichier d'état d'authentification Pronote %s : champ credentials invalide, "
|
||||
"aucun token chargé.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
)
|
||||
return None
|
||||
credentials[key] = value
|
||||
return credentials
|
||||
|
||||
def save(self, credentials: dict[str, str]) -> None:
|
||||
"""Sauvegarde les credentials dans le fichier d'état, de manière atomique.
|
||||
|
||||
Le fichier contient ``{"version": 1, "credentials": ...}``. Le JSON est
|
||||
d'abord écrit dans un fichier temporaire du même répertoire, créé avec
|
||||
les permissions ``0600`` (lecture seule pour le propriétaire) dès son
|
||||
ouverture via :func:`os.open` (avec ``O_EXCL`` et ``O_NOFOLLOW`` pour
|
||||
résister aux attaques par lien symbolique), puis verrouillé via
|
||||
:func:`os.fchmod` avant toute écriture ; le fichier temporaire remplace
|
||||
ensuite atomiquement le fichier d'état via :func:`os.replace`. Un
|
||||
éventuel fichier temporaire stale d'une exécution interrompue est
|
||||
supprimé avant l'ouverture. Les credentials ne sont jamais journalisés.
|
||||
|
||||
:param credentials: Dict des credentials pronotepy, tel que retourné
|
||||
par ``pronotepy.Client.export_credentials()``.
|
||||
:raises PronoteSyncError: Si l'écriture ou le remplacement du fichier
|
||||
échoue.
|
||||
"""
|
||||
payload: dict[str, Any] = {
|
||||
"version": _STATE_VERSION,
|
||||
"credentials": credentials,
|
||||
}
|
||||
tmp_file = self._state_file.with_suffix(".tmp")
|
||||
fd: int | None = None
|
||||
try:
|
||||
# Nettoie un éventuel fichier temporaire stale laissé par une exécution interrompue.
|
||||
if tmp_file.exists():
|
||||
try:
|
||||
tmp_file.unlink()
|
||||
except OSError:
|
||||
logger.debug(
|
||||
"Impossible de supprimer le fichier temporaire stale %s, "
|
||||
"l'ouverture en O_EXCL échouera.",
|
||||
redact_secrets(str(tmp_file)),
|
||||
)
|
||||
# O_EXCL empêche de créer par-dessus un fichier existant (attaque par lien
|
||||
# symbolique) et O_NOFOLLOW refuse de suivre un lien symbolique.
|
||||
fd = os.open(
|
||||
str(tmp_file),
|
||||
os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW,
|
||||
0o600,
|
||||
)
|
||||
# Verrouille les permissions en 0600 avant toute écriture, indépendamment de l'umask.
|
||||
os.fchmod(fd, 0o600)
|
||||
with os.fdopen(fd, "w", encoding="utf-8") as handle:
|
||||
json.dump(payload, handle, indent=2)
|
||||
os.replace(tmp_file, self._state_file)
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Impossible d'écrire le fichier d'état d'authentification Pronote %s : %s.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
redact_exception(exc),
|
||||
)
|
||||
if fd is not None:
|
||||
try:
|
||||
os.close(fd)
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
tmp_file.unlink(missing_ok=True)
|
||||
except Exception as cleanup_exc:
|
||||
logger.debug(
|
||||
"Nettoyage du fichier temporaire d'état d'authentification Pronote échoué : %s",
|
||||
redact_exception(cleanup_exc),
|
||||
)
|
||||
raise PronoteSyncError(
|
||||
f"Impossible d'écrire le fichier d'état d'authentification Pronote "
|
||||
f"{redact_secrets(str(self._state_file))}."
|
||||
) from None
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Supprime le fichier d'état d'authentification.
|
||||
|
||||
Si le fichier n'existe pas, la méthode ne fait rien et aucune erreur
|
||||
n'est levée.
|
||||
|
||||
:raises OSError: Si la suppression du fichier existant échoue.
|
||||
"""
|
||||
if not self._state_file.exists():
|
||||
return
|
||||
logger.debug(
|
||||
"Suppression du fichier d'état d'authentification Pronote %s.",
|
||||
redact_secrets(str(self._state_file)),
|
||||
)
|
||||
self._state_file.unlink()
|
||||
@@ -10,19 +10,24 @@ des cours et des devoirs se propagent pour déclencher le repli iCal.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
from typing import Any, Protocol
|
||||
from uuid import uuid4
|
||||
|
||||
import pronotepy
|
||||
import pronotepy.ent as pronotepy_ent
|
||||
import requests
|
||||
|
||||
from pronote_sync.config.settings import PronoteSettings
|
||||
from pronote_sync.errors import PronoteAuthRotationError
|
||||
from pronote_sync.models.agenda import Lesson, LessonStatus
|
||||
from pronote_sync.models.homework import Homework
|
||||
from pronote_sync.models.message import Message, MessageType
|
||||
from pronote_sync.utils.redaction import redact_exception
|
||||
from pronote_sync.sources.pronote.auth_state import PronoteAuthState
|
||||
from pronote_sync.utils.redaction import redact_exception, redact_secrets
|
||||
from pronote_sync.utils.uid import generate_deterministic_uid, normalize_pronote_uid
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
@@ -91,6 +96,51 @@ def _resolve_ent(ent_name: str) -> Any:
|
||||
return resolver
|
||||
|
||||
|
||||
def _collect_auth_secrets(client: PronoteClient) -> list[str]:
|
||||
"""Collecte toutes les valeurs sensibles d'authentification pour la redaction.
|
||||
|
||||
Rassemble le mot de passe, le PIN QR, le contenu du fichier QR (jeton,
|
||||
login, url) et les credentials persistés (token, username) afin de les
|
||||
transmettre comme ``extra_secrets`` aux fonctions de masquage. Une valeur
|
||||
vide ou ``None`` est ignorée.
|
||||
|
||||
:param client: Le client Pronote dont on collecte les secrets.
|
||||
:return: Liste des valeurs sensibles à expurger des logs.
|
||||
:rtype: list[str]
|
||||
"""
|
||||
secrets: list[str] = []
|
||||
settings = client._settings
|
||||
# Mot de passe
|
||||
if settings.password is not None:
|
||||
secrets.append(settings.password.get_secret_value())
|
||||
# PIN QR
|
||||
if settings.qr_pin is not None:
|
||||
secrets.append(settings.qr_pin.get_secret_value())
|
||||
# Contenu du fichier QR (jeton, login, url)
|
||||
if settings.qr_code_file is not None:
|
||||
try:
|
||||
qr_path = Path(settings.qr_code_file)
|
||||
qr_data: Any = json.loads(qr_path.read_text(encoding="utf-8"))
|
||||
for key in ("jeton", "login", "url"):
|
||||
val = qr_data.get(key)
|
||||
if isinstance(val, str):
|
||||
secrets.append(val)
|
||||
except Exception as exc:
|
||||
logger.debug(
|
||||
"Impossible de lire le fichier QR %s : %s",
|
||||
redact_secrets(settings.qr_code_file),
|
||||
redact_exception(exc),
|
||||
)
|
||||
# Credentials persistés (token, username du fichier d'état)
|
||||
if client._auth_state is not None:
|
||||
creds = client._auth_state.load()
|
||||
if creds is not None:
|
||||
for val in creds.values():
|
||||
if isinstance(val, str):
|
||||
secrets.append(val)
|
||||
return [s for s in secrets if s]
|
||||
|
||||
|
||||
class PronoteClientProtocol(Protocol):
|
||||
"""Interface du client Pronote consommée par la logique de repli."""
|
||||
|
||||
@@ -143,24 +193,56 @@ class PronoteClient:
|
||||
exceptions se propager pour déclencher le repli iCal.
|
||||
"""
|
||||
|
||||
def __init__(self, settings: PronoteSettings) -> None:
|
||||
def __init__(
|
||||
self,
|
||||
settings: PronoteSettings,
|
||||
auth_state: PronoteAuthState | None = None,
|
||||
) -> None:
|
||||
"""Initialise le client Pronote sans se connecter.
|
||||
|
||||
:param settings: Paramètres d'accès à Pronote (username, password, ent).
|
||||
:param settings: Paramètres d'accès à Pronote (username, password, ent,
|
||||
mode d'authentification, fichier QR et PIN).
|
||||
:param auth_state: Gestionnaire de persistance du token
|
||||
d'authentification (optionnel ; requis en mode ``qr_token`` pour
|
||||
conserver le token entre les exécutions).
|
||||
"""
|
||||
self._settings: PronoteSettings = settings
|
||||
self._auth_state: PronoteAuthState | None = auth_state
|
||||
self._client: pronotepy.Client | None = None
|
||||
|
||||
def _connect(self) -> pronotepy.Client:
|
||||
"""Crée et connecte le client ``pronotepy`` (connexion paresseuse).
|
||||
|
||||
Le client est créé une seule fois puis réutilisé pour les appels
|
||||
suivants. Le nom d'ENT, s'il est configuré, est résolu via
|
||||
:func:`_resolve_ent` ; en l'absence d'ENT, ``ent=None`` est transmis
|
||||
à ``pronotepy`` pour une connexion directe. 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.
|
||||
En mode ``password``, utilise l'authentification classique (URL,
|
||||
username, password, ENT). En mode ``qr_token``, utilise le token
|
||||
persisté via :class:`PronoteAuthState`, ou procède à l'enrôlement
|
||||
initial par QR code si aucun token n'est présent.
|
||||
|
||||
:return: Le client ``pronotepy`` connecté.
|
||||
:rtype: pronotepy.Client
|
||||
:raises ValueError: Si les credentials requis sont manquants.
|
||||
:raises PronoteAuthRotationError: Si le token persisté est invalide
|
||||
(rotation requise) ou si l'enrôlement QR échoue.
|
||||
:raises pronotepy.PronoteAPIError: Si la connexion échoue.
|
||||
"""
|
||||
if self._client is not None:
|
||||
return self._client
|
||||
|
||||
if self._settings.auth_mode == "qr_token":
|
||||
self._client = self._connect_qr_token()
|
||||
else:
|
||||
self._client = self._connect_password()
|
||||
return self._client
|
||||
|
||||
def _connect_password(self) -> pronotepy.Client:
|
||||
"""Connecte le client ``pronotepy`` en mode ``password``.
|
||||
|
||||
Le nom d'ENT, s'il est configuré, est résolu via :func:`_resolve_ent` ;
|
||||
en l'absence d'ENT, ``ent=None`` est transmis à ``pronotepy`` pour une
|
||||
connexion directe. 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
|
||||
@@ -168,27 +250,153 @@ class PronoteClient:
|
||||
est manquant, ou si l'ENT fourni est inconnu.
|
||||
:raises pronotepy.PronoteAPIError: Si la connexion à Pronote échoue.
|
||||
"""
|
||||
if self._client is None:
|
||||
url = self._settings.url
|
||||
username = self._settings.username
|
||||
password = self._settings.password
|
||||
ent = self._settings.ent
|
||||
if url is None or username is None or password is None:
|
||||
raise ValueError("url, username et password sont requis pour pronotepy")
|
||||
resolver = _resolve_ent(ent) if ent is not None else None
|
||||
client_class: type[pronotepy.Client] = (
|
||||
pronotepy.ParentClient
|
||||
if self._settings.account_type == "parent"
|
||||
else pronotepy.Client
|
||||
)
|
||||
self._client = client_class(
|
||||
pronote_url=url,
|
||||
username=username,
|
||||
password=password.get_secret_value(),
|
||||
ent=resolver,
|
||||
)
|
||||
url = self._settings.url
|
||||
username = self._settings.username
|
||||
password = self._settings.password
|
||||
ent = self._settings.ent
|
||||
if url is None or username is None or password is None:
|
||||
raise ValueError("url, username et password sont requis pour pronotepy")
|
||||
resolver = _resolve_ent(ent) if ent is not None else None
|
||||
client_class: type[pronotepy.Client] = (
|
||||
pronotepy.ParentClient if self._settings.account_type == "parent" else pronotepy.Client
|
||||
)
|
||||
self._client = client_class(
|
||||
pronote_url=url,
|
||||
username=username,
|
||||
password=password.get_secret_value(),
|
||||
ent=resolver,
|
||||
)
|
||||
return self._client
|
||||
|
||||
def _connect_qr_token(self) -> pronotepy.Client:
|
||||
"""Connecte via token persisté ou enrôlement par QR code.
|
||||
|
||||
En premier lieu, les credentials persistés (``pronote_url``, username,
|
||||
``password``/token, ``uuid``) sont rejoués via
|
||||
``pronotepy.Client.token_login`` si :class:`PronoteAuthState` est
|
||||
disponible et fournit un état. En cas d'échec du login par token
|
||||
(exception ou client non connecté), une :class:`PronoteAuthRotationError`
|
||||
est levée immédiatement, sans repli vers l'enrôlement QR : la rotation
|
||||
du token doit être déclenchée par l'opérateur. L'enrôlement par QR code
|
||||
n'est tenté que lorsqu'aucun credential n'est persisté (premier login) ;
|
||||
le nouveau token est ensuite persisté immédiatement.
|
||||
|
||||
:return: Le client ``pronotepy`` connecté.
|
||||
:rtype: pronotepy.Client
|
||||
:raises PronoteAuthRotationError: Si le token persisté est invalide
|
||||
(expiré ou refusé par Pronote), ou si l'enrôlement QR échoue
|
||||
(fichier QR ou PIN manquant, fichier QR invalide ou expiré).
|
||||
"""
|
||||
client_class: type[pronotepy.Client] = (
|
||||
pronotepy.ParentClient if self._settings.account_type == "parent" else pronotepy.Client
|
||||
)
|
||||
|
||||
# Login par token avec les credentials persistés
|
||||
if self._auth_state is not None:
|
||||
creds = self._auth_state.load()
|
||||
if creds is not None:
|
||||
try:
|
||||
client = client_class.token_login(**creds)
|
||||
if client.logged_in:
|
||||
self._auth_state.save(client.export_credentials())
|
||||
return client
|
||||
# logged_in est False — le token est invalide
|
||||
raise PronoteAuthRotationError(
|
||||
"Le token d'authentification Pronote est invalide (non connecté). "
|
||||
"Action requise : supprimez le fichier .pronote_auth_state.json "
|
||||
"et relancez avec un nouveau QR code."
|
||||
) from None
|
||||
except PronoteAuthRotationError:
|
||||
raise
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Échec du login par token pronotepy : %s",
|
||||
redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
|
||||
)
|
||||
# Token expiré/invalide — pas de repli vers l'enrôlement QR
|
||||
raise PronoteAuthRotationError(
|
||||
"Le token d'authentification Pronote est expiré ou invalide. "
|
||||
"Action requise : supprimez le fichier .pronote_auth_state.json "
|
||||
"et relancez avec un nouveau QR code (PRONOTE_QR_CODE_FILE + "
|
||||
"PRONOTE_QR_PIN)."
|
||||
) from None
|
||||
|
||||
# Enrôlement : premier login via QR code (aucun credential persisté)
|
||||
client = self._enroll_qr_code(client_class)
|
||||
# Persister le token rotaté immédiatement
|
||||
if self._auth_state is not None:
|
||||
self._auth_state.save(client.export_credentials())
|
||||
return client
|
||||
|
||||
def _enroll_qr_code(self, client_class: type[pronotepy.Client]) -> pronotepy.Client:
|
||||
"""Procède à l'enrôlement initial via QR code pronotepy.
|
||||
|
||||
Le fichier QR JSON doit contenir les clés ``login``, ``jeton`` et
|
||||
``url``. Le PIN et le contenu du fichier ne sont jamais journalisés ;
|
||||
les erreurs propagées sont expurgées.
|
||||
|
||||
:param client_class: Classe de client pronotepy à utiliser.
|
||||
:return: Le client ``pronotepy`` connecté après enrôlement.
|
||||
:rtype: pronotepy.Client
|
||||
:raises PronoteAuthRotationError: Si le fichier QR ou le PIN est
|
||||
manquant, si le fichier QR est illisible ou incomplet, ou si le
|
||||
login par QR code échoue (PIN invalide ou QR code expiré).
|
||||
"""
|
||||
qr_file = self._settings.qr_code_file
|
||||
qr_pin = self._settings.qr_pin
|
||||
|
||||
if qr_file is None or qr_pin is None:
|
||||
raise PronoteAuthRotationError(
|
||||
"Enrôlement QR requis : PRONOTE_QR_CODE_FILE et PRONOTE_QR_PIN sont "
|
||||
"nécessaires pour le premier login en mode qr_token. Supprimez le "
|
||||
"fichier .pronote_auth_state.json si présent et relancez avec un "
|
||||
"QR code frais."
|
||||
) from None
|
||||
|
||||
# Read and validate QR code JSON
|
||||
try:
|
||||
qr_path = Path(qr_file)
|
||||
qr_data: Any = json.loads(qr_path.read_text(encoding="utf-8"))
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Fichier QR invalide %s : %s",
|
||||
redact_secrets(qr_file, extra_secrets=_collect_auth_secrets(self)),
|
||||
redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
|
||||
)
|
||||
raise PronoteAuthRotationError(
|
||||
"Impossible de lire le fichier QR code : "
|
||||
f"{redact_secrets(qr_file, extra_secrets=_collect_auth_secrets(self))}"
|
||||
) from None
|
||||
|
||||
# Validate required keys
|
||||
for key in ("login", "jeton", "url"):
|
||||
if key not in qr_data:
|
||||
raise PronoteAuthRotationError(
|
||||
f"Le fichier QR code ne contient pas la clé requise : {key}"
|
||||
) from None
|
||||
|
||||
pin_value = qr_pin.get_secret_value()
|
||||
app_uuid = f"pronote-sync-{uuid4().hex}"
|
||||
|
||||
try:
|
||||
client = client_class.qrcode_login(
|
||||
qr_code=qr_data,
|
||||
pin=pin_value,
|
||||
uuid=app_uuid,
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Échec de l'enrôlement QR : %s",
|
||||
redact_exception(exc, extra_secrets=_collect_auth_secrets(self)),
|
||||
)
|
||||
raise PronoteAuthRotationError(
|
||||
"Échec de l'enrôlement par QR code : PIN invalide ou QR code expiré. "
|
||||
"Générez un nouveau QR code dans l'application Pronote et mettez à "
|
||||
"jour PRONOTE_QR_CODE_FILE."
|
||||
) from None
|
||||
|
||||
return client
|
||||
|
||||
def get_messages(self) -> list[Message]:
|
||||
"""Récupère les messages des discussions Pronote.
|
||||
|
||||
@@ -284,6 +492,8 @@ class PronoteClient:
|
||||
:param end: Date de fin de la fenêtre (incluse).
|
||||
:return: Liste des cours.
|
||||
:rtype: list[Lesson]
|
||||
:raises PronoteAuthRotationError: Si le token persisté est invalide et
|
||||
qu'aucun ré-enrôlement n'est possible (fichier QR ou PIN manquant).
|
||||
: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.
|
||||
@@ -334,6 +544,8 @@ class PronoteClient:
|
||||
:param end: Date de fin de la fenêtre (incluse).
|
||||
:return: Liste des devoirs.
|
||||
:rtype: list[Homework]
|
||||
:raises PronoteAuthRotationError: Si le token persisté est invalide et
|
||||
qu'aucun ré-enrôlement n'est possible (fichier QR ou PIN manquant).
|
||||
: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.
|
||||
|
||||
@@ -23,7 +23,7 @@ from enum import StrEnum
|
||||
from typing import Literal, Protocol
|
||||
|
||||
from pronote_sync.config.settings import Settings
|
||||
from pronote_sync.errors import PipelineCriticalError
|
||||
from pronote_sync.errors import PipelineCriticalError, PronoteAuthRotationError
|
||||
from pronote_sync.models.agenda import Lesson, SchoolEvent
|
||||
from pronote_sync.models.homework import Homework
|
||||
from pronote_sync.models.message import Message
|
||||
@@ -147,13 +147,19 @@ class PronoteFetcher:
|
||||
return self._settings.pronote.ical_url is not None
|
||||
|
||||
def _is_pronotepy_configured(self) -> bool:
|
||||
"""Vérifie que la source pronotepy est entièrement configurée.
|
||||
"""Vérifie si la source pronotepy est utilisable selon le mode d'authentification.
|
||||
|
||||
:return: ``True`` si ``url``, ``username`` et ``password``
|
||||
sont tous définis, ``False`` sinon.
|
||||
:return: ``True`` si pronotepy est configuré pour le mode
|
||||
d'authentification actif, ``False`` sinon.
|
||||
:rtype: bool
|
||||
"""
|
||||
pronote = self._settings.pronote
|
||||
if pronote.auth_mode == "qr_token":
|
||||
# En mode qr_token, seul PRONOTE_URL est requis.
|
||||
# Le QR code et le PIN ne sont nécessaires que pour l'enrôlement initial.
|
||||
# Les exécutions suivantes utilisent le token persisté.
|
||||
return pronote.url is not None
|
||||
# En mode password, URL + identifiant + mot de passe sont requis.
|
||||
return (
|
||||
pronote.url is not None
|
||||
and pronote.username is not None
|
||||
@@ -249,10 +255,14 @@ class PronoteFetcher:
|
||||
:return: Tuple ``(cours, événements scolaires)``.
|
||||
:rtype: tuple[list[Lesson], list[SchoolEvent]]
|
||||
:raises PipelineCriticalError: Si toutes les sources tentées échouent.
|
||||
:raises PronoteAuthRotationError: Si une rotation du token d'authentification
|
||||
pronotepy est nécessaire : propagée telle quelle, sans repli.
|
||||
"""
|
||||
primary, fallback = self._agenda_sources()
|
||||
try:
|
||||
return self._fetch_agenda_source(primary)
|
||||
except PronoteAuthRotationError:
|
||||
raise
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Échec de la récupération %s pour l'agenda : %s",
|
||||
@@ -266,6 +276,8 @@ class PronoteFetcher:
|
||||
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",
|
||||
@@ -370,10 +382,14 @@ class PronoteFetcher:
|
||||
:return: Liste des devoirs.
|
||||
:rtype: list[Homework]
|
||||
:raises PipelineCriticalError: Si toutes les sources tentées échouent.
|
||||
:raises PronoteAuthRotationError: Si une rotation du token d'authentification
|
||||
pronotepy est nécessaire : propagée telle quelle, sans repli.
|
||||
"""
|
||||
primary, fallback = self._homework_sources()
|
||||
try:
|
||||
return self._fetch_homework_source(primary, target_date)
|
||||
except PronoteAuthRotationError:
|
||||
raise
|
||||
except Exception as exc:
|
||||
logger.error(
|
||||
"Échec de la récupération %s pour les devoirs : %s",
|
||||
@@ -387,6 +403,8 @@ class PronoteFetcher:
|
||||
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",
|
||||
|
||||
Reference in New Issue
Block a user