Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • main par défaut protégée
  • pref19
2 résultats
Blame Lien permanent
Attrap_prefdpt.py 6,21 Kio
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122 






import datetime

from bs4 import BeautifulSoup
from urllib.parse import unquote

from Attrap import Attrap


class Attrap_prefdpt(Attrap):

    # Config
    user_agent = 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0'
    year_regex = '([0-9]{4})'
    grey_card = {
        'year': None,
        'month': None
    }
    white_card = {
        'year': None,
        'month': None
    }

    grey_card_css_path = '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'  # Chemin CSS des cartes grises
    white_card_title_css_path = 'div.fr-card.fr-card--horizontal.fr-card--sm.fr-enlarge-link div.fr-card__body div.fr-card__content h2.fr-card__title a.fr-card__link'  # Chemin CSS du titre des cartes blanches
    white_card_details_css_path = 'div.fr-card.fr-card--horizontal.fr-card--sm.fr-enlarge-link div.fr-card__body div.fr-card__content div.fr-card__end p.fr-card__detail'  # Chemin CSS du détail des cartes blanches
    white_card_pager_css_path = 'ul.fr-pagination__list li a.fr-pagination__link.fr-pagination__link--next.fr-pagination__link--lg-label'  # Chemin CSS du pager des cartes blanches

    element_css_path = 'div.fr-downloads-group.fr-downloads-group--bordered ul li a,div a.fr-link.fr-link--download'  # Chemin CSS d'un RAA

    def __init__(self, data_dir):
        super().__init__(data_dir, self.user_agent)
        self.set_sleep_time(30)

        self.page_urls_to_parse = [self.raa_page]
        self.elements = []

    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_grey_cards(page_content)  # On parse les cartes grises
            self.parse_white_cards(page_content)  # On parse les cartes blanches
            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

        self.parse_raa(self.elements[::-1], keywords)
        self.mailer()

    def parse_grey_cards(self, page_content):
        for card in self.get_sub_pages(
            page_content,
            self.grey_card_css_path,
            self.hostname,
            False
        ):
            date = None

            if self.grey_card['year']:
                date = Attrap.guess_date(card['name'].strip(), self.grey_card['year']).replace(day=1, month=1)
                if date >= self.not_before.replace(day=1, month=1) and card['url'] not in self.page_urls_to_parse:
                    # Si aucune date n'a été détectée, l'année est à 9999. Mais on n'inclut l'URL que s'il n'y a pas de regex de mois à tester après.
                    if not self.grey_card['month'] or (self.grey_card['month'] and date.year < 9999):
                        self.page_urls_to_parse.append(card['url'])

            # On cherche avec le regex de mois si aucun regex d'année n'est configuré ou si ce dernier n'a pas permis de trouver une date
            if self.grey_card['month'] and (not date or date.year == 9999):
                date = Attrap.guess_date(card['name'].strip(), self.grey_card['month']).replace(day=1)
                if date >= self.not_before.replace(day=1) and card['url'] not in self.page_urls_to_parse:
                    self.page_urls_to_parse.append(card['url'])

    def parse_white_cards(self, page_content):
        for card in self.get_sub_pages_with_pager(
            page_content,
            self.white_card_title_css_path,  # Carte avec un élément (mois ou arrêté seul)
            self.white_card_pager_css_path,  # Pager
            self.white_card_details_css_path,  # Détails (avec la date de publication)
            self.hostname
        ):
            date = None

            # Pour les cartes blanches, on parse le titre si un regex a été spécifié
            if self.white_card['year']:
                date = Attrap.guess_date(card['name'].strip(), self.white_card['year']).replace(day=1, month=1)
                if date >= self.not_before.replace(day=1, month=1) and card['url'] not in self.page_urls_to_parse:
                    # Si aucune date n'a été détectée, l'année est à 9999. Mais on n'inclut l'URL que s'il n'y a pas de regex de mois à tester après.
                    if not self.white_card['month'] or (self.white_card['month'] and date.year < 9999):
                        self.page_urls_to_parse.append(card['url'])

            # On cherche avec le regex de mois si aucun regex d'année n'est configuré ou si ce dernier n'a pas permis de trouver une date
            if self.white_card['month'] and (not date or date.year == 9999):
                date = Attrap.guess_date(card['name'].strip(), self.white_card['month']).replace(day=1)
                if date >= self.not_before.replace(day=1) and card['url'] not in self.page_urls_to_parse:
                    self.page_urls_to_parse.append(card['url'])

            # On regarde aussi la date dans les détails de la carte
            if not date or date.year == 9999:
                date = datetime.datetime.strptime(card['details'].replace('Publié le ', '').strip(), '%d/%m/%Y')
                if date >= self.not_before and card['url'] not in self.page_urls_to_parse:
                    self.page_urls_to_parse.append(card['url'])

    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(self.element_css_path):
            if a.get('href'):
                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