.gitignore

+__pycache__/
 bin/
 lib/
+lib64
 data/
 pyvenv.cfg
-output.log
+output_*.log
+*.patch
+CACHEDIR.TAG

.gitlab-ci.yml

-image: debian:bookworm
-
 variables:
   DEBIAN_FRONTEND: noninteractive
+  IMAGE_NAME:      $CI_REGISTRY_IMAGE/base
+
+stages:
+  - docker
+  - install
+  - lint
+  - test
 
-build:
+docker:
+  stage: docker
+  tags:
+    - dind
+  variables:
+    DOCKER_DRIVER:      "overlay2"
+    DOCKER_TLS_CERTDIR: "/certs"
+  services:
+    - docker:20.10.17-dind
   before_script:
-  - apt-get update && apt-get install --no-install-recommends -y python3 python3-pip python3-selenium python3-virtualenv chromium-driver make xauth xvfb tesseract-ocr tesseract-ocr-eng tesseract-ocr-fra ocrmypdf
-  - ln -s /usr/bin/python3 /usr/bin/python
+  - docker info
+  - docker login -u ${CI_REGISTRY_USER} -p ${CI_REGISTRY_PASSWORD} ${CI_REGISTRY}
+  script:
+  - docker build -t ${IMAGE_NAME}:latest -f Dockerfile-base .
+  - docker push ${IMAGE_NAME}:latest
+  image: docker:20.10.17
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE != "schedule"
+      changes:
+        paths:
+        - Dockerfile-base
+    - if: $COMPILE_DOCKER
+
+install:
+  stage: install
+  image: registry.git.laquadrature.net/la-quadrature-du-net/attrap/base:latest
+  tags:
+  - unprivileged
+  script:
   - virtualenv --python=/usr/bin/python3 .
   - source bin/activate
   - pip3 install -r requirements.txt
+  cache:
+    key: $CI_COMMIT_REF_SLUG
+    paths:
+    - bin/
+    - lib/
+    - pyvenv.cfg
+  rules:
+    - if: $COMPILE_DOCKER == null
+
+pep8:
+  stage: lint
+  image: registry.git.laquadrature.net/la-quadrature-du-net/attrap/base:latest
+  needs: [install]
+  tags:
+    - unprivileged
+  cache:
+    key: $CI_COMMIT_REF_SLUG
+    paths:
+    - bin/
+    - lib/
+    - pyvenv.cfg
+  script:
+    - make lint
+  allow_failure: true
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
+
+.default_pref:
+  stage: test
+  image: registry.git.laquadrature.net/la-quadrature-du-net/attrap/base:latest
+  tags:
+  - unprivileged
+  needs: [install]
   script:
+  - misc/download-from-s3.sh "${PREF}" "${S3_KEY}" "${S3_SECRET}" "${S3_HOST}" "${S3_BUCKET}" data/ || true
   - source bin/activate
-  - make
-  only:
-  - main
+  - /etc/init.d/tor start
+  - make "${PREF}"
+  - misc/upload-to-s3.sh "${PREF}" "${S3_KEY}" "${S3_SECRET}" "${S3_HOST}" "${S3_BUCKET}" data/ || true
   cache:
     key: $CI_COMMIT_REF_SLUG
     paths:
-      - data/
+    - bin/
+    - lib/
+    - pyvenv.cfg
   artifacts:
     paths:
