Attrap_pref63.py

-import os
-import datetime
-import re
+from Attrap_prefdpt import Attrap_prefdpt
 
-from bs4 import BeautifulSoup
-from urllib.parse import unquote
 
-from Attrap import Attrap
+class Attrap_pref63(Attrap_prefdpt):
 
-
-class Attrap_pref63(Attrap):
-
-    # Config
+    # Configuration de la préfecture
     hostname = 'https://www.puy-de-dome.gouv.fr'
     raa_page = f'{hostname}/Publications/Recueils-des-actes-administratifs/Recueils-des-actes-administratifs-Puy-de-Dome'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
     full_name = 'Préfecture du Puy-de-Dôme'
     short_code = 'pref63'
     timezone = 'Europe/Paris'
 
-    def __init__(self, data_dir):
-        super().__init__(data_dir, self.user_agent)
-        self.set_sleep_time(30)
-
-    def get_raa(self, keywords):
-        year_pages_to_parse = []
-
-        # On détermine quelles pages d'année parser
-        page_content = self.get_page(self.raa_page, 'get').content
-        year_pages = self.get_sub_pages(
-            page_content,
-            'div.fr-card.fr-card--sm.fr-card--grey.fr-enlarge-link div.fr-card__body div.fr-card__content h2.fr-card__title a',
-            self.hostname,
-            False
-        )
-        for year_page in year_pages:
-            if not year_page['name'].strip() == 'Archives':
-                year = 9999
-                try:
-                    year = int(year_page['name'].strip())
-                except Exception as exc:
-                    logger.warning(f"Impossible de deviner l\'année de la page {year_page['name']}")
-                    year = 9999
-
-                if year >= self.not_before.year:
-                    year_pages_to_parse.append(year_page['url'])
-
-        elements = []
-        # Pour chaque année, on parse les RAA
-        for year_page in year_pages_to_parse:
-            page_content = self.get_page(year_page, 'get').content
-            for element in self.get_raa_elements(page_content):
-                elements.append(element)
-
-        # On parse les RAA
-        self.parse_raa(elements, keywords)
-        self.mailer()
-
-    def get_raa_elements(self, page_content):
-        elements = []
-        # On charge le parser
-        soup = BeautifulSoup(page_content, 'html.parser')
-
-        # On récupère chaque balise a
-        for a in soup.select('a.fr-link.fr-link--download'):
-            if a.get('href') and a['href'].endswith('.pdf'):
-                if a['href'].startswith('/'):
-                    url = f"{self.hostname}{a['href']}"
-                else:
-                    url = a['href']
-
-                url = unquote(url)
-                name = a.find('span').previous_sibling.replace('Télécharger ', '').strip()
-                date = datetime.datetime.strptime(a.find('span').get_text().split(' - ')[-1].strip(), '%d/%m/%Y')
-
-                raa = Attrap.RAA(url, date, name, timezone=self.timezone)
-                elements.append(raa)
-        return elements
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'

