.gitignore

@@ -6,3 +6,4 @@ data/
 pyvenv.cfg
 output_*.log
 *.patch
+CACHEDIR.TAG

.gitlab-ci.yml

@@ -169,6 +169,11 @@ test_pref29:
     PREF: "pref29"
   extends: .default_pref
 
+test_pref30:
+  variables:
+    PREF: "pref30"
+  extends: .default_pref
+
 test_pref31:
   variables:
     PREF: "pref31"
@@ -219,16 +224,31 @@ test_pref50:
     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"
@@ -269,6 +289,16 @@ test_pref75:
     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"
@@ -314,6 +344,11 @@ test_pref976:
     PREF: "pref976"
   extends: .default_pref
 
+test_prefbretagne:
+  variables:
+    PREF: "prefbretagne"
+  extends: .default_pref
+
 test_prefidf:
   variables:
     PREF: "prefidf"

Attrap.py

@@ -9,6 +9,7 @@ import string
 import logging
 import requests
 import time
+from types import SimpleNamespace
 import datetime
 import json
 from urllib.parse import quote
@@ -169,7 +170,6 @@ class Attrap:
         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)
 
@@ -233,7 +233,7 @@ class Attrap:
             self.session.proxies.update(proxies)
             self.tor_requests = 0
 
-    def get_sub_pages(self, page_content, element, host, recursive_until_pdf):
+    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.
 
@@ -241,6 +241,7 @@ class Attrap:
         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 = []
@@ -257,7 +258,8 @@ class Attrap:
                             sub_page_content,
                             element,
                             host,
-                            recursive_until_pdf
+                            recursive_until_pdf,
+                            selenium=selenium
                         ):
                             sub_pages.append(sub_sub_page)
                     else:
@@ -274,7 +276,7 @@ class Attrap:
                     sub_pages.append(sub_page)
         return sub_pages
 
-    def get_sub_pages_with_pager(self, page, sub_page_element, pager_element, details_element, host):
+    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.
 
@@ -283,12 +285,13 @@ class Attrap:
         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').content
+            page_content = self.get_page(page, 'get', selenium=selenium).content
         else:
             page_content = page
 
@@ -321,13 +324,14 @@ class Attrap:
                 sub_page_element,
                 pager_element,
                 details_element,
-                host
+                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):
+    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.
 
@@ -337,11 +341,12 @@ class Attrap:
         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').content
+            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):
@@ -400,12 +405,17 @@ class Attrap:
         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}")
 
-        webdriver_options.add_argument("--headless")
-        webdriver_options.add_argument("--window-size=1024,768")
+        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()
 
@@ -430,6 +440,8 @@ class Attrap:
                 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)
@@ -456,13 +468,14 @@ class Attrap:
         f.write(data + "\n")
         f.close()
 
-    def get_page(self, url, method, data={}):
+    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}')
@@ -477,10 +490,15 @@ class Attrap:
                 self.last_http_request = int(time.mktime(datetime.datetime.today().timetuple()))
 
             page = None
-            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 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...')
@@ -626,6 +644,7 @@ class Attrap:
                     # 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):
@@ -635,6 +654,10 @@ class Attrap:
                         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:
