@tricoteuses/senat 2.8.1 → 2.8.5

package/lib/scripts/convert_data.mjs

@@ -0,0 +1,95 @@
+import assert from "assert";
+import commandLineArgs from "command-line-args";
+import fs from "fs-extra";
+import path from "path";
+import { datasets, EnabledDatasets, getEnabledDatasets } from "../datasets";
+import { findAllCirconscriptions, findAllLois, findAllQuestions, findAllSens } from "../model";
+import { formatToFourDigitSession, SIGNET_STRUCTURE_REGEXP, UNDEFINED_SESSION } from "./datautil";
+import { commonOptions } from "./shared/cli_helpers";
+import { ensureAndClearDir } from "./shared/util";
+const optionsDefinitions = [
+    ...commonOptions,
+];
+const options = commandLineArgs(optionsDefinitions);
+async function convertData() {
+    const enabledDatasets = getEnabledDatasets(options.categories);
+    const dataDir = options.dataDir;
+    assert(dataDir, "Missing argument: data directory");
+    console.time("conversion time");
+    if (enabledDatasets & EnabledDatasets.DosLeg) {
+        const dataset = datasets.dosleg;
+        if (!options.silent) {
+            console.log(`Converting database ${dataset.database} data into files…`);
+        }
+        const loiReorganizedRootDir = path.join(dataDir, dataset.database);
+        ensureAndClearDir(loiReorganizedRootDir);
+        for await (const loi of findAllLois()) {
+            if (options.verbose) {
+                console.log(`Converting ${loi.signet} file…`);
+            }
+            let loiReorganizedDir = path.join(loiReorganizedRootDir, UNDEFINED_SESSION);
+            const signetParts = SIGNET_STRUCTURE_REGEXP.exec(loi.signet)?.groups;
+            if (signetParts) {
+                const { session } = signetParts;
+                const formattedSession = formatToFourDigitSession(session);
+                loiReorganizedDir = path.join(loiReorganizedRootDir, formattedSession);
+            }
+            fs.ensureDirSync(loiReorganizedDir);
+            const loiFileName = `${loi.signet}.json`;
+            fs.writeJSONSync(path.join(loiReorganizedDir, loiFileName), loi, { spaces: 2 });
+        }
+    }
+    if (enabledDatasets & EnabledDatasets.Questions) {
+        const dataset = datasets.questions;
+        if (!options.silent) {
+            console.log(`Converting database ${dataset.database} data into files…`);
+        }
+        const questionReorganizedRootDir = path.join(dataDir, dataset.database);
+        ensureAndClearDir(questionReorganizedRootDir);
+        for await (const question of findAllQuestions()) {
+            if (options.verbose) {
+                console.log(`Converting ${question.reference} file…`);
+            }
+            const legislature = question.legislature ? question.legislature : 0;
+            const questionReorganizedDir = path.join(questionReorganizedRootDir, String(legislature));
+            fs.ensureDirSync(questionReorganizedDir);
+            const questionFileName = `${question.reference}.json`;
+            fs.writeJSONSync(path.join(questionReorganizedDir, questionFileName), question, { spaces: 2 });
+        }
+    }
+    if (enabledDatasets & EnabledDatasets.Sens) {
+        const dataset = datasets.sens;
+        if (!options.silent) {
+            console.log(`Converting database ${dataset.database} data into files…`);
+        }
+        const senReorganizedRootDir = path.join(dataDir, dataset.database);
+        const senReorganizedDir = path.join(senReorganizedRootDir, "sens");
+        const circonscriptionsReorganizedDir = path.join(senReorganizedRootDir, "circonscriptions");
+        ensureAndClearDir(senReorganizedRootDir);
+        ensureAndClearDir(senReorganizedDir);
+        ensureAndClearDir(circonscriptionsReorganizedDir);
+        for await (const sen of findAllSens()) {
+            if (options.verbose) {
+                console.log(`Converting ${sen.matricule} file…`);
+            }
+            const senFileName = `${sen.matricule}.json`;
+            fs.writeJSONSync(path.join(senReorganizedDir, senFileName), sen, { spaces: 2 });
+        }
+        for await (const circonscription of findAllCirconscriptions()) {
+            if (options.verbose) {
+                console.log(`Converting ${circonscription.identifiant} file…`);
+            }
+            const circonscriptionFileName = `${circonscription.identifiant}.json`;
+            fs.writeJSONSync(path.join(circonscriptionsReorganizedDir, circonscriptionFileName), circonscription, { spaces: 2 });
+        }
+    }
+    if (!options.silent) {
+        console.timeEnd("conversion time");
+    }
+}
+convertData()
+    .then(() => process.exit(0))
+    .catch((error) => {
+    console.log(error);
+    process.exit(1);
+});

