From f02a23f0324bab019f1c8fce3e35af23840d08c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20GUEZO?= Date: Fri, 6 Feb 2026 18:55:37 +0100 Subject: [PATCH 1/3] modif(main.py): restructuration de la classe --- main.py | 158 ++++++++++++++++++++++++++------------------------- test_main.py | 7 ++- 2 files changed, 85 insertions(+), 80 deletions(-) diff --git a/main.py b/main.py index acc276a..11fefb6 100644 --- a/main.py +++ b/main.py @@ -1,90 +1,94 @@ -import requests -from typing import Any, Dict -from bs4 import BeautifulSoup -import json +from sys import stderr +from typing import cast +from requests import Response, Session +from bs4 import BeautifulSoup, Tag +from json import JSONDecodeError, loads class Scraper: - """ - Scraper est une classe qui permet de gerer - de façon dynamique des requetes uniquement - sur le serveur https de Millesina - """ + def __init__(self, subdir: str = "") -> None: + self._url: str = "https://www.millemisa.fr/" + self._session: Session = Session() - def __init__(self, subdir: str = None): - """ - Initialise la session de scraping et récupère la page d'accueil. - """ - # Très utile pour éviter de renvoyer toujours les mêmes handshake - # TCP et d'avoir toujours une connexion constante avec le server - self._session: requests.Session = requests.Session() - self._url: str = "https://www.millesima.fr/" - self._soup = self.getsoup(subdir) + self._latest_request: tuple[(str, Response | None)] = ("", None) - def _request( - self, subdir: str, use_cache: bool = True - ) -> requests.Response | requests.HTTPError: - """ - Effectue une requête GET sur le serveur Millesima. - :param subdir: Le sous-répertoire ou chemin de l'URL (ex: "/vins"). - :param use_cache: Si True, retourne la réponse précédente si l'URL est - identique. - :return: requests.Response: L'objet réponse de la requête. - :rtype: requests.HTTPError: Si le serveur renvoie un code d'erreur - (4xx, 5xx). - """ + def _request(self, subdir: str) -> Response: + target_url: str = self._url + subdir.lstrip("/") + response: Response = self._session.get(url=target_url, timeout=10) + response.raise_for_status() + return response - target_url: str = f"{self._url}{subdir.lstrip('/')}" if subdir is \ - not None else self._url - # Éviter un max possible de faire des requetes au servers même - # en ayant un tunnel tcp avec le paramètre `use_cache` que si - # activer, va comparer l'url avec l'url précédant - if use_cache and hasattr(self, "_response") \ - and self._response is not None: - if self._response.url == target_url: - return self._response + def getresponse(self, subdir: str = "") -> Response: + rq_subdir, rq_response = self._latest_request - self._response: requests.Response = self._session.get( - target_url, timeout=10) - self._response.raise_for_status() + if rq_response is None or subdir != rq_subdir: + request: Response = self._request(subdir) + self._latest_request = (subdir, request) + return request - return self._response + return rq_response - def getsoup(self, subdir: str = None - ) -> BeautifulSoup | requests.HTTPError: - """ - Récupère le contenu HTML d'une page et le transforme en objet - BeautifulSoup. + def getsoup(self, subdir: str = "") -> BeautifulSoup: + markup: str = self.getresponse(subdir).text + return BeautifulSoup(markup, features="html.parser") - :param subdir: Le chemin de la page. Si None, retourne la soupe - actuelle. - :return: BeautifulSoup: L'objet parsé pour extraction de données. - :rtype: BeautifulSoup - """ - if not hasattr(self, "_soup") or subdir is not None: - self._request(subdir) - self._soup = BeautifulSoup(self._response.text, "html.parser") - return self._soup + # def getjsondata(self, subdir: str = "", id: str = "__NEXT_DATA__") -> dict[str, object]: + # soup: BeautifulSoup = self.getsoup(subdir) + # # On s'assure que c'est bien un Tag pour avoir accès à .string + # script = soup.find("script", id=id) - def get_json_data(self) -> Dict[str, Any]: - """ - Extrait les données JSON contenues dans la balise __NEXT_DATA__ du - site. - Beaucoup de sites modernes (Next.js) stockent leur état initial dans - une balise + + + """ + m.get("https://www.millesima.fr/nino-negri-5-stelle-sfursat-2022.html", text=html_product) + + # on return m sans fermer le server qui simule la page + yield m -def test_getProductName(): - assert ( - Scraper("chateau-gloria-2016.html").get_json_data()["productName"] - == "Château Gloria 2016" - ) +@pytest.fixture +def scraper() -> Scraper: + return Scraper() + + +def test_soup(scraper: Scraper): + h1: Tag | None = scraper.getsoup().find("h1") + + assert isinstance(h1, Tag) + assert h1.text == "MILLESIMA" + + +def test_getProductName(scraper: Scraper): + jsondata = scraper.getjsondata("nino-negri-5-stelle-sfursat-2022.html") + assert jsondata["productName"] == "Nino Negri : 5 Stelle Sfursat 2022" + assert len(jsondata["items"]) > 0 + assert jsondata["items"][0]["offerPrice"] == 390 \ No newline at end of file From a81d5be5a98d4267fe9fd65f59c21a171551725a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20GUEZO?= Date: Fri, 6 Feb 2026 21:21:52 +0100 Subject: [PATCH 3/3] ajout: commentaires et les requirements --- main.py | 106 ++++++++++++++++++++++++++++++++--------------- requirements.txt | 4 +- 2 files changed, 75 insertions(+), 35 deletions(-) diff --git a/main.py b/main.py index 11fefb6..078fa91 100644 --- a/main.py +++ b/main.py @@ -6,19 +6,54 @@ from json import JSONDecodeError, loads class Scraper: - def __init__(self, subdir: str = "") -> None: - self._url: str = "https://www.millemisa.fr/" - self._session: Session = Session() + """ + Scraper est une classe qui permet de gerer + de façon dynamique des requetes uniquement + sur le serveur https de Millesima + """ + def __init__(self) -> None: + """ + Initialise la session de scraping. + """ + self._url: str = "https://www.millesima.fr/" + # Très utile pour éviter de renvoyer toujours les mêmes handshake + # TCP et d'avoir toujours une connexion constante avec le server + self._session: Session = Session() + # Système de cache pour éviter de solliciter le serveur inutilement self._latest_request: tuple[(str, Response | None)] = ("", None) def _request(self, subdir: str) -> Response: + """ + Effectue une requête GET sur le serveur Millesima. + + Args: + subdir (str): Le sous-répertoire ou chemin de l'URL (ex: "/vins"). + + Returns: + Response: L'objet réponse de la requête. + + Raise: + HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx). + """ target_url: str = self._url + subdir.lstrip("/") response: Response = self._session.get(url=target_url, timeout=10) response.raise_for_status() return response def getresponse(self, subdir: str = "") -> Response: + """ + Récupère la réponse d'une page, en utilisant le cache si possible. + + Args: + subdir (str, optional): Le chemin de la page. + + Returns: + Response: L'objet réponse (cache ou nouvelle requête). + + Raise: + HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx). + """ rq_subdir, rq_response = self._latest_request if rq_response is None or subdir != rq_subdir: @@ -29,47 +64,50 @@ class Scraper: return rq_response def getsoup(self, subdir: str = "") -> BeautifulSoup: + """ + Récupère le contenu HTML d'une page et le transforme en objet BeautifulSoup. + + Args: + subdir (str, optional): Le chemin de la page. + + Returns: + BeautifulSoup: L'objet parsé pour extraction de données. + + Raise: + HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx). + """ markup: str = self.getresponse(subdir).text return BeautifulSoup(markup, features="html.parser") - # def getjsondata(self, subdir: str = "", id: str = "__NEXT_DATA__") -> dict[str, object]: - # soup: BeautifulSoup = self.getsoup(subdir) - # # On s'assure que c'est bien un Tag pour avoir accès à .string - # script = soup.find("script", id=id) - - # if isinstance(script, Tag) and script.string: - # try: - # # On commence avec le dictionnaire complet - # current_data: Any = loads(script.string) - - # # Parcours de la structure imbriquée - # keys = ['props', 'pageProps', 'initialReduxState', 'product', 'content'] - # for key in keys: - # if isinstance(current_data, dict) and key in current_data: - # current_data = current_data[key] - # else: - # # Si une clé manque, on lève une erreur explicite - # raise ValueError(f"Clé manquante dans le JSON : {key}") - - # # On garantit à Pyright que le résultat final est un dictionnaire - # if isinstance(current_data, dict): - # return cast(dict[str, object], current_data) - - # except (decoder.JSONDecodeError, ValueError) as e: - # print(f"Erreur lors de l'extraction JSON : {e}", file=stderr) - - # return {} - def getjsondata( self, subdir: str = "", id: str = "__NEXT_DATA__" ) -> dict[str, object]: + """ + Extrait les données JSON contenues dans la balise __NEXT_DATA__ du site. + Beaucoup de sites modernes (Next.js) stockent leur état initial dans + une balise