Attrap_pref74.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref74(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.haute-savoie.gouv.fr'
+    raa_page = f'{hostname}/Publications/Actes-administratifs'
+    full_name = 'Préfecture de la Haute-Savoie'
+    short_code = 'pref74'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'

Attrap_pref75.py

@@ -15,7 +15,7 @@ class Attrap_pref75(Attrap):
     # Config
     hostname = 'https://www.prefectures-regions.gouv.fr'
     raa_page = f'{hostname}/ile-de-france/tags/view/Ile-de-France/Documents+et+publications/Recueil+des+actes+administratifs'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
+    user_agent = 'Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0'
     full_name = 'Préfecture de Paris'
     short_code = 'pref75'
     timezone = 'Europe/Paris'
@@ -23,17 +23,19 @@ class Attrap_pref75(Attrap):
     def __init__(self, data_dir):
         super().__init__(data_dir, self.user_agent)
         self.enable_tor(10)
+        self.set_sleep_time(10)
 
     def get_raa(self, keywords):
         year_pages_to_parse = []
 
         # On détermine quelles pages d'année parser
-        page_content = self.get_page(self.raa_page, 'get').content
+        page_content = self.get_session(self.raa_page, 'main', 6)
         year_pages = self.get_sub_pages(
             page_content,
             'article.news-list-item header h2.news-list-title a',
             self.hostname,
-            False
+            False,
+            selenium=True
         )
         for year_page in year_pages:
             year_date = Attrap.guess_date(year_page['name'].strip(), '(?:.*Paris.*)([0-9]{4})').replace(day=1, month=1)
@@ -42,13 +44,14 @@ class Attrap_pref75(Attrap):
 
         pages_to_parse = []
         for year_page in year_pages_to_parse:
-            page_content = self.get_page(year_page, 'get').content
+            page_content = self.get_session(year_page, 'main', 6)
             year = BeautifulSoup(page_content, 'html.parser').select('div.breadcrumb div.container p span.active')[0].get_text().split('-')[-1].strip()
             month_pages = self.get_sub_pages(
                 page_content,
                 'div.sommaire-bloc div.sommaire-content ol li a',
                 self.hostname,
-                False
+                False,
+                selenium=True
             )[::-1]
             for month_page in month_pages:
                 month_date = Attrap.guess_date(f"{month_page['name']} {year}", "(.*)").replace(day=1)
@@ -57,7 +60,7 @@ class Attrap_pref75(Attrap):
 
         elements = []
         for page in pages_to_parse[::-1]:
-            page_content = self.get_page(page, 'get').content
+            page_content = self.get_session(page, 'main', 6)
             for element in self.get_raa_elements(page_content):
                 elements.append(element)
 

Attrap_pref76.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref76(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.seine-maritime.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueils-des-actes-administratifs-RAA'
+    full_name = 'Préfecture de la Seine-Maritime'
+    short_code = 'pref76'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = '([0-9]{4})'
+    Attrap_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'
+    Attrap_prefdpt.grey_card['follow_link_on_unrecognised_date'] = False

Attrap_pref77.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref77(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.seine-et-marne.gouv.fr'
+    raa_page = f'{hostname}/Publications/RECUEILS-DES-ACTES-ADMINISTRATIFS-RAA'
+    full_name = 'Préfecture de Seine-et-Marne'
+    short_code = 'pref77'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.white_card['regex']['year'] = 'RAA ([0-9]{4})'
+
+    # On ajoute un widget de menu déroulant
+    Attrap_prefdpt.select_widgets.append(
+        Attrap_prefdpt.DptSelectWidget(
+            'menu_deroulant',
+            regex='D77-([0-9]{2}-[0-9]{2}-[0-9]{4})',
+            css_path='select#Liste-liste-docs',
+            type='year-month-day'
+        )
+    )

Attrap_pref81.py

@@ -19,7 +19,7 @@ class Attrap_pref81(Attrap):
 
     def __init__(self, data_dir):
         super().__init__(data_dir, self.user_agent)
-        self.set_sleep_time(30)
+        self.set_sleep_time(5)
 
     def get_raa(self, keywords):
         year_pages_to_parse = []

Attrap_pref976.py

@@ -19,7 +19,7 @@ class Attrap_pref976(Attrap):
 
     def __init__(self, data_dir):
         super().__init__(data_dir, self.user_agent)
-        self.set_sleep_time(30)
+        self.set_sleep_time(5)
 
     def get_raa(self, keywords):
         year_pages_to_parse = []

Attrap_prefbretagne.py

+import datetime
+import time
+
+from bs4 import BeautifulSoup
+from urllib.parse import unquote
+
+from Attrap import Attrap
+
+
+class Attrap_prefbretagne(Attrap):
+
+    # Config
+    hostname = 'https://www.prefectures-regions.gouv.fr'
+    raa_page = f'{hostname}/bretagne/Documents-publications/Recueils-des-actes-administratifs/Recueil-des-actes-administratifs'
+    user_agent = 'Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0'
+    full_name = 'Préfecture de la région Bretagne'
+    short_code = 'prefbretagne'
+    timezone = 'Europe/Paris'
+
+    def __init__(self, data_dir):
+        super().__init__(data_dir, self.user_agent)
+        self.enable_tor(10)
+        self.set_sleep_time(10)
+
+    def get_raa(self, keywords):
+        # page_content = self.get_page(self.raa_page, 'get').content
+        page_content = self.get_session(self.raa_page, 'main', 6)
+        elements = self.get_raa_elements(page_content)
+
+        time.sleep(10)
+
+        self.parse_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.select('main div.container.main-container div.col-main article.article div.texte div a.link-download'):
+            if a.get('href') and a['href'].endswith('.pdf'):
+                if a['href'].startswith('/'):
+                    url = f"{self.hostname}{a['href']}"
+                else:
+                    url = a['href']
+                url = unquote(url)
+                name = a.find('span').get_text().strip()
+                # On devine la date du RAA à partir du nom de fichier
+                guessed = Attrap.guess_date(name, '((?:[0-9]{2}|[0-9]{1})(?:er){0,1}[ _](?:[a-zéû]{3,9})[ _](?:[0-9]{4}|[0-9]{2}))')
+                if (guessed == datetime.datetime(9999, 1, 1, 0, 0)):
+                    date = None
+                else:
+                    date = guessed
+
+                raa = Attrap.RAA(url, date, name, timezone=self.timezone)
+                elements.append(raa)
+        return elements

Attrap_prefdpt.py

@@ -21,7 +21,9 @@ class Attrap_prefdpt(Attrap):
         },
         'link_to_raa': False,
         'autodetect_links_to_raa': True,
-        'follow_link_on_unrecognised_date': True
+        'follow_link_on_unrecognised_date': True,
+        'exclude': [],
+        'add_year_to_months': False
     }
     white_card = {
         'regex': {
@@ -35,11 +37,14 @@ class Attrap_prefdpt(Attrap):
         },
         'link_to_raa': False,
         'autodetect_links_to_raa': True,
-        'follow_link_on_unrecognised_date': True
+        'follow_link_on_unrecognised_date': True,
+        'exclude': [],
+        'add_year_to_months': False
     }
 
     # Liste des widgets à analyser (sera remplie au moment de l'initialisation, mais peut être surchargée par la classe de préfecture de département)
     widgets = []
+    select_widgets = []
 
     # Est-ce qu'on inclue les widgets des cartes blanches et grises ? Par défaut oui, mais il peut être nécessaire de les désactiver sur certaines préfectures
     include_grey_card_widget = True
@@ -54,13 +59,15 @@ class Attrap_prefdpt(Attrap):
     class DptWidget:
         """Une classe représentant un widget sur le site d'une préfecture de département."""
 
-        def __init__(self, name, regex=None, css_path=None, link_to_raa=False, autodetect_links_to_raa=True, follow_link_on_unrecognised_date=True):
+        def __init__(self, name, regex=None, css_path=None, link_to_raa=False, autodetect_links_to_raa=True, follow_link_on_unrecognised_date=True, exclude=[], add_year_to_months=False):
             self.name = name
             self.regex = regex
             self.css_path = css_path
             self.link_to_raa = link_to_raa
             self.autodetect_links_to_raa = autodetect_links_to_raa
             self.follow_link_on_unrecognised_date = follow_link_on_unrecognised_date
+            self.exclude = exclude
+            self.add_year_to_months = add_year_to_months
 
         def has_css_path(self, key):
             return self.css_path and self.css_path.get(key, None) is not None
@@ -80,15 +87,41 @@ class Attrap_prefdpt(Attrap):
             else:
                 return self.regex.get(key, None)
 
+    class DptSelectWidget:
+        """Une classe représentant un menu déroulant sur le site d'une préfecture de département."""
+
+        def __init__(self, name, regex=None, css_path=None, follow_link_on_unrecognised_date=True, exclude=[], type='year-month-day'):
+            self.name = name
+            self.regex = regex
+            self.css_path = css_path
+            self.follow_link_on_unrecognised_date = follow_link_on_unrecognised_date
+            self.exclude = exclude
+            self.type = type
+
+    def add_url(self, url, date=None):
+        if date and date.year == 9999:
+            date = None
+        self.page_urls_to_parse.append([url, date])
+
+    def get_urls_to_parse(self):
+        urls = []
+        for url in self.page_urls_to_parse:
+            urls.append(url[0])
+        return urls
+
     def __init__(self, data_dir):
         """Une classe générique permettant d'analyser les préfectures de département en fonction de certains paramètres."""
 
         super().__init__(data_dir, self.user_agent)
         self.set_sleep_time(self.pref_sleep_time)
 
+        self.page_urls_to_parse = []
+
         if isinstance(self.raa_page, str):
-            self.raa_page = [self.raa_page]
-        self.page_urls_to_parse = self.raa_page
+            self.add_url(self.raa_page)
+        else:
+            for url in self.raa_page:
+                self.add_url(url)
         self.elements = []
 
         # On ajoute les cartes grises et blanches à la liste des widgets à parser
@@ -100,7 +133,9 @@ class Attrap_prefdpt(Attrap):
                     css_path=self.grey_card['css_path'],
                     link_to_raa=self.grey_card['link_to_raa'],
                     autodetect_links_to_raa=self.grey_card['autodetect_links_to_raa'],
-                    follow_link_on_unrecognised_date=self.grey_card['follow_link_on_unrecognised_date']
+                    follow_link_on_unrecognised_date=self.grey_card['follow_link_on_unrecognised_date'],
+                    exclude=self.grey_card['exclude'],
+                    add_year_to_months=self.grey_card['add_year_to_months']
                 )
             )
 