package/lib/scripts/convert_data.ts

@@ -0,0 +1,119 @@
+import assert from "assert"
+import commandLineArgs from "command-line-args"
+import fs from "fs-extra"
+import path from "path"
+
+import { datasets, EnabledDatasets, getEnabledDatasets } from "../datasets"
+import { findAllCirconscriptions, findAllLois, findAllQuestions, findAllSens } from "../model"
+import { formatToFourDigitSession, SIGNET_STRUCTURE_REGEXP, UNDEFINED_SESSION } from "./datautil"
+import { commonOptions } from "./shared/cli_helpers"
+import { ensureAndClearDir } from "./shared/util"
+
+const optionsDefinitions = [
+  ...commonOptions,
+]
+const options = commandLineArgs(optionsDefinitions)
+
+async function convertData() {
+  const enabledDatasets = getEnabledDatasets(options.categories)
+  const dataDir: string = options.dataDir
+  assert(dataDir, "Missing argument: data directory")
+
+  console.time("conversion time")
+
+  if (enabledDatasets & EnabledDatasets.DosLeg) {
+    const dataset = datasets.dosleg
+
+    if (!options.silent) {
+      console.log(`Converting database ${dataset.database} data into files…`)
+    }
+
+    const loiReorganizedRootDir = path.join(dataDir, dataset.database)
+    ensureAndClearDir(loiReorganizedRootDir)
+
+    for await (const loi of findAllLois()) {
+      if (options.verbose) {
+        console.log(`Converting ${loi.signet} file…`)
+      }
+
+      let loiReorganizedDir = path.join(loiReorganizedRootDir, UNDEFINED_SESSION)
+      const signetParts = SIGNET_STRUCTURE_REGEXP.exec(loi.signet)?.groups
+      if (signetParts) {
+        const { session } = signetParts
+        const formattedSession = formatToFourDigitSession(session)
+        loiReorganizedDir = path.join(loiReorganizedRootDir, formattedSession)
+      }
+      fs.ensureDirSync(loiReorganizedDir)
+
+      const loiFileName = `${loi.signet}.json`
+      fs.writeJSONSync(path.join(loiReorganizedDir, loiFileName), loi, {spaces: 2})
+    }
+  }
+
+  if (enabledDatasets & EnabledDatasets.Questions) {
+    const dataset = datasets.questions
+
+    if (!options.silent) {
+      console.log(`Converting database ${dataset.database} data into files…`)
+    }
+
+    const questionReorganizedRootDir = path.join(dataDir, dataset.database)
+    ensureAndClearDir(questionReorganizedRootDir)
+
+    for await (const question of findAllQuestions()) {
+      if (options.verbose) {
+        console.log(`Converting ${question.reference} file…`)
+      }
+
+      const legislature = question.legislature ? question.legislature : 0
+      const questionReorganizedDir = path.join(questionReorganizedRootDir, String(legislature))
+      fs.ensureDirSync(questionReorganizedDir)
+      const questionFileName = `${question.reference}.json`
+      fs.writeJSONSync(path.join(questionReorganizedDir, questionFileName), question, {spaces: 2})
+    }
+  }
+
+  if (enabledDatasets & EnabledDatasets.Sens) {
+    const dataset = datasets.sens
+
+    if (!options.silent) {
+      console.log(`Converting database ${dataset.database} data into files…`)
+    }
+
+    const senReorganizedRootDir = path.join(dataDir, dataset.database)
+    const senReorganizedDir = path.join(senReorganizedRootDir, "sens")
+    const circonscriptionsReorganizedDir = path.join(senReorganizedRootDir, "circonscriptions")
+    ensureAndClearDir(senReorganizedRootDir)
+    ensureAndClearDir(senReorganizedDir)
+    ensureAndClearDir(circonscriptionsReorganizedDir)
+
+    for await (const sen of findAllSens()) {
+      if (options.verbose) {
+        console.log(`Converting ${sen.matricule} file…`)
+      }
+
+      const senFileName = `${sen.matricule}.json`
+      fs.writeJSONSync(path.join(senReorganizedDir, senFileName), sen, {spaces: 2})
+    }
+
+    for await (const circonscription of findAllCirconscriptions()) {
+      if (options.verbose) {
+        console.log(`Converting ${circonscription.identifiant} file…`)
+      }
+
+      const circonscriptionFileName = `${circonscription.identifiant}.json`
+      fs.writeJSONSync(path.join(circonscriptionsReorganizedDir, circonscriptionFileName), circonscription, {spaces: 2})
+    }
+  }
+
+  if (!options.silent) {
+      console.timeEnd("conversion time")
+  }
+}
+
+convertData()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.log(error)
+    process.exit(1)
+  })