@@ -726,7 +749,7 @@ class Attrap:
         """
         try:
             search = re.search(regex, string, re.IGNORECASE)
-            guessed_date = dateparser.parse(search.group(1), languages=['fr'])
+            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:

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_pref35.py

@@ -19,6 +19,7 @@ class Attrap_pref35(Attrap_prefdpt):
         Attrap_prefdpt.DptSelectWidget(
             'menu_deroulant',
             regex=year_regex,
-            css_path='div.fr-select-group select#Archives-des-RAA-liste-docs.fr-select'
+            css_path='div.fr-select-group select#Archives-des-RAA-liste-docs.fr-select',
+            type='year'
         )
     )

Attrap_pref38.py

@@ -20,7 +20,8 @@ class Attrap_pref38(Attrap_prefdpt):
     Attrap_prefdpt.select_widgets.append(
         Attrap_prefdpt.DptSelectWidget(
             'menu_deroulant',
-            regex='.*([0-9]*(?:er|ER)? [A-Za-zéÉûÛ]* [0-9]*)',
-            css_path='select#-liste-docs'
+            regex='([0-9]{1,2}[er]{0,1} [a-zéû]* [0-9]{4})',
+            css_path='select#-liste-docs',
+            type='year-month-day'
         )
     )

Attrap_pref44.py

-import os
-import datetime
-import logging
+from Attrap_prefdpt import Attrap_prefdpt
 
-from bs4 import BeautifulSoup
-from urllib.parse import unquote
 
-from Attrap import Attrap
+class Attrap_pref44(Attrap_prefdpt):
 
-logger = logging.getLogger(__name__)
-
-
-class Attrap_pref44(Attrap):
-
-    # Config
+    # Configuration de la préfecture
     hostname = 'https://www.loire-atlantique.gouv.fr'
     raa_page = f'{hostname}/Publications/Recueil-des-actes-administratifs-RAA-en-Loire-Atlantique'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
     full_name = 'Préfecture de la Loire-Atlantique'
     short_code = 'pref44'
     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):
-        pages_to_parse = []
-
-        # Parfois un RAA est mal catégorisé et se retrouve sur la page racine, donc on la parse
-        pages_to_parse.append(self.raa_page)
-
-        # On détermine quelles pages d'année parser
-        year_pages_to_parse = []
-        page_content = self.get_page(self.raa_page, 'get').content
-        year_pages = self.get_sub_pages(
-            page_content,
-            '.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:
-            year = 9999
-            try:
-                year = int(year_page['name'].strip())
-                if year is None:
-                    year = 9999
-            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'])
-
-                # Parfois un RAA est mal catégorisé et se retrouve sur la page de l'année, donc on la parse
-                pages_to_parse.append(year_page['url'])
-
-        # Pour chaque année, on cherche les sous-pages de mois
-        month_pages_to_parse = []
-        for year_page in year_pages_to_parse:
-            page_content = self.get_page(year_page, 'get').content
-            month_pages = self.get_sub_pages(
-                page_content,
-                '.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
-            )[::-1]
-
-            for month_page in month_pages:
-                pages_to_parse.append(month_page['url'])
-
-        # On parse les pages sélectionnées
-        elements = self.get_raa_with_pager(
-            pages_to_parse,
-            "ul.fr-pagination__list li a.fr-pagination__link.fr-pagination__link--next.fr-pagination__link--lg-label",
-            self.hostname
-        )[::-1]
-
-        self.parse_raa(elements, keywords)
-        self.mailer()
-
-    def get_raa_elements(self, page_content):
-        elements = []
-
-        # On récupère chaque carte avec un RAA
-        for card in BeautifulSoup(page_content, 'html.parser').select('div.fr-card.fr-card--horizontal div.fr-card__body div.fr-card__content'):
-            # On récupère le lien
-            links = card.select('h2.fr-card__title a.fr-card__link.menu-item-link')
-            # On récupère la date
-            dates_raw = card.select('div.fr-card__end p.fr-card__detail')
-
-            # Si on a toutes les infos, on continue
-            if links and links[0] and dates_raw and dates_raw[0]:
-                a = links[0]
-                date_raw = dates_raw[0]
-
-                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.get_text().strip()
-                    date = datetime.datetime.strptime(date_raw.get_text().replace('Publié le', '').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_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'
+    Attrap_prefdpt.grey_card['add_year_to_months'] = True

Attrap_pref52.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref52(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.haute-marne.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs-RAA'
+    full_name = 'Préfecture de la Haute-Marne'
+    short_code = 'pref52'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.white_card['regex']['year'] = 'Année ([0-9]{4})'

Attrap_pref54.py

@@ -18,6 +18,7 @@ class Attrap_pref54(Attrap_prefdpt):
         Attrap_prefdpt.DptSelectWidget(
             'menu_deroulant',
             regex='.* du ([0-9]*(?:er|ER)? [A-Za-zéÉûÛ]* [0-9]*)',
-            css_path='select#Liste-liste-docs'
+            css_path='select#Liste-liste-docs',
+            type='year-month-day'
         )
     )

Attrap_pref55.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref55(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.meuse.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs-RAA'
+    full_name = 'Préfecture de la Meuse'
+    short_code = 'pref55'
+    timezone = 'Europe/Paris'
+
+    # On configure le widget de menu déroulant
+    Attrap_prefdpt.select_widgets.append(
+        Attrap_prefdpt.DptSelectWidget(
+            'menu_deroulant',
+            regex='RAA année ([0-9]{4})',
+            css_path='select#Liste-des-recueils-liste-docs',
+            type='year'
+        )
+    )

Attrap_pref59.py

-import os
-import datetime
-import dateparser
-import logging
+from Attrap_prefdpt import Attrap_prefdpt
 
-from bs4 import BeautifulSoup
-from urllib.parse import unquote
 
-from Attrap import Attrap
+class Attrap_pref59(Attrap_prefdpt):
 
-logger = logging.getLogger(__name__)
-
-
-class Attrap_pref59(Attrap):
-
-    # Config
+    # Configuration de la préfecture
     hostname = 'https://www.nord.gouv.fr'
     raa_page = f'{hostname}/Publications/Recueils-des-actes-administratifs/RAA-du-departement-du-Nord'
-    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
     full_name = 'Préfecture du Nord'
     short_code = 'pref59'
     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):
-        # On récupère les pages d'années
-        year_pages = []
-        page_content = self.get_page(self.raa_page, 'get').content
-        for card in self.get_sub_pages(
-            page_content,
-            'div.fr-card__body div.fr-card__content h2.fr-card__title a',
-            self.hostname,
-            False
-        ):
-            if Attrap.guess_date(card['name'], '([0-9]{4})').year >= self.not_before.year:
-                year_pages.append(card['url'])
-
-        elements = []
-        for raa_page in year_pages:
-            page_content = self.get_page(raa_page, 'get').content
-            sub_pages = self.get_sub_pages(
-                page_content,
-                'div.fr-card__body div.fr-card__content h2.fr-card__title a',
-                self.hostname,
-                True
-            )
-            for sub_page in sub_pages[::-1]:
-                sub_page_content = self.get_page(sub_page['url'], 'get').content
-                for element in self.get_raa_elements(sub_page_content):
-                    elements.append(element)
-
-        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_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'
+    Attrap_prefdpt.grey_card['add_year_to_months'] = True

Attrap_pref61.py

+from Attrap_prefdpt import Attrap_prefdpt
+
+
+class Attrap_pref61(Attrap_prefdpt):
+
+    # Configuration de la préfecture
+    hostname = 'https://www.orne.gouv.fr'
+    raa_page = f'{hostname}/Publications/Recueil-des-Actes-Administratifs-RAA/Recueil-des-Actes-Administratifs-RAA'
+    full_name = 'Préfecture de l\'Orne'
+    short_code = 'pref61'
+    timezone = 'Europe/Paris'
+
+    # Configuration des widgets à analyser
+    Attrap_prefdpt.grey_card['regex']['year'] = 'Le Recueil des actes administratifs ([0-9]{4})'
+    Attrap_prefdpt.grey_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'
+    Attrap_prefdpt.grey_card['add_year_to_months'] = True
+    Attrap_prefdpt.white_card['regex']['month'] = '([A-Za-zéû]* [0-9]{4})'
+    Attrap_prefdpt.white_card['add_year_to_months'] = True

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_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

@@ -22,7 +22,8 @@ class Attrap_prefdpt(Attrap):
         'link_to_raa': False,
         'autodetect_links_to_raa': True,
         'follow_link_on_unrecognised_date': True,
-        'exclude': []
+        'exclude': [],
+        'add_year_to_months': False
     }
     white_card = {
         'regex': {
@@ -37,7 +38,8 @@ class Attrap_prefdpt(Attrap):
         'link_to_raa': False,
         'autodetect_links_to_raa': True,
         'follow_link_on_unrecognised_date': True,
-        'exclude': []
+        '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)
@@ -57,7 +59,7 @@ 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, exclude=[]):
+        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
@@ -65,6 +67,7 @@ class Attrap_prefdpt(Attrap):
             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
@@ -87,12 +90,24 @@ class Attrap_prefdpt(Attrap):
     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=[]):
+        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."""
@@ -100,9 +115,13 @@ class Attrap_prefdpt(Attrap):
         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