-    - output.log
-    expire_in: 1 year
+    - data/${PREF}/raa/*.txt
+    - data/${PREF}/raa/*.json
+    - output_${PREF}.log
+    expire_in: 2 days
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule" && $COMPILE_DOCKER == null
+
+test_ppparis:
+  variables:
+    PREF: "ppparis"
+  extends: .default_pref
+
+test_pref01:
+  variables:
+    PREF: "pref01"
+  extends: .default_pref
+
+test_pref02:
+  variables:
+    PREF: "pref02"
+  extends: .default_pref
+
+test_pref03:
+  variables:
+    PREF: "pref03"
+  extends: .default_pref
+
+test_pref04:
+  variables:
+    PREF: "pref04"
+  extends: .default_pref
+
+test_pref05:
+  variables:
+    PREF: "pref05"
+  extends: .default_pref
+
+test_pref06:
+  variables:
+    PREF: "pref06"
+  extends: .default_pref
+
+test_pref09:
+  variables:
+    PREF: "pref09"
+  extends: .default_pref
+
+test_pref10:
+  variables:
+    PREF: "pref10"
+  extends: .default_pref
+
+test_pref11:
+  variables:
+    PREF: "pref11"
+  extends: .default_pref
+
+test_pref13:
+  variables:
+    PREF: "pref13"
+  extends: .default_pref
+
+test_pref2a:
+  variables:
+    PREF: "pref2a"
+  extends: .default_pref
+
+test_pref2b:
+  variables:
+    PREF: "pref2b"
+  extends: .default_pref
+
+test_pref25:
+  variables:
+    PREF: "pref25"
+  extends: .default_pref
+
+test_pref29:
+  variables:
+    PREF: "pref29"
+  extends: .default_pref
+
+test_pref30:
+  variables:
+    PREF: "pref30"
+  extends: .default_pref
+
+test_pref31:
+  variables:
+    PREF: "pref31"
+  extends: .default_pref
+
+test_pref33:
+  variables:
+    PREF: "pref33"
+  extends: .default_pref
+
+test_pref34:
+  variables:
+    PREF: "pref34"
+  extends: .default_pref
+
+test_pref35:
+  variables:
+    PREF: "pref35"
+  extends: .default_pref
+
+test_pref38:
+  variables:
+    PREF: "pref38"
+  extends: .default_pref
+
+test_pref39:
+  variables:
+    PREF: "pref39"
+  extends: .default_pref
+
+test_pref42:
+  variables:
+    PREF: "pref42"
+  extends: .default_pref
+
+test_pref44:
+  variables:
+    PREF: "pref44"
+  extends: .default_pref
+
+test_pref49:
+  variables:
+    PREF: "pref49"
+  extends: .default_pref
+
+test_pref50:
+  variables:
+    PREF: "pref50"
+  extends: .default_pref
+
+test_pref52:
+  variables:
+    PREF: "pref52"
+  extends: .default_pref
+
+test_pref54:
+  variables:
+    PREF: "pref54"
+  extends: .default_pref
+
+test_pref55:
+  variables:
+    PREF: "pref55"
+  extends: .default_pref
+
+test_pref59:
+  variables:
+    PREF: "pref59"
+  extends: .default_pref
+
+test_pref61:
+  variables:
+    PREF: "pref61"
+  extends: .default_pref
+
+test_pref62:
+  variables:
+    PREF: "pref62"
+  extends: .default_pref
+
+test_pref63:
+  variables:
+    PREF: "pref63"
+  extends: .default_pref
+
+test_pref64:
+  variables:
+    PREF: "pref64"
+  extends: .default_pref
+
+test_pref65:
+  variables:
+    PREF: "pref65"
+  extends: .default_pref
+
+test_pref66:
+  variables:
+    PREF: "pref66"
+  extends: .default_pref
+
+test_pref69:
+  variables:
+    PREF: "pref69"
+  extends: .default_pref
+
+test_pref73:
+  variables:
+    PREF: "pref73"
+  extends: .default_pref
+
+test_pref75:
+  variables:
+    PREF: "pref75"
+  extends: .default_pref
+
+test_pref76:
+  variables:
+    PREF: "pref76"
+  extends: .default_pref
+
+test_pref77:
+  variables:
+    PREF: "pref77"
+  extends: .default_pref
+
+test_pref80:
+  variables:
+    PREF: "pref80"
+  extends: .default_pref
+
+test_pref81:
+  variables:
+    PREF: "pref81"
+  extends: .default_pref
+
+test_pref83:
+  variables:
+    PREF: "pref83"
+  extends: .default_pref
+
+test_pref87:
+  variables:
+    PREF: "pref87"
+  extends: .default_pref
+
+test_pref91:
+  variables:
+    PREF: "pref91"
+  extends: .default_pref
+
+test_pref92:
+  variables:
+    PREF: "pref92"
+  extends: .default_pref
+
+test_pref93:
+  variables:
+    PREF: "pref93"
+  extends: .default_pref
+
+test_pref94:
+  variables:
+    PREF: "pref94"
+  extends: .default_pref
+
+test_pref976:
+  variables:
+    PREF: "pref976"
+  extends: .default_pref
+
+test_prefbretagne:
+  variables:
+    PREF: "prefbretagne"
+  extends: .default_pref
+
+test_prefidf:
+  variables:
+    PREF: "prefidf"
+  extends: .default_pref
+
+test_prefpaca:
+  variables:
+    PREF: "prefpaca"
+  extends: .default_pref

Attrap.py

+import os
+import sys
+import re
+import random
+import ssl
+import subprocess
+import shutil
+import string
+import logging
+import requests
+import time
+from types import SimpleNamespace
+import datetime
+import json
+from urllib.parse import quote
+
+from selenium import webdriver
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.wait import WebDriverWait
+from selenium.webdriver.support import expected_conditions
+
+import pytz
+import dateparser
+import urllib3
+
+from bs4 import BeautifulSoup
+from pyvirtualdisplay import Display
+
+from pypdf import PdfReader
+from pypdf import PdfWriter
+from pypdf.generic import NameObject, NumberObject
+from pypdf.errors import PdfStreamError
+from pypdf.errors import EmptyFileError
+
+import hashlib
+import smtplib
+import email
+
+from mastodon import Mastodon
+
+import ftfy
+
+logger = logging.getLogger(__name__)
+
+
+class Attrap:
+    class RAA:
+        """La classe représentant un Recueil des actes administratifs. La plupart du temps, il s'agit d'un PDF avec plusieurs arrêtés."""
+
+        url = ""
+        date = None
+        name = ""
+        sha256 = ""
+        pdf_creation_date = None
+        pdf_modification_date = None
+
+        def __init__(self, url, date, name, timezone='Europe/Paris'):
+            self.timezone = timezone
+            if not url == "":
+                self.url = url
+            if date is not None:
+                self.date = Attrap.get_aware_datetime(date, timezone=timezone)
+            if not name == "":
+                self.name = name
+
+        def get_sha256(self):
+            """Calcule et met en cache le hash sha256 de l'URL du PDF, pour servir d'identifiant unique."""
+            if (self.sha256 == ""):
+                self.sha256 = hashlib.sha256(self.url.encode('utf-8')).hexdigest()
+            return self.sha256
+
+        def get_pdf_dates(self, data_dir):
+            """Extrait les dates des PDF pour les ajouter à l'objet du RAA."""
+            raa_data_dir = f'{data_dir}/raa/'
+
+            reader = PdfReader(f'{raa_data_dir}{self.get_sha256()}.pdf')
+            pdf_metadata = reader.metadata
+
+            if pdf_metadata:
+                if pdf_metadata.creation_date:
+                    self.pdf_creation_date = Attrap.get_aware_datetime(pdf_metadata.creation_date, timezone=self.timezone)
+                    if self.date is None:
+                        self.date = Attrap.get_aware_datetime(pdf_metadata.creation_date, timezone=self.timezone)
+
+                if pdf_metadata.modification_date:
+                    self.pdf_modification_date = Attrap.get_aware_datetime(pdf_metadata.modification_date, timezone=self.timezone)
+                    if self.date is None:
+                        self.date = Attrap.get_aware_datetime(pdf_metadata.modification_date, timezone=self.timezone)
+
+        def extract_content(self, data_dir):
+            """Extrait le contenu du PDF OCRisé pour l'écrire dans le fichier qui servira à faire la recherche de mots-clés. Supprime tous les PDF à la fin."""
+            raa_data_dir = f'{data_dir}/raa/'
+
+            text = ""
+
+            reader = PdfReader(f'{raa_data_dir}{self.get_sha256()}.ocr.pdf')
+            ftfy_config = ftfy.TextFixerConfig(unescape_html=False, explain=False)
+            for page in reader.pages:
+                try:
+                    text = text + "\n" + ftfy.fix_text(page.extract_text(), config=ftfy_config)
+                except Exception as exc:
+                    logger.warning(f'ATTENTION: Impossible d\'extraire le texte du fichier {self.get_sha256()}.pdf : {exc}')
+
+            # Écrit le texte du PDF dans un fichier texte pour une analyse future
+            f = open(f'{raa_data_dir}{self.get_sha256()}.txt', 'w')
+            f.write(text)
+            f.close()
+
+            # Supprime le PDF d'origine et la version OCRisée
+            os.remove(f'{raa_data_dir}{self.get_sha256()}.pdf')
+            os.remove(f'{raa_data_dir}{self.get_sha256()}.ocr.pdf')
+            os.remove(f'{raa_data_dir}{self.get_sha256()}.flat.pdf')
+
+        def write_properties(self, data_dir):
+            """Écris les propriétés du RAA dans un fichier JSON."""
+            raa_data_dir = f'{data_dir}/raa/'
+
+            pdf_creation_date_json = None
+            pdf_modification_date_json = None
+
+            if self.pdf_creation_date:
+                pdf_creation_date_json = self.pdf_creation_date.astimezone(pytz.utc).isoformat(timespec="seconds")
+            if self.pdf_modification_date:
+                pdf_modification_date_json = self.pdf_modification_date.astimezone(pytz.utc).isoformat(timespec="seconds")
+
+            properties = {
+                'version': 2,
+                'name': self.name,
+                'date': self.date.strftime("%Y-%m-%d"),
+                'url': quote(self.url, safe='/:'),
+                'first_seen_on': datetime.datetime.now(pytz.utc).isoformat(timespec="seconds"),
+                'pdf_creation_date': pdf_creation_date_json,
+                'pdf_modification_date': pdf_modification_date_json,
+                'timezone': self.timezone
+            }
+            f = open(f'{raa_data_dir}{self.get_sha256()}.json', 'w')
+            f.write(json.dumps(properties))
+            f.close()
+
+        def parse_metadata(self, data_dir):
+            """Lance l'extraction des dates du PDF puis l'écriture de ses propriétés dans un fichier JSON."""
+            self.get_pdf_dates(data_dir)
+            self.write_properties(data_dir)
+
+    def __init__(self, data_dir, user_agent=''):
+        """
+        Initialise Attrap et le dossier de données.
+        data_dir -- le dossier où sont situées les données
+        user_agent -- le user_agent utilisé pour les requêtes
+        """
+        logger.debug('Initialisation de Attrap')
+
+        # On crée le dossier de téléchargement
+        os.makedirs(data_dir, exist_ok=True)
+
+        self.session = requests.Session()
+        self.data_dir = data_dir
+        self.found = False
+        self.output_file_path = os.path.dirname(os.path.abspath(__file__)) + f'/output_{self.short_code}.log'
+        self.sleep_time = 0
+        self.last_http_request = 0
+        self.tor_enabled = False
+        self.tor_max_requests = 0
+        self.tor_requests = 0
+        self.tor_socks5_key = None
+        self.not_before = datetime.datetime(2024, 1, 1)
+        self.smtp_configured = False
+        self.mastodon = None
+        self.mastodon_prefix = ''
+        self.mastodon_suffix = ''
+        self.safe_mode = False
+        self.timezone = datetime.datetime.now(datetime.timezone.utc).astimezone().tzname()
+
+        self.update_user_agent(user_agent)
+
+        f = open(self.output_file_path, 'w')
+        f.write('')
+        f.close()
+
+        self.print_output(str(self.__class__.__name__))
+
+        # Si le safe mode est activé, on configure un long délai entre chaque requête
+        if os.getenv('SAFE_MODE'):
+            self.safe_mode = True
+            logger.warning('ATTENTION: le safe mode est activé, configuration d\'un délai entre chaque requête')
+            self.sleep_time = 30
+
+    def configure_mastodon(self, access_token, instance, mastodon_prefix, mastodon_suffix):
+        """Configuration de Mastodon afin de publier un toot à chaque RAA détecté."""
+        if access_token and access_token != "" and instance and instance != "":
+            self.mastodon = Mastodon(
+                access_token=access_token,
+                api_base_url=instance
+            )
+            self.mastodon_prefix = mastodon_prefix
+            self.mastodon_suffix = mastodon_suffix
+
+    def mastodon_toot(self, content):
+        """Publie le toot en ajoutant le header et footer configurés."""
+        if self.mastodon:
+            toot = content
+            if not self.mastodon_prefix == '':
+                toot = f"{self.mastodon_prefix}\n\n{toot}"
+            if not self.mastodon_suffix == '':
+                toot = f"{toot}\n\n{self.mastodon_suffix}"
+            self.mastodon.toot(toot)
+
+    def enable_tor(self, max_requests=0):
+        """Active l'utilisation de Tor pour effectuer les requêtes."""
+        if not self.safe_mode:
+            self.tor_enabled = True
+            self.tor_max_requests = max_requests
+            self.tor_get_new_id()
+        else:
+            logger.warning('ATTENTION: le safe mode est activé, Tor n\'a pas été activé')
+
+    def disable_tor(self):
+        """Désactive l'utilisation de Tor."""
+        proxies = {}
+        self.tor_enabled = False
+        self.tor_max_requests = 0
+        self.tor_requests = 0
+        self.session.proxies.update(proxies)
+
+    def tor_get_new_id(self):
+        """Change de circuit Tor. Cela permet de changer de noeud de sortie donc d'IP."""
+        if self.tor_enabled:
+            self.tor_socks5_key = 'attrap_' + ''.join(random.choices(string.ascii_lowercase, k=20))
+            proxies = {
+                "http": f"socks5h://attrap:{self.tor_socks5_key}@127.0.0.1:9050",
+                "https": f"socks5h://attrap:{self.tor_socks5_key}@127.0.0.1:9050",
+            }
+            self.session.proxies.update(proxies)
+            self.tor_requests = 0
+
+    def get_sub_pages(self, page_content, element, host, recursive_until_pdf, selenium=False):
+        """
+        Récupère, à partir d'un chemin CSS, les sous-pages d'une page.
+
+        page_content -- Un contenu HTML à analyser
+        element -- Le chemin CSS vers l'objet renvoyant vers la sous-page recherchée
+        host -- Le nom d'hôte du site
+        recursive_until_pdf -- Un booléen pour savoir s'il faut rechercher un fichier PDF dans le chemin CSS. Le cas échéant, relance la recherche sur la sous-page si le lien n'est pas un PDF.
+        selenium -- lance un navigateur avec Selenium pour contourner les protections anti-robots
+        """
+        soup = BeautifulSoup(page_content, 'html.parser')
+        sub_pages = []
+        for a in soup.select(element):
+            if a.get('href'):
+                url = f"{host}{a['href']}"
+                if recursive_until_pdf:
+                    sub_page_content = self.get_page(url, 'get').content
+                    if not self.has_pdf(sub_page_content):
+                        logger.info(
+                            f'{url} ne contient pas de PDF, on récupère ses sous-pages'
+                        )
+                        for sub_sub_page in self.get_sub_pages(
+                            sub_page_content,
+                            element,
+                            host,
+                            recursive_until_pdf,
+                            selenium=selenium
+                        ):
+                            sub_pages.append(sub_sub_page)
+                    else:
+                        sub_page = {
+                            'url': url,
+                            'name': a.get_text().strip()
+                        }
+                        sub_pages.append(sub_page)
+                else:
+                    sub_page = {
+                        'url': url,
+                        'name': a.get_text().strip()
+                    }
+                    sub_pages.append(sub_page)
+        return sub_pages
+
+    def get_sub_pages_with_pager(self, page, sub_page_element, pager_element, details_element, host, selenium=False):
+        """
+        Récupère, à partir d'un chemin CSS, les sous-pages d'une page contenant un pager.
+
+        page -- L'URL ou le contenu HTML de la page à analyser
+        sub_page_element -- Le chemin CSS vers l'objet renvoyant vers la sous-page recherchée
+        pager_element -- Le chemin CSS vers le lien de page suivante du pager
+        details_element -- Le chemin CSS vers l'objet contenant les détails de la sous-page recherchée
+        host -- Le nom d'hôte du site
+        selenium -- lance un navigateur avec Selenium pour contourner les protections anti-robots
+        """
+        pages = []
+        if isinstance(page, bytes):
+            page = page.decode('utf-8')
+        if page.startswith('https://') or page.startswith('http://'):
+            page_content = self.get_page(page, 'get', selenium=selenium).content
+        else:
+            page_content = page
+
+        # On initialise le parser
+        soup = BeautifulSoup(page_content, 'html.parser')
+
+        # On recherche les sous-pages
+        sub_pages = soup.select(sub_page_element)
+        sub_pages_details = None
+        if details_element is not None:
+            sub_pages_details = soup.select(details_element)
+        i = 0
+        for sub_page in sub_pages:
+            if sub_page.get('href'):
+                page = {
+                    'url': f"{host}{sub_page['href']}",
+                    'name': sub_page.get_text().strip(),
+                    'details': ''
+                }
+                if details_element is not None:
+                    page['details'] = sub_pages_details[i].get_text().strip()
+                pages.append(page)
+                i = i + 1
+
+        # On recherche un pager, et si on le trouve on le suit
+        pager = soup.select(pager_element)
+        if pager and pager[0] and pager[0].get('href'):
+            for sub_page in self.get_sub_pages_with_pager(
+                f"{host}{pager[0]['href']}",
+                sub_page_element,
+                pager_element,
+                details_element,
+                host,
+                selenium=selenium
+            ):
+                pages.append(sub_page)
+
+        return pages
+
+    def get_raa_with_pager(self, pages_list, pager_element, host, filter_from_last_element_date=False, selenium=False):
+        """
+        Récupère et analyse les RAA d'une page contenant un pager.
+
+        pages_list -- Un tableau contenant la liste des pages
+        pager_element -- Le chemin CSS vers le lien de page suivante du pager
+        host -- Le nom d'hôte du site
+        filter_from_last_element_date -- (Optionnel) Si la date du dernier élément de la dernière page parsée
+        n'est pas dans la plage temporelle voulue, ne charge pas les pages suivantes. Par défaut à False. Ne doit
+        être activé que si l'ordre des éléments est chronologique.
+        selenium -- lance un navigateur avec Selenium pour contourner les protections anti-robots
+        """
+        elements = []
+        # On parse chaque page passée en paramètre
+        for page in pages_list:
+            page_content = self.get_page(page, 'get', selenium=selenium).content
+
+            # Pour chaque page, on récupère les PDF
+            for raa in self.get_raa_elements(page_content):
+                elements.append(raa)
+
+            # Si la date du dernier RAA est dans la plage temporelle voulue,
+            # on regarde également s'il n'y aurait pas un pager
+            if not filter_from_last_element_date or (filter_from_last_element_date and (elements[-1].date >= Attrap.get_aware_datetime(self.not_before, timezone=self.timezone))):
+                sub_pages = []
+                for sub_page in self.get_sub_pages(
+                    page_content,
+                    pager_element,
+                    host,
+                    True
+                ):
+                    sub_pages.append(sub_page['url'])
+                for sub_raa in self.get_raa_with_pager(
+                    sub_pages,
+                    pager_element,
+                    host,
+                    filter_from_last_element_date=filter_from_last_element_date
+                ):
+                    elements.append(sub_raa)
+        return elements
+
+    def set_sleep_time(self, sleep_time):
+        """Configure le temps de temporisation"""
+        self.sleep_time = sleep_time
+
+    def has_pdf(self, page_content):
+        """
+        Renvoie un booléen Vrai si la page contient un lien vers un PDF
+
+        page_content -- Un contenu HTML à analyser
+        """
+        elements = []
+        soup = BeautifulSoup(page_content, 'html.parser')
+        for a in soup.find_all('a', href=True):
+            if a['href'].endswith('.pdf'):
+                return True
+        return False
+
+    # On démarre le navigateur
+    def get_session(self, url, wait_element, remaining_retries=0):
+        """
+        Lance un navigateur avec Selenium.
+
+        url -- URL à interroger
+        wait_element -- Élement (désigné par son identifiant CSS) qui indique que la page est chargée
+        remaining_retries -- Nombre d'échecs autorisé avant de soulever une erreur
+        """
+        webdriver_options = webdriver.ChromeOptions()
+        webdriver_options.add_argument("--no-sandbox")
+        webdriver_options.add_argument("--disable-extensions")
+        webdriver_options.add_argument("--disable-gpu")
+        webdriver_options.add_argument("--disable-dev-shm-usage")
+        webdriver_options.add_argument("--use_subprocess")
+        webdriver_options.add_argument("--disable-blink-features=AutomationControlled")
+        webdriver_options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        webdriver_options.add_experimental_option('useAutomationExtension', False)
+
+        if not self.user_agent == "":
+            webdriver_options.add_argument(f"--user-agent={self.user_agent}")
+
+        if self.tor_enabled:
+            webdriver_options.add_argument(f'--proxy-server=socks5://127.0.0.1:9050')
+
+        webdriver_options.add_argument("--headless=new")
+        webdriver_options.add_argument("--start-maximized")
+        display = Display(visible=False, size=(1024, 768))
+        display.start()
+
+        browser = webdriver.Chrome(options=webdriver_options)
+
+        # Téléchargement de l'URL
+        browser.get(url)
+
+        if wait_element is not None:
+            # On attend que le navigateur ait passé les tests anti-robots et
+            # que le contenu s'affiche
+            try:
+                WebDriverWait(browser, 60).until(
+                    expected_conditions.presence_of_element_located(
+                        (
+                            By.ID,
+                            wait_element
+                        )
+                    )
+                )
+            except TimeoutException as exc:
+                logger.warning(f'TimeoutException: {exc}')
+                if remaining_retries > 0:
+                    time.sleep(5)
+                    if self.tor_enabled:
+                        self.tor_get_new_id()
+                    return self.get_session(url, wait_element, (remaining_retries - 1))
+                else:
+                    raise TimeoutException(exc)
+
+        page_content = browser.page_source
+
+        # On récupère les cookies du navigateur pour les réutiliser plus tard
+        for cookie in browser.get_cookies():
+            self.session.cookies.set(cookie['name'], cookie['value'])
+
+        # On arrête le navigateur
+        browser.quit()
+        display.stop()
+
+        return page_content
+
+    def print_output(self, data):
+        """Affiche dans le terminal et dans le fichier de log un texte"""
+        print(data)
+        data = data.replace('\033[92m', '')
+        data = data.replace('\033[0m', '')
+        data = data.replace('\033[1m', '')
+        f = open(self.output_file_path, 'a')
+        f.write(data + "\n")
+        f.close()
+
+    def get_page(self, url, method, data={}, selenium=False):
+        """
+        Récupère le contenu HTML d'une page web
+
+        url -- L'URL de la page demandée
+        method -- 'post' ou 'get', selon le type de requête
+        data -- Un dictionnaire contenant les données à envoyer au site
+        selenium -- lance un navigateur avec Selenium pour contourner les protections anti-robots
+        """
+        try:
+            logger.debug(f'Chargement de la page {url}')
+
+            # Si un délai a été configuré, on vérifie qu'il n'est pas trop tôt pour lancer la requête
+            if self.sleep_time > 0:
+                current_time = int(time.mktime(datetime.datetime.today().timetuple()))
+                remaining_sleep_time = self.last_http_request + self.sleep_time - current_time
+
+                if remaining_sleep_time > 0:
+                    time.sleep(remaining_sleep_time)
+                self.last_http_request = int(time.mktime(datetime.datetime.today().timetuple()))
+
+            page = None
+            if selenium and method == 'get':
+                page_content = self.get_session(url, None, 6)
+                page = {'content': page_content, 'status_code': 200}
+                page = SimpleNamespace(**page)
+            else:
+                if method == 'get':
+                    page = self.session.get(url, timeout=(10, 120))
+                if method == 'post':
+                    page = self.session.post(url, data=data, timeout=(10, 120))
+
+            if page.status_code == 429:
+                logger.warning('Erreur 429 Too Many Requests reçue, temporisation...')
+                self.tor_get_new_id()
+                time.sleep(1)
+                return self.get_page(url, method, data)
+
+            if self.tor_enabled:
+                self.tor_requests += 1
+                if self.tor_max_requests > 0 and \
+                   self.tor_requests > self.tor_max_requests:
+                    self.tor_get_new_id()
+
+            return page
+        except requests.exceptions.ConnectionError:
+            logger.warning(f'Erreur de connexion, temporisation...')
+            self.tor_get_new_id()
+            time.sleep(30)
+            return self.get_page(url, method, data)
+        except requests.exceptions.Timeout:
+            logger.warning(f'Timeout, on relance la requête...')
+            return self.get_page(url, method, data)
+        except urllib3.exceptions.ProtocolError:
+            logger.warning(f'Erreur de connexion, on relance la requête...')
+            return self.get_page(url, method, data)
+
+    def update_user_agent(self, user_agent):
+        """Change la valeur du user-agent"""
+        self.user_agent = user_agent
+        self.session.headers.update({'User-Agent': self.user_agent})
+
+    def download_file(self, raa):
+        """Télécharge un RAA"""
+        try:
+            os.makedirs(
+                os.path.dirname(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf'),
+                exist_ok=True
+            )
+            file = self.get_page(raa.url, 'get')
+            f = open(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf', 'wb')
+            f.write(file.content)
+            f.close()
+        except (requests.exceptions.ConnectionError,
+                requests.exceptions.ChunkedEncodingError):
+            logger.warning(f'ATTENTION: la connexion a été interrompue pendant le téléchargement de {raa.url}, nouvelle tentative...')
+            self.download_file(raa)
+        except Exception as exc:
+            logger.warning(f'ATTENTION: Impossible de télécharger le fichier {raa.url}: {exc}')
+
+    def ocr(self, raa, retry_on_failure=True):
+        """OCRise un RAA"""
+        cmd = [
+            'python3',
+            'bin/ocrmypdf',
+            '-l', 'eng+fra',
+            '--output-type', 'pdf',
+            '--redo-ocr',
+            '--skip-big', '250',
+            '--max-image-mpixels', '250',
+            '--invalidate-digital-signatures',
+            '--optimize', '0',
+            f'{self.data_dir}/raa/{raa.get_sha256()}.flat.pdf',
+            f'{self.data_dir}/raa/{raa.get_sha256()}.ocr.pdf'
+        ]
+        logger.debug(f'Lancement de ocrmypdf: {cmd}')
+        try:
+            output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as exc:
+            if exc.returncode == 2 and retry_on_failure:
+                logger.warning('ATTENTION : Le fichier n\'est pas un PDF correct, nouvelle tentative de le télécharger')
+                if self.tor_enabled:
+                    self.tor_get_new_id()
+                self.download_file(raa)
+                self.ocr(raa, False)
+            elif (not exc.returncode == 6) and (not exc.returncode == 10) and (not exc.returncode == 4):
+                logger.warning('ATTENTION : Impossible d\'OCRiser le document', exc.returncode, exc.output)
+                shutil.copy(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf', f'{self.data_dir}/raa/{raa.get_sha256()}.ocr.pdf')
+
+    def flatten_pdf(self, raa):
+        """Supprime les formulaires d'un PDF pour pouvoir les OCRiser après dans OCRmyPDF."""
+        reader = PdfReader(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf')
+        writer = PdfWriter()
+
+        for page in reader.pages:
+            if page.get('/Annots'):
+                for annot in page.get('/Annots'):
+                    writer_annot = annot.get_object()
+                    writer_annot.update({
+                        NameObject("/Ff"): NumberObject(1)
+                    })
+            writer.add_page(page)
+        writer.write(f'{self.data_dir}/raa/{raa.get_sha256()}.flat.pdf')
+
+    def search_keywords(self, raa, keywords):
+        """Recherche des mots-clés dans le texte extrait du PDF"""
+        if keywords and not keywords == '':
+            text = open(f'{self.data_dir}/raa/{raa.get_sha256()}.txt').read()
+            date_str = raa.date.strftime("%d/%m/%Y")
+
+            found = False
+            found_keywords = []
+            for keyword in keywords.split(','):
+                if re.search(keyword, text, re.IGNORECASE | re.MULTILINE):
+                    if not found:
+                        url = quote(raa.url, safe='/:')
+                        self.print_output(f'\033[92m{raa.name}\033[0m ({date_str})')
+                        self.print_output(f'URL : {url}')
+                        found = True
+                        self.found = True
+                    self.print_output(f'    Le terme \033[1m{keyword}\033[0m a été trouvé.')
+                    found_keywords.append(keyword)
+
+            if found:
+                self.print_output('')
+                url = quote(raa.url, safe='/:')
+                found_keywords_str = ', '.join(
+                    [str(x) for x in found_keywords]
+                )
+                self.mastodon_toot(
+                    f'{raa.name} ({date_str})\n\nLes termes suivants ont '
+                    f'été trouvés : {found_keywords_str}.\n\nURL : {url}'
+                )
+
+    def parse_raa(self, elements, keywords):
+        """
+        Démarre l'analyse des RAA.
+
+        elements -- Un tableau contenant les RAA à analyser
+        keywords -- Les mots-clés à rechercher dans chaque RAA
+        """
+        self.print_output(f'Termes recherchés: {keywords}')
+        self.print_output('')
+
+        for raa in elements:
+            # Si le fichier n'a pas déjà été parsé et qu'il est postérieur à la
+            # date maximale d'analyse, on le télécharge et on le parse
+            if not os.path.isfile(f'{self.data_dir}/raa/{raa.get_sha256()}.txt') and (not raa.date or (raa.date >= Attrap.get_aware_datetime(self.not_before, timezone=self.timezone))):
+                url = quote(raa.url, safe='/:')
+                self.download_file(raa)
+                try:
+                    raa.parse_metadata(self.data_dir)
+                    # Lorsque la date du RAA n'est pas connue, on a dû télécharger le PDF pour récupérer la date de ses métadonnées.
+                    # Donc on vérifie à nouveau ici si la date correspond à ce qu'on veut analyser
+                    if not raa.date:
+                        os.remove(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf')
+                        os.remove(f'{self.data_dir}/raa/{raa.get_sha256()}.json')
+                        logger.error(f'ERREUR: le RAA {raa.name} n\'a pas de date !')
+                        sys.exit(1)
+                    if raa.date >= Attrap.get_aware_datetime(self.not_before, timezone=self.timezone):
+                        date_str = raa.date.strftime("%d/%m/%Y")
+                        logger.info(f'Nouveau fichier : {raa.name} ({date_str}). URL : {url}')
+                        self.flatten_pdf(raa)
+                        self.ocr(raa, True)
+                        raa.extract_content(self.data_dir)
+                        self.search_keywords(raa, keywords)
+                    else:
+                        # On supprime le fichier de metadonnées puisqu'on ne le parsera pas
+                        os.remove(f'{self.data_dir}/raa/{raa.get_sha256()}.pdf')
+                        os.remove(f'{self.data_dir}/raa/{raa.get_sha256()}.json')
+                except PdfStreamError as exc:
+                    logger.warning(f'ATTENTION: le RAA à l\'adresse {raa.url} n\'est pas valide ! On l\'ignore...')
+                except EmptyFileError as exc:
+                    logger.warning(f'ATTENTION: le RAA à l\'adresse {raa.url} est vide ! On l\'ignore...')
+
+    def get_raa(self, page_content):
+        logger.error('Cette fonction doit être surchargée')
+
+    def configure_mailer(self, smtp_host, smtp_username, smtp_password,
+                         smtp_port, smtp_starttls, smtp_ssl, email_from,
+                         email_to, email_object):
+        """
+        Configure les courriers électroniques.
+
+        smtp_host -- Nom d'hôte du serveur SMTP
+        smtp_username -- Nom d'utilisateur pour se connecter au serveur SMTP
+        smtp_password -- Mot de passe pour se connecter au serveur SMTP
+        smtp_port -- Port de connexion au serveur SMTP
+        smtp_starttls -- Booléen. Si vrai, se connecte avec STARTTLS
+        smtp_ssl -- Booléen. Si vrai, se connecte avec SSL/TLS
+        email_from -- Adresse électronique de l'expéditeur des notifications
+        email_to -- Tableau contenant les adresses électroniques à notifier
+        email_object -- Objet du courrier électronique de notification
+        """
+        self.smtp_host = smtp_host
+        self.smtp_username = smtp_username
+        self.smtp_password = smtp_password
+        if smtp_port <= 0:
+            self.smtp_port = 587
+        else:
+            self.smtp_port = int(smtp_port)
+        self.smtp_starttls = smtp_starttls
+        self.smtp_ssl = smtp_ssl
+        self.email_from = email_from
+        self.email_to = email_to
+        self.email_object = email_object
+
+        if smtp_host and smtp_username and smtp_password and email_from and email_to and email_object:
+            self.smtp_configured = True
+
+    def mailer(self):
+        if self.smtp_configured and self.found:
+            try:
+                message = email.message.EmailMessage()
+                message.set_content(open(self.output_file_path).read())
+
+                message['Subject'] = self.email_object
+                message['From'] = self.email_from
+                message['Message-ID'] = email.utils.make_msgid(domain=self.email_from.split('@')[-1])
+                message['Date'] = email.utils.formatdate()
+
+                context = ssl.create_default_context()
+
+                if self.smtp_ssl is True:
+                    for address in self.email_to.split(','):
+                        del message['To']
+                        message['To'] = address
+                        smtp = smtplib.SMTP_SSL(self.smtp_host, port, context=context)
+                        if self.smtp_username:
+                            smtp.login(self.smtp_username, self.smtp_password)
+                        smtp.send_message(message)
+                        smtp.quit()
+                elif self.smtp_starttls is True:
+                    for address in self.email_to.split(','):
+                        del message['To']
+                        message['To'] = address
+                        smtp = smtplib.SMTP(self.smtp_host)
+                        smtp.starttls(context=context)
+                        if self.smtp_username:
+                            smtp.login(self.smtp_username, self.smtp_password)
+                        smtp.send_message(message)
+                        smtp.quit()
+                else:
+                    for address in self.email_to.split(','):
+                        del message['To']
+                        message['To'] = address
+                        smtp = smtplib.SMTP(self.smtp_host)
+                        if self.smtp_username:
+                            smtp.login(self.smtp_username, self.smtp_password)
+                        smtp.send_message(message)
+                        smtp.quit()
+            except Exception as exc:
+                logger.warning(f'Impossible d\'envoyer le courrier électronique : {exc}')
+
+    def guess_date(string, regex):
+        """
+        Essaie de deviner la date d'un RAA à partir de son nom.
+        Utile pour limiter les requêtes lors de l'obtention des RAA à scanner.
+        """
+        try:
+            search = re.search(regex, string, re.IGNORECASE)
+            guessed_date = dateparser.parse(search.group(1), languages=['fr'], settings={'PREFER_DAY_OF_MONTH': 'last', 'PREFER_MONTH_OF_YEAR': 'last'})
+            if guessed_date is None:
+                raise Exception('La date est un objet None')
+            else:
+                return guessed_date
+        except Exception as exc:
+            logger.warning(f'Impossible de deviner la date du terme {string} : {exc}')
+            return datetime.datetime(9999, 1, 1)
+
+    def get_aware_datetime(unknown_datetime, timezone='Europe/Paris'):
+        """
+        Retourne un objet datetime avisé.
+
+        datetime - L'objet datetime à aviser. Utilise le fuseau indiqué si datetime est naïf.
+        """
+
+        if unknown_datetime.tzinfo is not None and unknown_datetime.tzinfo.utcoffset(unknown_datetime) is not None:
+            return unknown_datetime
+        else:
+            return pytz.timezone(timezone).localize(unknown_datetime)

Attrap_ppparis.py

+import datetime
+
+from bs4 import BeautifulSoup
+from urllib.parse import unquote
+
+from Attrap import Attrap
+
+
+class Attrap_ppparis(Attrap):
+
+    # Config
+    hostname = 'https://www.prefecturedepolice.interieur.gouv.fr'
+    raa_page = f'{hostname}/actualites-et-presse/arretes/accueil-arretes'
+    __WAIT_ELEMENT = 'block-decree-list-block'
+    user_agent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
+    full_name = 'Préfecture de police de Paris'
+    short_code = 'ppparis'
+    timezone = 'Europe/Paris'
+
+    def __init__(self, data_dir):
+        super().__init__(data_dir, self.user_agent)
+
+    def get_raa(self, keywords):
+        page_content = self.get_session(self.raa_page, self.__WAIT_ELEMENT, 6)
+        raa_elements = self.get_raa_elements(page_content)
+        self.parse_raa(raa_elements, keywords)
+        self.mailer()
+
+    def get_raa_elements(self, page_content):
+        elements = []
+        # On charge le parser
+        soup = BeautifulSoup(page_content, 'html.parser')
+
+        # Pour chaque balise a, on regarde si c'est un PDF, et si oui on le
+        # parse
+        for a in soup.find_all('a', href=True):
+            if a['href'].endswith('.pdf'):
+                if a['href'].startswith('/'):
+                    url = 'https://www.prefecturedepolice.interieur.gouv.fr' + a['href']
+                else:
+                    url = a['href']
+
+                url = unquote(url)
+                name = a.find('span').get_text()
+                date = datetime.datetime.strptime(a.find('div', class_="field--type-datetime").get_text().strip(), '%d/%m/%Y')
+
+                raa = Attrap.RAA(url, date, name, timezone=self.timezone)
+                elements.append(raa)
+        return elements

Attrap_pref01.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref01(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.ain.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs-RAA'
+    full_name = 'Préfecture de l\'Ain'
+    short_code = 'pref01'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '(?:Recueil|Recueils) (?:des actes administratifs)(?:[ -])*([0-9]{4})'

Attrap_pref02.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref02(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.aisne.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs'
+    full_name = 'Préfecture de l\'Aisne'
+    short_code = 'pref02'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'RAA [Aa]nnée ([0-9]{4})'

Attrap_pref03.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref03(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.allier.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs-arretes'
+    full_name = 'Préfecture de l\'Allier'
+    short_code = 'pref03'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'

Attrap_pref04.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref04(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.alpes-de-haute-provence.gouv.fr'
+    raa_page = f'{hostname}/Publications/Publications-administratives-et-legales/Recueil-des-Actes-Administratifs'
+    full_name = 'Préfecture des Alpes-de-Haute-Provence'
+    short_code = 'pref04'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'

Attrap_pref05.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref05(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.hautes-alpes.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs'
+    full_name = 'Préfecture des Hautes-Alpes'
+    short_code = 'pref05'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'Année *([0-9]{4})'
+    Attrap_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* *[0-9]{4})'

Attrap_pref06.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref06(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.alpes-maritimes.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs-RAA'
+    full_name = 'Préfecture des Alpes-Maritimes'
+    short_code = 'pref06'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'Année *([0-9]{4})'

Attrap_pref09.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref09(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.ariege.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs/Recueils-des-Actes-Administratifs-de-l-Ariege-a-partir-du-28-avril-2015'
+    full_name = 'Préfecture de l\'Ariège'
+    short_code = 'pref09'
+    timezone = 'Europe/Paris'

Attrap_pref10.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref10(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.aube.gouv.fr'
+    raa_page = [
+        f'{hostname}/Publications/RAA-Recueil-des-Actes-Administratifs',
+        f'{hostname}/Publications/RAA-Recueil-des-Actes-Administratifs/RAA-Archives'
+    ]
+
+    full_name = 'Préfecture de l\'Aube'
+    short_code = 'pref10'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'RAA *([0-9]{4})'
+
+    # On ajoute un widget custom représentant les liens sur la page d'accueil
+    Attrap_prefdpt.widgets.append(
+        Attrap_prefdpt.DptWidget(
+            'homepage_links',
+            regex={'year': 'Année *([0-9]{4})'},
+            css_path={'title': 'div.fr-text--lead p a.fr-link'}
+        )
+    )

Attrap_pref11.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref11(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.aude.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs-RAA'
+    full_name = 'Préfecture de l\'Aude'
+    short_code = 'pref11'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'Année *([0-9]{4})'

Attrap_pref13.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref13(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.bouches-du-rhone.gouv.fr'
+    raa_page = [
+        f'{hostname}/Publications/RAA-et-Archives',
+        f'{hostname}/Publications/RAA-et-Archives/Archives-RAA-des-Bouches-du-Rhone'
+    ]
+    full_name = 'Préfecture des Bouches-du-Rhône'
+    short_code = 'pref13'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'RAA[- ]*([0-9]{4})'
+    Attrap_prefdpt.grey_card['follow_link_on_unrecognised_date'] = False

Attrap_pref25.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref25(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.doubs.gouv.fr'
+    raa_page = f'{hostname}/Publications/Publications-Legales/Recueil-des-Actes-Administratifs-RAA'
+    full_name = 'Préfecture du Doubs'
+    short_code = 'pref25'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'
+    Attrap_prefdpt.grey_card['follow_link_on_unrecognised_date'] = False

Attrap_pref29.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref29(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.finistere.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs'
+    full_name = 'Préfecture du Finistère'
+    short_code = 'pref29'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '(?:Recueils publiés en ).*([0-9]{4})'

Attrap_pref2a.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref2a(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.corse-du-sud.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs/Recueil-des-actes-administratifs-de-la-prefecture-de-la-Corse-du-Sud'
+    full_name = 'Préfecture de la Corse-du-Sud'
+    short_code = 'pref2a'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.white_card['regex']['year'] = '([0-9]{4})'

Attrap_pref2b.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref2b(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.haute-corse.gouv.fr'
+    raa_page = f'{hostname}/Publications/Publications-administratives-et-legales/Recueils-des-actes-administratifs'
+    full_name = 'Préfecture de Haute-Corse'
+    short_code = 'pref2b'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'Recueils des actes administratifs ([0-9]{4})'
+    Attrap_prefdpt.white_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'

Attrap_pref30.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref30(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.gard.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs'
+    full_name = 'Préfecture du Gard'
+    short_code = 'pref30'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'

Attrap_pref31.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref31(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.haute-garonne.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs/Recueil-des-Actes-Administratifs-Haute-Garonne'
+    full_name = 'Préfecture de la Haute-Garonne'
+    short_code = 'pref31'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'