@@ -112,15 +147,18 @@ class Attrap_prefdpt(Attrap):
                     css_path=self.white_card['css_path'],
                     link_to_raa=self.white_card['link_to_raa'],
                     autodetect_links_to_raa=self.white_card['autodetect_links_to_raa'],
-                    follow_link_on_unrecognised_date=self.white_card['follow_link_on_unrecognised_date']
+                    follow_link_on_unrecognised_date=self.white_card['follow_link_on_unrecognised_date'],
+                    exclude=self.white_card['exclude'],
+                    add_year_to_months=self.white_card['add_year_to_months']
                 )
             )
 
     def get_raa(self, keywords):
         while not self.page_urls_to_parse == []:
             page_url = self.page_urls_to_parse[-1]
-            page_content = self.get_page(page_url, 'get').content  # On récupère le HTML de la page
-            self.parse_widgets(page_content)  # On parse les cartes blanches
+            page_content = self.get_page(page_url[0], 'get').content  # On récupère le HTML de la page
+            self.parse_widgets(page_url, page_content)  # On parse les cartes
+            self.parse_select_widgets(page_url, page_content)  # On parse les menus déroulants
             for element in self.get_raa_elements(page_content):  # On cherche les RAA
                 self.elements.append(element)
             self.page_urls_to_parse.remove(page_url)  # On supprime la page de la liste de celles à parser
