@tricoteuses/senat 3.1.20 → 3.1.21

package/lib/src/parsers/collaborateurs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
+ *
+ * Le PDF est un tableau à deux colonnes par page :
+ *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
+ * Une ligne sans employeur prolonge le sénateur précédent.
+ *
+ * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
+ * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ */
+/** Élément de texte positionné extrait du PDF (x croissant vers la droite, y croissant vers le haut). */
+export type PdfTextItem = {
+    str: string;
+    x: number;
+    y: number;
+    page: number;
+};
+export type PersonneNom = {
+    civilite: string;
+    nom: string;
+    prenom: string;
+};
+export type LigneCollaborateur = {
+    senateur: PersonneNom;
+    collaborateur: PersonneNom;
+};
+/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
+export declare function normaliserPourComparaison(valeur: string): string;
+/**
+ * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
+ * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
+ * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ */
+export declare function parseCellulePersonne(cellule: string): PersonneNom | null;
+/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
+export declare function extraireDateEdition(strings: string[]): Date | null;
+/**
+ * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
+ * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
+ * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ */
+export declare function construireLignesCollaborateurs(items: PdfTextItem[]): LigneCollaborateur[];

package/lib/src/parsers/collaborateurs.js

@@ -0,0 +1,157 @@
+/**
+ * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
+ *
+ * Le PDF est un tableau à deux colonnes par page :
+ *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
+ * Une ligne sans employeur prolonge le sénateur précédent.
+ *
+ * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
+ * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ */
+// Bandes horizontales des deux colonnes (mesurées sur le PDF : employeur ≈ 147, collaborateur ≈ 285).
+const COLONNE_EMPLOYEUR = { min: 130, max: 225 };
+const COLONNE_COLLABORATEUR = { min: 255, max: 360 };
+const CIVILITES = ["Mme", "M.", "Mlle", "M"];
+// Particules nobiliaires/patronymiques en minuscules, qui font partie du nom quand elles le précèdent
+// (ex. "de CIDRAC", "de LA GONTRIE", "de LEGGE"). Le référentiel Sénat les conserve dans Nom_usuel.
+const PARTICULES = new Set([
+    "de",
+    "du",
+    "des",
+    "d'",
+    "le",
+    "la",
+    "les",
+    "von",
+    "van",
+    "der",
+    "den",
+    "da",
+    "di",
+    "del",
+    "dos",
+]);
+// Lignes d'en-tête / pied de page à ignorer.
+const LIGNES_IGNOREES = [
+    /liste des collaborateurs/i,
+    /^employeur$/i,
+    /^nom collaborateur$/i,
+    /^a\.?g\.?a\.?s\.?/i,
+    /edition du/i,
+    /congé non rémunéré/i,
+    /^-\s*\d+\s*-$/,
+];
+/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
+export function normaliserPourComparaison(valeur) {
+    return valeur
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toUpperCase()
+        .replace(/['']/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function estIgnoree(str) {
+    const t = str.trim();
+    if (!t)
+        return true;
+    return LIGNES_IGNOREES.some((re) => re.test(t));
+}
+/**
+ * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
+ * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
+ * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ */
+export function parseCellulePersonne(cellule) {
+    const brut = cellule
+        .replace(/\(\*\)/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!brut)
+        return null;
+    let civilite = "";
+    let reste = brut;
+    for (const civ of CIVILITES) {
+        if (brut === civ)
+            return null;
+        if (brut.startsWith(`${civ} `)) {
+            civilite = civ;
+            reste = brut.slice(civ.length + 1).trim();
+            break;
+        }
+    }
+    if (!reste)
+        return null;
+    const jetons = reste.split(" ");
+    const estMajuscule = (jeton) => {
+        const lettres = jeton.replace(/[^A-Za-zÀ-ÿ]/g, "");
+        return lettres.length > 0 && lettres === lettres.toUpperCase();
+    };
+    const jetonsNom = [];
+    let i = 0;
+    // Particules de tête en minuscules (ex. "de", "de la") faisant partie du nom.
+    while (i < jetons.length && PARTICULES.has(jetons[i].toLowerCase())) {
+        jetonsNom.push(jetons[i]);
+        i++;
+    }
+    // Puis les jetons du nom en majuscules.
+    while (i < jetons.length && estMajuscule(jetons[i])) {
+        jetonsNom.push(jetons[i]);
+        i++;
+    }
+    // Une particule seule sans nom en majuscules n'est pas un nom valide : on rétablit.
+    if (jetonsNom.length > 0 && jetonsNom.every((j) => PARTICULES.has(j.toLowerCase()))) {
+        jetonsNom.length = 0;
+        i = 0;
+    }
+    // Si aucun jeton majuscule (cas inattendu), on prend le premier comme nom.
+    if (jetonsNom.length === 0 && jetons.length > 0) {
+        jetonsNom.push(jetons[0]);
+        i = 1;
+    }
+    const nom = jetonsNom.join(" ");
+    const prenom = jetons.slice(i).join(" ");
+    if (!nom)
+        return null;
+    return { civilite, nom, prenom };
+}
+/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
+export function extraireDateEdition(strings) {
+    for (const s of strings) {
+        const m = s.match(/Edition du\s+(\d{2})\/(\d{2})\/(\d{4})/i);
+        if (m) {
+            const [, jj, mm, aaaa] = m;
+            return new Date(Date.UTC(Number(aaaa), Number(mm) - 1, Number(jj)));
+        }
+    }
+    return null;
+}
+/**
+ * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
+ * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
+ * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ */
+export function construireLignesCollaborateurs(items) {
+    const utiles = items.filter((it) => !estIgnoree(it.str));
+    // Tri lecture : page croissante, puis y décroissant (haut → bas), puis x croissant (gauche → droite).
+    const tries = [...utiles].sort((a, b) => a.page - b.page || b.y - a.y || a.x - b.x);
+    const lignes = [];
+    let senateurCourant = null;
+    for (const it of tries) {
+        const dansEmployeur = it.x >= COLONNE_EMPLOYEUR.min && it.x <= COLONNE_EMPLOYEUR.max;
+        const dansCollaborateur = it.x >= COLONNE_COLLABORATEUR.min && it.x <= COLONNE_COLLABORATEUR.max;
+        if (dansEmployeur) {
+            const personne = parseCellulePersonne(it.str);
+            if (personne)
+                senateurCourant = personne;
+        }
+        else if (dansCollaborateur && senateurCourant) {
+            const collaborateur = parseCellulePersonne(it.str);
+            if (collaborateur)
+                lignes.push({ senateur: senateurCourant, collaborateur });
+        }
+    }
+    return lignes;
+}

package/lib/src/scripts/retrieve_agenda.js

@@ -11,6 +11,8 @@ import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js"
 import { fetchWithRetry } from "./shared/util.js";
 import { buildReunionsByBucket } from "../utils/reunion_parsing.js";
 import { buildSenatDossierIndex, buildDoslegReunionIndex } from "../utils/reunion_odj_building.js";
+import { loadPreviousManifest, saveManifest, detectChanges } from "../utils/manifest.js";
+import { deleteReunionFiles } from "../utils/reunion_deletion.js";
 const optionsDefinitions = [
     ...commonOptions,
     {
@@ -52,11 +54,9 @@ async function retrieveAgendas(options, sessions) {
     for (const session of sessions) {
         const originalAgendaSessionDir = path.join(originalAgendaDir, `${session}`);
         fs.ensureDirSync(originalAgendaSessionDir);
-        fs.emptyDirSync(originalAgendaSessionDir);
         const transformedAgendaSessionDir = path.join(transformedAgendaDir, `${session}`);
         if (options["parseAgenda"]) {
             fs.ensureDirSync(transformedAgendaSessionDir);
-            fs.emptyDirSync(transformedAgendaSessionDir);
         }
         const fifteenDaysFromNow = new Date();
         // Don't download agendas more than 15 days in the future.
@@ -68,7 +68,8 @@ async function retrieveAgendas(options, sessions) {
             try {
                 await downloadAgenda(agendaName, agendaPath);
                 if (options["parseAgenda"]) {
-                    await parseAgenda(transformedAgendaSessionDir, agendaFileName, agendaPath, dossierIndex, doslegReunionIndex);
+                    const createdUids = await parseAgenda(transformedAgendaSessionDir, agendaFileName, agendaPath, dossierIndex, doslegReunionIndex);
+                    await processManifestAndDeletions(transformedAgendaSessionDir, agendaFileName, session, createdUids);
                 }
             }
             catch (error) {
@@ -109,21 +110,54 @@ async function parseAgenda(transformedAgendaSessionDir, agendaFileName, agendaPa
         console.log(`Parsing Agenda ${agendaPath}…`);
     const parsedAgendaEvents = await parseAgendaFromFile(agendaPath);
     if (!parsedAgendaEvents?.length)
-        return;
+        return [];
     const flatPath = path.join(transformedAgendaSessionDir, `${agendaFileName}.json`);
     fs.writeJSONSync(flatPath, parsedAgendaEvents, { spaces: 2 });
     const byBucket = buildReunionsByBucket(parsedAgendaEvents, dossierBySenatUrl, doslegReunionIndex);
+    // Collecter tous les UIDs créés
+    const createdUids = [];
     // SP
     if (byBucket.IDS.length > 0) {
         writeGroupsAsFiles(transformedAgendaSessionDir, byBucket.IDS);
+        createdUids.push(...byBucket.IDS.map((r) => r.uid));
     }
     // NON-SP
     for (const suffix of ["IDC", "IDM", "IDO", "IDI"]) {
         const groups = byBucket[suffix];
         if (groups.length > 0) {
             writeGroupsAsFiles(transformedAgendaSessionDir, groups);
+            createdUids.push(...groups.map((r) => r.uid));
+        }
+    }
+    return createdUids;
+}
+async function processManifestAndDeletions(transformedAgendaSessionDir, agendaFileName, session, currentUids) {
+    const date = agendaFileName;
+    const previousManifest = loadPreviousManifest(transformedAgendaSessionDir, date);
+    if (previousManifest) {
+        const changes = detectChanges(previousManifest.reunionUids, currentUids);
+        if (changes.new.length > 0) {
+            console.log(`  [${date}] ${changes.new.length} nouvelle(s) réunion(s)`);
         }
+        if (changes.deleted.length > 0) {
+            console.log(`  [${date}] ${changes.deleted.length} réunion(s) supprimée(s) détectée(s)`);
+            const deleted = deleteReunionFiles(transformedAgendaSessionDir, changes.deleted);
+            console.log(`  [${date}] ${deleted} fichier(s) supprimé(s)`);
+        }
+        if (changes.kept.length > 0 && !options["silent"]) {
+            console.log(`  [${date}] ${changes.kept.length} réunion(s) conservée(s)`);
+        }
+    }
+    else if (!options["silent"]) {
+        console.log(`  [${date}] Premier téléchargement (${currentUids.length} réunions)`);
     }
+    const newManifest = {
+        date,
+        timestamp: DateTime.now().toISO() ?? "",
+        reunionUids: currentUids,
+        session,
+    };
+    saveManifest(transformedAgendaSessionDir, newManifest);
 }
 async function main() {
     const dataDir = assertExistingDirectory(options["dataDir"], "data directory");

package/lib/src/scripts/retrieve_collaborateurs.js

@@ -0,0 +1,166 @@
+import fs from "fs-extra";
+import path from "path";
+import { getDocumentProxy } from "unpdf";
+import { construireLignesCollaborateurs, extraireDateEdition, normaliserPourComparaison, } from "../parsers/collaborateurs.js";
+import { assertExistingDirectory } from "./shared/cli_helpers.js";
+import { iterFilePaths } from "../server/loaders.js";
+const URL_PDF_DEFAUT = "https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf";
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36";
+async function telechargerPdf(url) {
+    const cookies = new Map();
+    let courant = url;
+    for (let i = 0; i < 8; i += 1) {
+        const headers = { "User-Agent": USER_AGENT };
+        if (cookies.size > 0) {
+            headers["Cookie"] = [...cookies].map(([k, v]) => `${k}=${v}`).join("; ");
+        }
+        const reponse = await fetch(courant, { redirect: "manual", headers });
+        for (const brut of reponse.headers.getSetCookie?.() ?? []) {
+            const [paire] = brut.split(";");
+            const idx = paire.indexOf("=");
+            if (idx > 0)
+                cookies.set(paire.slice(0, idx).trim(), paire.slice(idx + 1).trim());
+        }
+        if (reponse.status >= 300 && reponse.status < 400) {
+            const location = reponse.headers.get("location");
+            if (!location)
+                throw new Error(`Redirection sans en-tête Location (HTTP ${reponse.status})`);
+            courant = new URL(location, courant).toString();
+            continue;
+        }
+        if (!reponse.ok)
+            throw new Error(`Téléchargement du PDF échoué : HTTP ${reponse.status}`);
+        const buffer = Buffer.from(await reponse.arrayBuffer());
+        if (buffer.subarray(0, 5).toString("latin1") !== "%PDF-") {
+            throw new Error("Le contenu téléchargé n'est pas un PDF");
+        }
+        return buffer;
+    }
+    throw new Error("Trop de redirections lors du téléchargement du PDF DRH");
+}
+async function extraireItemsPdf(buffer) {
+    const pdf = await getDocumentProxy(new Uint8Array(buffer));
+    const items = [];
+    const strings = [];
+    for (let p = 1; p <= pdf.numPages; p += 1) {
+        const page = await pdf.getPage(p);
+        const contenu = await page.getTextContent();
+        for (const item of contenu.items) {
+            if (typeof item.str !== "string" || !item.str.trim() || !item.transform)
+                continue;
+            items.push({ str: item.str, x: item.transform[4], y: item.transform[5], page: p });
+            strings.push(item.str);
+        }
+    }
+    return { items, strings };
+}
+function chargerSenateurs(dataDir) {
+    const senateursDir = path.join(dataDir, "sens", "senateurs");
+    const files = new Map();
+    const indexParNom = new Map();
+    if (!fs.existsSync(senateursDir))
+        return { files, indexParNom };
+    for (const filePath of iterFilePaths(senateursDir)) {
+        const senator = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        files.set(senator.matricule, senator);
+        const cle = normaliserPourComparaison(senator.nom_usuel);
+        const liste = indexParNom.get(cle);
+        if (liste)
+            liste.push(senator);
+        else
+            indexParNom.set(cle, [senator]);
+    }
+    return { files, indexParNom };
+}
+async function main() {
+    const dataDir = process.argv[2];
+    assertExistingDirectory(dataDir, "dataDir");
+    // 1. Téléchargement + parsing du PDF
+    console.log(`Téléchargement du PDF DRH : ${URL_PDF_DEFAUT}`);
+    const buffer = await telechargerPdf(URL_PDF_DEFAUT);
+    const { items, strings } = await extraireItemsPdf(buffer);
+    const lignes = construireLignesCollaborateurs(items);
+    const dateEdition = extraireDateEdition(strings);
+    console.log(`PDF lu : ${lignes.length} lignes collaborateur, édition ${dateEdition?.toISOString().slice(0, 10) ?? "inconnue"}`);
+    if (lignes.length === 0) {
+        throw new Error("Aucune ligne collaborateur extraite du PDF : format inattendu, abandon sans modification.");
+    }
+    // 2. Charger les fichiers sénateurs existants
+    const { indexParNom } = chargerSenateurs(dataDir);
+    if (indexParNom.size === 0) {
+        throw new Error("Aucun fichier sénateur trouvé. Lancez d'abord data:download pour générer les fichiers.");
+    }
+    // 3. Résoudre les sénateurs du PDF → fichiers
+    let nbEnrichis = 0;
+    let nbNonResolus = 0;
+    // Grouper les collaborateurs par matricule de sénateur
+    const collabsParMatricule = new Map();
+    const nomsNonResolus = new Set();
+    for (const ligne of lignes) {
+        const cleNom = normaliserPourComparaison(ligne.senateur.nom);
+        const candidats = indexParNom.get(cleNom);
+        if (!candidats || candidats.length === 0) {
+            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
+            nbNonResolus += 1;
+            continue;
+        }
+        // Désambiguïsation par préfixe de prénom
+        const prenomCible = normaliserPourComparaison(ligne.senateur.prenom);
+        const parPrenom = candidats.filter((c) => normaliserPourComparaison(c.prenom_usuel).startsWith(prenomCible));
+        let senator = null;
+        if (candidats.length === 1) {
+            senator = candidats[0];
+        }
+        else if (parPrenom.length === 1) {
+            senator = parPrenom[0];
+        }
+        else {
+            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
+            nbNonResolus += 1;
+            continue;
+        }
+        let collabs = collabsParMatricule.get(senator.matricule);
+        if (!collabs) {
+            collabs = [];
+            collabsParMatricule.set(senator.matricule, collabs);
+        }
+        // Dédoublonnage
+        const nNom = normaliserPourComparaison(ligne.collaborateur.nom);
+        const nPrenom = normaliserPourComparaison(ligne.collaborateur.prenom);
+        if (!collabs.some((c) => normaliserPourComparaison(c.nom) === nNom && normaliserPourComparaison(c.prenom) === nPrenom)) {
+            collabs.push({
+                civilite: ligne.collaborateur.civilite,
+                nom: ligne.collaborateur.nom,
+                prenom: ligne.collaborateur.prenom,
+            });
+        }
+    }
+    // 4. Écrire les collaborateurs dans les fichiers sénateurs
+    for (const [matricule, collaborateurs] of collabsParMatricule) {
+        const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+        if (!fs.existsSync(cheminFichier))
+            continue;
+        const senator = JSON.parse(fs.readFileSync(cheminFichier, "utf-8"));
+        senator.collaborateurs = collaborateurs;
+        fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
+        nbEnrichis += 1;
+    }
+    // 5. Nettoyer les collaborateurs des sénateurs absents du PDF
+    const matriculesEnrichis = new Set(collabsParMatricule.keys());
+    const { files: tousLesFichiers } = chargerSenateurs(dataDir);
+    for (const [matricule, senator] of tousLesFichiers) {
+        if (!matriculesEnrichis.has(matricule) && senator.collaborateurs) {
+            delete senator.collaborateurs;
+            const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+            fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
+        }
+    }
+    console.log(`${nbEnrichis} sénateur(s) enrichi(s) avec leurs collaborateurs`);
+    if (nomsNonResolus.size > 0) {
+        console.warn(`${nbNonResolus} sénateur(s) du PDF non rattaché(s) : ${[...nomsNonResolus].slice(0, 10).join(", ")}${nomsNonResolus.size > 10 ? "…" : ""}`);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});