package/lib/scripts/data-download.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/data-download.js

@@ -0,0 +1,9 @@
+import { execSync } from "child_process";
+const args = process.argv.slice(2).join(" ");
+try {
+    execSync(`tsx src/scripts/retrieve_open_data.ts --all ${args}`, { stdio: "inherit" });
+    execSync(`tsx src/scripts/convert_data.ts ${args}`, { stdio: "inherit" });
+}
+catch (error) {
+    process.exit(1);
+}

package/lib/scripts/datautil.mjs

@@ -0,0 +1,16 @@
+import { DateTime, Settings } from "luxon";
+Settings.twoDigitCutoffYear = 50;
+export const SIGNET_STRUCTURE_REGEXP = /^(?<type>[a-z]+)(?<session>\d{2,4})-?(?<numTexte>\d+)?/;
+export const AKN_IDENTIFICATION_STRUCTURE_REGEXP = /^\/akn\/fr\/(?<type>[a-z]+)\/(?<session>\d{4}-\d{4})\/?(?<numTexte>\d+)\/fr@(?<version>\b(?:RECT|RECT_BIS|RECT_TER|RECT_QUATER|RECT_QUINQUIES)\b)?/;
+export const AKN_WORKFLOW_IDENTIFICATION_STRUCTURE_REGEXP = /^\/akn\/fr\/(?<type>[a-z]+)\/(?<session>\d{2,4})\/?(?<numTexte>[a-zA-Z0-9]+)\/fr@(?<version>\b(?:RECT|RECT_BIS|RECT_TER|RECT_QUATER|RECT_QUINQUIES)\b)?/;
+export const UNDEFINED_SESSION = "0";
+export function formatToFourDigitSession(session) {
+    if (session.length >= 2) {
+        const sessionFirstTwoDigits = session.substring(0, 2);
+        const sessionLastTwoDigits = session.substring(session.length - 2);
+        const twoDigitSession = parseInt(sessionFirstTwoDigits) === parseInt(sessionLastTwoDigits) - 1 ?
+            sessionFirstTwoDigits : sessionLastTwoDigits;
+        return DateTime.fromFormat(String(twoDigitSession), "yy").toFormat("yyyy");
+    }
+    return UNDEFINED_SESSION;
+}

package/lib/scripts/datautil.ts