@@ -128,8 +166,8 @@ class Attrap_prefdpt(Attrap):
         self.parse_raa(self.elements[::-1], keywords)
         self.mailer()
 
-    def parse_widgets(self, page_content):
-        # Pour chaque widget paramétré, on le cherche sur la page
+    def parse_widgets(self, page_url, page_content):
+        # Pour chaque widget paramétré qui n'est pas de type select, on le cherche sur la page
         for widget in self.widgets:
             cards = []
             # Si n'appelle pas la même fonction le widget a prévu un pager ou non
@@ -149,7 +187,7 @@ class Attrap_prefdpt(Attrap):
                     False
                 )
             for card in cards:
-                if card['url'] not in self.page_urls_to_parse:
+                if card['url'] not in self.get_urls_to_parse() and card['name'].strip() not in widget.exclude:
                     date = None
                     date_is_correct = False
 
@@ -161,13 +199,18 @@ class Attrap_prefdpt(Attrap):
                             date_is_correct = True
 
                     # Si un regex de mois est spécifié et qu'aucune date correcte n'a été trouvée, on teste avec le regex de mois sur le titre
-                    if widget.has_regex('month') and not date_is_correct:
-                        date = Attrap.guess_date(card['name'].strip(), widget.get_regex('month')).replace(day=1)
+                    if widget.has_regex('month') and (not date or date.year == 9999):
+                        # On ajoute l'année au nom du mois à tester si configuré dans le widget
+                        if widget.add_year_to_months and page_url[1]:
+                            month = card['name'].strip() + ' ' + str(page_url[1].year)
+                        else:
+                            month = card['name'].strip()
+                        date = Attrap.guess_date(month, widget.get_regex('month')).replace(day=1)
                         if date >= self.not_before.replace(day=1) and date.year < 9999:
                             date_is_correct = True
 
                     # Si un chemin CSS vers les détails du widget est spécifié et qu'aucune date correcte n'a été trouvée, on tente de parser la date présente dans les détails