@@ -115,7 +134,8 @@ class Attrap_prefdpt(Attrap):
                     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'],
-                    exclude=self.grey_card['exclude']
+                    exclude=self.grey_card['exclude'],
+                    add_year_to_months=self.grey_card['add_year_to_months']
                 )
             )
 
@@ -128,15 +148,16 @@ class Attrap_prefdpt(Attrap):
                     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'],
-                    exclude=self.white_card['exclude']
+                    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
+            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)
@@ -145,7 +166,7 @@ class Attrap_prefdpt(Attrap):
         self.parse_raa(self.elements[::-1], keywords)
         self.mailer()
 
-    def parse_widgets(self, page_content):
+    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 = []
@@ -166,7 +187,7 @@ class Attrap_prefdpt(Attrap):
                     False
                 )
             for card in cards:
-                if card['url'] not in self.page_urls_to_parse and card['name'].strip() not in widget.exclude:
+                if card['url'] not in self.get_urls_to_parse() and card['name'].strip() not in widget.exclude:
                     date = None
                     date_is_correct = False
 
@@ -178,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:
@@ -201,7 +227,7 @@ class Attrap_prefdpt(Attrap):
                     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 is None or date.year == 9999) and widget.follow_link_on_unrecognised_date):
-                            self.page_urls_to_parse.append(card['url'])
+                            self.add_url(card['url'], date)
 
     def parse_select_widgets(self, page_url, page_content):
         for select_widget in self.select_widgets:
@@ -218,12 +244,21 @@ class Attrap_prefdpt(Attrap):
                     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 >= self.not_before) or (date.year == 9999 and select_widget.follow_link_on_unrecognised_date):
+                        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,
+                                page_url[0],
                                 'post',
                                 {
                                     select['id']: option['value']
@@ -247,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)