@@ -0,0 +1,19 @@
+import { DateTime, Settings } from "luxon"
+
+Settings.twoDigitCutoffYear = 50
+
+export const SIGNET_STRUCTURE_REGEXP = /^(?<type>[a-z]+)(?<session>\d{2,4})-?(?<numTexte>\d+)?/
+export const AKN_IDENTIFICATION_STRUCTURE_REGEXP = /^\/akn\/fr\/(?<type>[a-z]+)\/(?<session>\d{4}-\d{4})\/?(?<numTexte>\d+)\/fr@(?<version>\b(?:RECT|RECT_BIS|RECT_TER|RECT_QUATER|RECT_QUINQUIES)\b)?/
+export const AKN_WORKFLOW_IDENTIFICATION_STRUCTURE_REGEXP = /^\/akn\/fr\/(?<type>[a-z]+)\/(?<session>\d{2,4})\/?(?<numTexte>[a-zA-Z0-9]+)\/fr@(?<version>\b(?:RECT|RECT_BIS|RECT_TER|RECT_QUATER|RECT_QUINQUIES)\b)?/
+export const UNDEFINED_SESSION = "0"
+
+export function formatToFourDigitSession (session: string) {
+  if (session.length >= 2) {
+    const sessionFirstTwoDigits = session.substring(0, 2)
+    const sessionLastTwoDigits = session.substring(session.length - 2)
+    const twoDigitSession = parseInt(sessionFirstTwoDigits) === parseInt(sessionLastTwoDigits) - 1 ?
+      sessionFirstTwoDigits : sessionLastTwoDigits
+    return DateTime.fromFormat(String(twoDigitSession), "yy").toFormat("yyyy")
+  }
+  return UNDEFINED_SESSION
+}

package/lib/scripts/parse_textes.mjs

@@ -0,0 +1,38 @@
+import assert from "assert";
+import commandLineArgs from "command-line-args";
+import fs from "fs-extra";
+import path from "path";
+import { iterFilePaths } from "../loaders";
+import { parseTexteFromFile } from "../model/texte";
+import { commonOptions } from "./shared/cli_helpers";
+import { ensureAndClearDir } from "./shared/util";
+const optionsDefinitions = [
+    ...commonOptions,
+];
+const options = commandLineArgs(optionsDefinitions);
+async function main() {
+    const dataDir = options.dataDir;
+    assert(dataDir, "Missing argument: data directory");
+    const transformedTextesDir = path.join(options.dataDir, "leg", "transformed");
+    ensureAndClearDir(transformedTextesDir);
+    for (const filePath of iterFilePaths(path.join(dataDir, "leg", "original"))) {
+        const parsedFilePath = path.parse(filePath);
+        if (parsedFilePath.ext !== ".xml") {
+            continue;
+        }
+        const texteDirFromOriginal = parsedFilePath.dir.substring(filePath.indexOf("original") + "original".length);
+        const transformedTexteDir = path.join(transformedTextesDir, texteDirFromOriginal);
+        fs.ensureDirSync(transformedTexteDir);
+        if (!options.silent) {
+            console.log(`Parsing texte ${parsedFilePath.name}.xml…`);
+        }
+        const parsedTexte = await parseTexteFromFile(filePath);
+        fs.writeJSONSync(path.join(transformedTexteDir, `${parsedFilePath.name}.json`), parsedTexte, { spaces: 2 });
+    }
+}
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+    console.log(error);
+    process.exit(1);
+});

package/lib/scripts/parse_textes.ts