-                    if widget.has_css_path('details') and not date_is_correct:
+                    if widget.has_css_path('details') and (not date or date.year == 9999):
                         try:
                             date = datetime.datetime.strptime(card['details'].replace('Publié le ', '').strip(), '%d/%m/%Y')
                             if date >= self.not_before:
@@ -177,14 +220,52 @@ class Attrap_prefdpt(Attrap):
 
                     # Si la configuration indique que les liens renvoient vers un RAA, on ajoute le lien à la liste des éléments
                     if widget.link_to_raa or (widget.autodetect_links_to_raa and card['url'].endswith('.pdf')):
-                        if date.year == 9999:
+                        if date and date.year == 9999:
                             date = None
                         raa = Attrap.RAA(card['url'], date, card['name'].strip(), timezone=self.timezone)
                         self.elements.append(raa)
                     else:
                         # Si une date a été trouvée, on regarde s'il faut ajouter l'URL à la liste des pages à parser
-                        if date_is_correct or (date.year == 9999 and widget.follow_link_on_unrecognised_date):
-                            self.page_urls_to_parse.append(card['url'])
+                        if date_is_correct or ((date is None or date.year == 9999) and widget.follow_link_on_unrecognised_date):
+                            self.add_url(card['url'], date)
+
+    def parse_select_widgets(self, page_url, page_content):
+        for select_widget in self.select_widgets:
+            # Les widgets select fonctionnent différemment : chaque valeur option doit être testée pour trouver une date, et si la date correspond
+            # à la date recherchée la requête POST est envoyée, puis le résultat est analysé par get_raa_elements()
+
+            # On charge le parser
+            soup = BeautifulSoup(page_content, 'html.parser')
+
+            # On récupère les select
+            for select in soup.select(select_widget.css_path):
+                # On récupère les option de chaque select
+                for option in select.find_all('option'):
+                    if not option['value'] == "" and option['title'].strip() not in select_widget.exclude:
+                        # On estime la date à partir du nom de fichier
+                        date = Attrap.guess_date(option['title'].strip(), select_widget.regex)
+                        match select_widget.type:
+                            case 'year':
+                                date = date.replace(day=1, month=1)
+                                not_before = self.not_before.replace(day=1, month=1)
+                            case 'year-month':
+                                date = date.replace(day=1)
+                                not_before = self.not_before.replace(day=1)
+                            case _:
+                                not_before = self.not_before
+
+                        # Si la date estimée correspond à la plage d'analyse ou si follow_link_on_unrecognised_date est à True,
+                        # on demande au serveur les détails du RAA
+                        if (date.year < 9999 and date >= not_before) or (date.year == 9999 and select_widget.follow_link_on_unrecognised_date):
+                            page_content = self.get_page(
+                                page_url[0],
+                                'post',
+                                {
+                                    select['id']: option['value']
+                                }
+                            ).content
+                            for element in self.get_raa_elements(page_content):
+                                self.elements.append(element)
 
     def get_raa_elements(self, page_content):
         elements = []
@@ -201,7 +282,13 @@ class Attrap_prefdpt(Attrap):
 
                 url = unquote(url)
                 name = a.find('span').previous_sibling.replace('Télécharger ', '').strip()
-                date = datetime.datetime.strptime(a.find('span').get_text().split(' - ')[-1].strip(), '%d/%m/%Y')
+                if not name:
+                    name = url.split('/')[-1].strip()
+
+                try:
+                    date = datetime.datetime.strptime(a.find('span').get_text().split(' - ')[-1].strip(), '%d/%m/%Y')
+                except Exception:
+                    date = None
 
                 raa = Attrap.RAA(url, date, name, timezone=self.timezone)
                 elements.append(raa)

Attrap_prefidf.py

@@ -12,25 +12,27 @@ class Attrap_prefidf(Attrap):
     # Config
     hostname = 'https://www.prefectures-regions.gouv.fr'
     raa_page = f'{hostname}/ile-de-france/tags/view/Ile-de-France/Documents+et+publications/Recueil+des+actes+administratifs'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
-    full_name = 'Préfecture d\'Île-de-France'
+    user_agent = 'Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0'
+    full_name = 'Préfecture de la région Île-de-France'
     short_code = 'prefidf'
     timezone = 'Europe/Paris'
 
     def __init__(self, data_dir):
         super().__init__(data_dir, self.user_agent)
         self.enable_tor(10)
+        self.set_sleep_time(10)
 
     def get_raa(self, keywords):
         year_pages_to_parse = []
 
         # On détermine quelles pages d'année parser
-        page_content = self.get_page(self.raa_page, 'get').content
+        page_content = self.get_session(self.raa_page, 'main', 6)
         year_pages = self.get_sub_pages(
             page_content,
             'article.news-list-item header h2.news-list-title a',
             self.hostname,
-            False
+            False,
+            selenium=True
         )
         for year_page in year_pages:
             year_date = Attrap.guess_date(year_page['name'].strip(), '(?:.*[ÎIiî]le-de-[Ff]rance.*)([0-9]{4})').replace(day=1, month=1)
@@ -39,13 +41,14 @@ class Attrap_prefidf(Attrap):
 
         pages_to_parse = []
         for year_page in year_pages_to_parse:
-            page_content = self.get_page(year_page, 'get').content
+            page_content = self.get_page(year_page, 'get', selenium=True).content
             year = BeautifulSoup(page_content, 'html.parser').select('div.breadcrumb div.container p span.active')[0].get_text().split('-')[-1].strip()
             month_pages = self.get_sub_pages(
                 page_content,
                 'div.sommaire-bloc div.sommaire-content ol li a',
                 self.hostname,
-                False
+                False,
+                selenium=True
             )[::-1]
             for month_page in month_pages:
                 month_date = Attrap.guess_date(f"{month_page['name']} {year}", "(.*)").replace(day=1)
@@ -54,7 +57,7 @@ class Attrap_prefidf(Attrap):
 
         elements = []
         for page in pages_to_parse:
-            page_content = self.get_page(page, 'get').content
+            page_content = self.get_session(page, 'main', 6)
             for element in self.get_raa_elements(page_content):
                 elements.append(element)
 

Attrap_prefpaca.py

@@ -12,24 +12,29 @@ class Attrap_prefpaca(Attrap):
     # Config
     hostname = 'https://www.prefectures-regions.gouv.fr'
     raa_page = f'{hostname}/provence-alpes-cote-dazur/Documents-publications'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