@@ -0,0 +1,52 @@
+import assert from "assert"
+import commandLineArgs from "command-line-args"
+import fs from "fs-extra"
+import path from "path"
+
+import { iterFilePaths } from "../loaders"
+import { parseTexteFromFile } from "../model/texte"
+import { commonOptions } from "./shared/cli_helpers"
+import { ensureAndClearDir } from "./shared/util"
+
+const optionsDefinitions = [
+  ...commonOptions,
+]
+const options = commandLineArgs(optionsDefinitions)
+
+async function main() {
+  const dataDir = options.dataDir
+  assert(dataDir, "Missing argument: data directory")
+
+  const transformedTextesDir = path.join(options.dataDir, "leg", "transformed")
+  ensureAndClearDir(transformedTextesDir)
+
+  for (const filePath of iterFilePaths(path.join(dataDir, "leg", "original"))) {
+    const parsedFilePath = path.parse(filePath)
+
+    if (parsedFilePath.ext !== ".xml") {
+      continue
+    }
+
+    const texteDirFromOriginal = parsedFilePath.dir.substring(filePath.indexOf("original") + "original".length)
+    const transformedTexteDir = path.join(transformedTextesDir, texteDirFromOriginal)
+    fs.ensureDirSync(transformedTexteDir)
+
+    if (!options.silent) {
+      console.log(`Parsing texte ${parsedFilePath.name}.xml…`)
+    }
+
+    const parsedTexte = await parseTexteFromFile(filePath)
+    fs.writeJSONSync(
+      path.join(transformedTexteDir, `${parsedFilePath.name}.json`),
+      parsedTexte,
+      { spaces: 2 }
+    )
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.log(error)
+    process.exit(1)
+  })

package/lib/scripts/retrieve_documents.mjs