-    full_name = 'Préfecture de Provence-Alpes-Côte-d\'Azur'
+    user_agent = 'Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0'
+    full_name = 'Préfecture de la région Provence-Alpes-Côte-d\'Azur'
     short_code = 'prefpaca'
     timezone = 'Europe/Paris'
 
     def __init__(self, data_dir):
         super().__init__(data_dir, self.user_agent)
         self.enable_tor(10)
+        self.set_sleep_time(10)
 
     def get_raa(self, keywords):
+        # On récupère une session avec Selenium
+        page_content = self.get_session(self.raa_page, 'main', 6)
+
         # On récupère les pages d'années
         year_pages = []
         for year_page in self.get_sub_pages_with_pager(
-            self.raa_page,
+            page_content,
             'article.news-list-item header h2.news-list-title a',
             'article.article div.content-pagination ul.pagination li.next a',
             None,
-            self.hostname
+            self.hostname,
+            selenium=True
         ):
             year = Attrap.guess_date(year_page['name'].strip(), 'RAA ([0-9]{4})').year
             if year < 9999 and year >= self.not_before.year:
@@ -37,7 +42,7 @@ class Attrap_prefpaca(Attrap):
 
         elements = []
         for year_page in year_pages:
-            page_content = self.get_page(year_page, 'get').content
+            page_content = self.get_session(year_page, 'main', 6)
             for element in self.get_raa_elements(page_content):
                 elements.append(element)
 

Makefile

-make: ppparis pref01 pref02 pref03 pref04 pref05 pref06 pref09 pref10 pref11 pref13 pref2a pref2b pref25 pref29 pref31 pref33 pref34 pref35 pref38 pref39 pref42 pref44 pref49 pref50 pref59 pref62 pref63 pref64 pref65 pref66 pref69 pref73 pref75 pref80 pref81 pref83 pref87 pref91 pref92 pref93 pref94 pref976 prefidf prefpaca
+make: ppparis pref01 pref02 pref03 pref04 pref05 pref06 pref09 pref10 pref11 pref13 pref2a pref2b pref25 pref29 pref30 pref31 pref33 pref34 pref35 pref38 pref39 pref42 pref44 pref49 pref50 pref52 pref54 pref55 pref59 pref61 pref62 pref63 pref64 pref65 pref66 pref69 pref73 pref74 pref75 pref76 pref77 pref80 pref81 pref83 pref87 pref91 pref92 pref93 pref94 pref976 prefbretagne prefidf prefpaca
 ppparis:
 	bin/python3 cli.py ppparis
 pref01:
@@ -29,6 +29,8 @@ pref25:
 	bin/python3 cli.py pref25
 pref29:
 	bin/python3 cli.py pref29
+pref30:
+	bin/python3 cli.py pref30
 pref31:
 	bin/python3 cli.py pref31
 pref33:
@@ -49,8 +51,16 @@ pref49:
 	bin/python3 cli.py pref49
 pref50:
 	bin/python3 cli.py pref50
+pref52:
+	bin/python3 cli.py pref52
+pref54:
+	bin/python3 cli.py pref54
+pref55:
+	bin/python3 cli.py pref55
 pref59:
 	bin/python3 cli.py pref59
+pref61:
+	bin/python3 cli.py pref61
 pref62:
 	bin/python3 cli.py pref62
 pref63:
@@ -65,8 +75,14 @@ pref69:
 	bin/python3 cli.py pref69
 pref73:
 	bin/python3 cli.py pref73
+pref74:
+	bin/python3 cli.py pref74
 pref75:
 	bin/python3 cli.py pref75
+pref76:
+	bin/python3 cli.py pref76
+pref77:
+	bin/python3 cli.py pref77
 pref80:
 	bin/python3 cli.py pref80
 pref81:
@@ -85,6 +101,8 @@ pref94:
 	bin/python3 cli.py pref94
 pref976:
 	bin/python3 cli.py pref976
+prefbretagne:
+	bin/python3 cli.py prefbretagne
 prefidf:
 	bin/python3 cli.py prefidf
 prefpaca:

README.md

@@ -71,6 +71,7 @@ Vous pouvez également activer le safe mode en spécifiant la variable d'environ
 - Préfecture de Haute-Corse (identifiant : `pref2b`)
 - Préfecture du Doubs (identifiant : `pref25`)
 - Préfecture du Finistère (identifiant : `pref29`)
+- Prefecture du Gard (identifiant : `pref30`)
 - Préfecture de la Haute-Garonne (identifiant : `pref31`)
 - Préfecture de la Gironde (identifiant : `pref33`)
 - Préfecture de l'Hérault (identifiant : `pref34`)
@@ -81,7 +82,11 @@ Vous pouvez également activer le safe mode en spécifiant la variable d'environ
 - Préfecture de la Loire-Atlantique (identifiant : `pref44`)
 - Préfecture de Maine-et-Loire (identifiant : `pref49`)
 - Préfecture de la Manche (identifiant : `pref50`)
+- Préfecture de la Haute-Marne (identifiant : `pref52`)
+- Préfecture de Meurthe-et-Moselle (identifiant : `pref54`)
+- Préfecture de la Meuse (identifiant : `pref55`)
 - Préfecture du Nord (identifiant : `pref59`)
+- Préfecture de l'Orne (identifiant : `pref61`)
 - Préfecture du Pas-de-Calais (identifiant : `pref62`)
 - Préfecture du Puy-de-Dôme (identifiant : `pref63`)
 - Préfecture des Pyrénées-Atlantiques (identifiant : `pref64`)
@@ -89,7 +94,10 @@ Vous pouvez également activer le safe mode en spécifiant la variable d'environ
 - Préfecture des Pyrénées-Orientales (identifiant : `pref66`)
 - Préfecture du Rhône (identifiant : `pref69`)
 - Préfecture de la Savoie (identifiant : `pref73`)
+- Préfecture de la Haute-Savoie (identifiant : `pref74`)
 - Préfecture de Paris (identifiant : `pref75`)
+- Préfecture de la Seine-Maritime (identifiant : `pref76`)
+- Préfecture de Seine-et-Marne (identifiant : `pref77`)
 - Préfecture de la Somme (identifiant : `pref80`)
 - Préfecture du Tarn (identifiant : `pref81`)
 - Préfecture du Var (identifiant : `pref83`)
@@ -99,8 +107,9 @@ Vous pouvez également activer le safe mode en spécifiant la variable d'environ
 - Préfecture de Seine-Saint-Denis (identifiant : `pref93`)
 - Préfecture du Val-de-Marne (identifiant : `pref94`)
 - Préfecture de Mayotte (identifiant : `pref976`)
-- Préfecture d'Île-de-France (identifiant : `prefidf`)
-- Préfecture de Provence-Alpes-Côte-d'Azur (identifiant : `prefpaca`)
+- Préfecture de la région Bretagne (identifiant : `prefbretagne`)
+- Préfecture de la région Île-de-France (identifiant : `prefidf`)
+- Préfecture de la région Provence-Alpes-Côte-d'Azur (identifiant : `prefpaca`)
 
 ## Contributions
 

cli.py

@@ -59,6 +59,7 @@ available_administrations = [
     'pref2b',
     'pref25',
     'pref29',
+    'pref30',
     'pref31',
     'pref33',
     'pref34',
@@ -69,7 +70,11 @@ available_administrations = [
     'pref44',
     'pref49',
     'pref50',
+    'pref52',
+    'pref54',
+    'pref55',
     'pref59',
+    'pref61',
     'pref62',
     'pref63',
     'pref64',
@@ -77,7 +82,10 @@ available_administrations = [
     'pref66',
     'pref69',
     'pref73',
+    'pref74',
     'pref75',
+    'pref76',
+    'pref77',
     'pref80',
     'pref81',
     'pref83',
@@ -87,6 +95,7 @@ available_administrations = [
     'pref93',
     'pref94',
     'pref976',
+    'prefbretagne',
     'prefidf',
     'prefpaca'
 ]