@@ -0,0 +1,243 @@
+import assert from "assert";
+import commandLineArgs from "command-line-args";
+import fs from "fs-extra";
+import path from "path";
+import { findSenatRapportUrls, findSenatTexteUrls } from "../model/dosleg";
+import { parseTexte, parseTexteFromFile } from "../model/texte";
+import { UNDEFINED_SESSION } from "./datautil";
+import { commonOptions } from "./shared/cli_helpers";
+import { ensureAndClearDir, fetchWithRetry, isOptionEmptyOrHasValue } from "./shared/util";
+const optionsDefinitions = [
+    ...commonOptions,
+    {
+        help: "sessions of textes to retrieve; leave empty for all",
+        multiple: true,
+        name: "sessions",
+        type: String,
+    },
+    {
+        help: "parse and convert documents into JSON (textes only for now, requires format xml)",
+        name: "parseDocuments",
+        type: Boolean,
+    },
+    {
+        alias: "F",
+        help: "formats of documents to retrieve (xml/html/pdf for textes, html/pdf for rapports); leave empty for all",
+        multiple: true,
+        name: "formats",
+        type: String,
+    },
+    {
+        help: "types of documents to retrieve (textes/rapports); leave empty for all",
+        multiple: true,
+        name: "types",
+        type: String,
+    },
+    {
+        help: "force retrieve all documents, even already retrieved ones",
+        name: "force",
+        type: Boolean,
+    },
+];
+const options = commandLineArgs(optionsDefinitions);
+const SENAT_TEXTE_XML_BASE_URL = "https://www.senat.fr/akomantoso/";
+const SENAT_TEXTE_BASE_URL = "https://www.senat.fr/leg/";
+const SENAT_RAPPORT_BASE_URL = "https://www.senat.fr/rap/";
+const textDecoder = new TextDecoder("utf8");
+async function retrieveDocument(documentUrl) {
+    if (!options.silent) {
+        console.log(`Retrieving document ${documentUrl}…`);
+    }
+    try {
+        const response = await fetchWithRetry(documentUrl);
+        if (!response.ok) {
+            if (response.status === 404) {
+                console.warn(`Texte ${documentUrl} not found`);
+            }
+            else {
+                console.error(`An error occurred while retrieving texte ${documentUrl}: ${response.status}`);
+            }
+            return null;
+        }
+        return response.arrayBuffer();
+    }
+    catch (error) {
+        console.error(error.message);
+        return null;
+    }
+}
+async function retrieveTextes(dataDir) {
+    const textesDir = path.join(dataDir, "leg");
+    fs.ensureDirSync(textesDir);
+    const originalTextesDir = path.join(textesDir, "original");
+    const transformedTextesDir = path.join(textesDir, "transformed");
+    ensureAndClearDir(transformedTextesDir);
+    let retrievedTextesCount = 0;
+    const texteUrlsNotFoundOrError = [];
+    const texteUrlsParseError = [];
+    for await (const texte of findSenatTexteUrls(options.sessions)) {
+        const texteName = path.parse(texte.url).name;
+        const texteDir = path.join(originalTextesDir, `${texte.session ?? UNDEFINED_SESSION}`, texteName);
+        fs.ensureDirSync(texteDir);
+        if (isOptionEmptyOrHasValue(options.formats, "xml")) {
+            const texteXmlUrl = `${texteName}.akn.xml`;
+            const texteXmlAbsoluteUrl = new URL(texteXmlUrl, SENAT_TEXTE_XML_BASE_URL).toString();
+            const textePath = path.join(texteDir, texteXmlUrl);
+            let texteBuffer = null;
+            if (!options.force && fs.existsSync(textePath)) {
+                if (!options.silent) {
+                    console.info(`Already retrieved texte ${textePath}…`);
+                }
+            }
+            else {
+                texteBuffer = await retrieveDocument(texteXmlAbsoluteUrl);
+                if (!texteBuffer) {
+                    texteUrlsNotFoundOrError.push(texteXmlAbsoluteUrl);
+                    continue;
+                }
+                fs.writeFileSync(textePath, Buffer.from(texteBuffer));
+                retrievedTextesCount++;
+            }
+            if (options.parseDocuments) {
+                if (!options.silent) {
+                    console.log(`Parsing texte ${texteXmlUrl}…`);
+                }
+                let parsedTexte = null;
+                if (texteBuffer) {
+                    const texteXml = textDecoder.decode(texteBuffer);
+                    parsedTexte = parseTexte(texteXml);
+                }
+                else {
+                    parsedTexte = await parseTexteFromFile(textePath);
+                }
+                if (!parsedTexte) {
+                    texteUrlsParseError.push(texteXmlAbsoluteUrl);
+                    continue;
+                }
+                const transformedTexteDir = path.join(transformedTextesDir, `${texte.session ?? UNDEFINED_SESSION}`, texteName);
+                fs.ensureDirSync(transformedTexteDir);
+                fs.writeJSONSync(path.join(transformedTexteDir, `${texteName}.akn.json`), parsedTexte, { spaces: 2 });
+            }
+        }
+        if (isOptionEmptyOrHasValue(options.formats, "html")) {
+            const texteHtmlUrl = `${texteName}.html`;
+            const texteHtmlAbsoluteUrl = new URL(texteHtmlUrl, SENAT_TEXTE_BASE_URL).toString();
+            const textePath = path.join(texteDir, texteHtmlUrl);
+            if (!options.force && fs.existsSync(textePath)) {
+                if (!options.silent) {
+                    console.info(`Already retrieved texte ${textePath}…`);
+                }
+                continue;
+            }
+            const texteBuffer = await retrieveDocument(texteHtmlAbsoluteUrl);
+            if (!texteBuffer) {
+                texteUrlsNotFoundOrError.push(texteHtmlAbsoluteUrl);
+                continue;
+            }
+            fs.writeFileSync(textePath, Buffer.from(texteBuffer));
+            retrievedTextesCount++;
+        }
+        if (isOptionEmptyOrHasValue(options.formats, "pdf")) {
+            const textePdfUrl = `${texteName}.pdf`;
+            const textePdfAbsoluteUrl = new URL(textePdfUrl, SENAT_TEXTE_BASE_URL).toString();
+            const textePath = path.join(texteDir, textePdfUrl);
+            if (!options.force && fs.existsSync(textePath)) {
+                if (!options.silent) {
+                    console.info(`Already retrieved texte ${textePath}…`);
+                }
+                continue;
+            }
+            const texteBuffer = await retrieveDocument(textePdfAbsoluteUrl);
+            if (!texteBuffer) {
+                texteUrlsNotFoundOrError.push(textePdfAbsoluteUrl);
+                continue;
+            }
+            fs.writeFileSync(textePath, Buffer.from(texteBuffer));
+            retrievedTextesCount++;
+        }
+    }
+    if (options.verbose) {
+        console.log(`${retrievedTextesCount} textes retrieved`);
+        console.log(`${texteUrlsNotFoundOrError.length} textes failed to be retrieved with URLs ${texteUrlsNotFoundOrError.join(", ")}`);
+        if (options.parseDocuments) {
+            console.log(`${texteUrlsParseError.length} textes failed to be parsed with URLs ${texteUrlsParseError.join(", ")}`);
+        }
+    }
+    // TODO retrieve exposé des motifs (/leg/exposes-des-motifs)
+}
+async function retrieveRapports(dataDir) {
+    const rapportsDir = path.join(dataDir, "rap");
+    fs.ensureDirSync(rapportsDir);
+    let retrievedRapportsCount = 0;
+    const rapportUrlsNotFoundOrError = [];
+    for await (const rapport of findSenatRapportUrls(options.sessions)) {
+        const parsedRapportUrl = path.parse(rapport.url);
+        const rapportName = parsedRapportUrl.name;
+        const rapportDir = path.join(rapportsDir, `${rapport.session ?? UNDEFINED_SESSION}`, rapportName);
+        fs.ensureDirSync(rapportDir);
+        if (isOptionEmptyOrHasValue(options.formats, "html")) {
+            const rapportHtmlUrlBase = `${rapportName}_mono.html`;
+            const rapportHtmlUrl = path.format({
+                dir: parsedRapportUrl.dir,
+                base: rapportHtmlUrlBase,
+            });
+            const rapportHtmlAbsoluteUrl = new URL(rapportHtmlUrl, SENAT_RAPPORT_BASE_URL).toString();
+            const rapportPath = path.join(rapportDir, rapportHtmlUrlBase);
+            if (!options.force && fs.existsSync(rapportPath)) {
+                if (!options.silent) {
+                    console.info(`Already retrieved rapport ${rapportPath}…`);
+                }
+                continue;
+            }
+            const rapportBuffer = await retrieveDocument(rapportHtmlAbsoluteUrl);
+            if (!rapportBuffer) {
+                rapportUrlsNotFoundOrError.push(rapportHtmlAbsoluteUrl);
+                continue;
+            }
+            fs.writeFileSync(rapportPath, Buffer.from(rapportBuffer));
+            retrievedRapportsCount++;
+        }
+        if (isOptionEmptyOrHasValue(options.formats, "pdf")) {
+            const rapportPdfUrlBase = `${rapportName}1.pdf`;
+            const rapportPdfUrl = path.format({
+                dir: parsedRapportUrl.dir,
+                base: rapportPdfUrlBase,
+            });
+            const rapportPdfAbsoluteUrl = new URL(rapportPdfUrl, SENAT_RAPPORT_BASE_URL).toString();
+            const rapportPath = path.join(rapportDir, rapportPdfUrlBase);
+            if (!options.force && fs.existsSync(rapportPath)) {
+                if (!options.silent) {
+                    console.info(`Already retrieved rapport ${rapportPath}…`);
+                }
+                continue;
+            }
+            const rapportBuffer = await retrieveDocument(rapportPdfAbsoluteUrl);
+            if (!rapportBuffer) {
+                rapportUrlsNotFoundOrError.push(rapportPdfAbsoluteUrl);
+                continue;
+            }
+            fs.writeFileSync(rapportPath, Buffer.from(rapportBuffer));
+            retrievedRapportsCount++;
+        }
+    }
+    if (options.verbose) {
+        console.log(`${retrievedRapportsCount} rapports retrieved`);
+        console.log(`${rapportUrlsNotFoundOrError.length} rapports failed with URLs ${rapportUrlsNotFoundOrError.join(", ")}`);
+    }
+}
+async function main() {
+    const dataDir = options.dataDir;
+    assert(dataDir, "Missing argument: data directory");
+    if (isOptionEmptyOrHasValue(options.types, "textes")) {
+        await retrieveTextes(dataDir);
+    }
+    if (isOptionEmptyOrHasValue(options.types, "rapports")) {
+        await retrieveRapports(dataDir);
+    }
+}
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+    console.log(error);
+    process.exit(1);
+});