đ·ïž The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
Python aiai-scrapingautomationcrawlercrawlingcrawling-pythondatadata-extractionmcpmcp-serverplaywrightpythonscrapingselectorsstealthweb-scraperweb-scrapingweb-scraping-pythonwebscrapingxpath
docs: Add French docs for the website
Karim shoaird7182358bae6
diff --git a/docs/README_FR.md b/docs/README_FR.mdindex b6f5944..32c73f5 100644--- a/docs/README_FR.md+++ b/docs/README_FR.md@@ -1,68 +1,68 @@<!-- mcp-name: io.github.D4Vinci/Scrapling --><h1 align="center">- <a href="https://scrapling.readthedocs.io">+ <a href="https://scrapling.readthedocs.io/en/latest/fr/"><picture><source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_dark.svg?sanitize=true">- <img alt="Scrapling Poster" src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_light.svg?sanitize=true">+ <img alt="Couverture de Scrapling" src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_light.svg?sanitize=true"></picture></a><br>- <small>Effortless Web Scraping for the Modern Web</small>+ <small>Extrayez simplement les donnĂ©es du web moderne</small></h1><p align="center"><a href="https://github.com/D4Vinci/Scrapling/actions/workflows/tests.yml" alt="Tests"><img alt="Tests" src="https://github.com/D4Vinci/Scrapling/actions/workflows/tests.yml/badge.svg"></a>- <a href="https://badge.fury.io/py/Scrapling" alt="PyPI version">- <img alt="PyPI version" src="https://badge.fury.io/py/Scrapling.svg"></a>+ <a href="https://badge.fury.io/py/Scrapling" alt="Version sur PyPI">+ <img alt="Version sur PyPI" src="https://badge.fury.io/py/Scrapling.svg"></a><a href="https://hub.docker.com/r/pyd4vinci/scrapling" target="_blank">- <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/pyd4vinci/scrapling?labelColor=%20%23FDB062&logo=Docker&labelColor=%20%23528bff"></a>- <a href="https://clickpy.clickhouse.com/dashboard/scrapling" rel="nofollow"><img src="https://img.shields.io/pypi/dm/scrapling" alt="PyPI package downloads"></a>- <a href="https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html" alt="AI Agent Skill">- <img alt="Static Badge" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Fai%2Fagent-skill.html"></a>- <a href="https://clawhub.ai/D4Vinci/scrapling-official" alt="OpenClaw Skill">- <img alt="OpenClaw Skill" src="https://img.shields.io/badge/Clawhub-darkred?style=flat&label=OpenClaw&link=https%3A%2F%2Fclawhub.ai%2FD4Vinci%2Fscrapling-official"></a>+ <img alt="TĂ©lĂ©chargements Docker" src="https://img.shields.io/docker/pulls/pyd4vinci/scrapling?labelColor=%20%23FDB062&logo=Docker&labelColor=%20%23528bff"></a>+ <a href="https://clickpy.clickhouse.com/dashboard/scrapling" rel="nofollow"><img src="https://img.shields.io/pypi/dm/scrapling" alt="TĂ©lĂ©chargements du paquet sur PyPI"></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/ai/agent-skill.html" alt="Skill pour agents IA">+ <img alt="Badge Agent Skill" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Ffr%2Fai%2Fagent-skill.html"></a>+ <a href="https://clawhub.ai/D4Vinci/scrapling-official" alt="Skill pour OpenClaw">+ <img alt="Skill pour OpenClaw" src="https://img.shields.io/badge/Clawhub-darkred?style=flat&label=OpenClaw&link=https%3A%2F%2Fclawhub.ai%2FD4Vinci%2Fscrapling-official"></a><br/><a href="https://discord.gg/EMgGbDceNQ" alt="Discord" target="_blank"><img alt="Discord" src="https://img.shields.io/discord/1360786381042880532?style=social&logo=discord&link=https%3A%2F%2Fdiscord.gg%2FEMgGbDceNQ"></a>- <a href="https://x.com/Scrapling_dev" alt="X (formerly Twitter)">- <img alt="X (formerly Twitter) Follow" src="https://img.shields.io/twitter/follow/Scrapling_dev?style=social&logo=x&link=https%3A%2F%2Fx.com%2FScrapling_dev">+ <a href="https://x.com/Scrapling_dev" alt="X (anciennement Twitter)">+ <img alt="Suivre sur X (anciennement Twitter)" src="https://img.shields.io/twitter/follow/Scrapling_dev?style=social&logo=x&link=https%3A%2F%2Fx.com%2FScrapling_dev"></a><br/>- <a href="https://pypi.org/project/scrapling/" alt="Supported Python versions">- <img alt="Supported Python versions" src="https://img.shields.io/pypi/pyversions/scrapling.svg"></a>+ <a href="https://pypi.org/project/scrapling/" alt="Versions de Python compatibles">+ <img alt="Versions de Python compatibles" src="https://img.shields.io/pypi/pyversions/scrapling.svg"></a></p><p align="center">- <a href="https://scrapling.readthedocs.io/en/latest/parsing/selection.html"><strong>MĂ©thodes de sĂ©lection</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/parsing/selection.html"><strong>MĂ©thodes de sĂ©lection</strong></a>·- <a href="https://scrapling.readthedocs.io/en/latest/fetching/choosing.html"><strong>Fetchers</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/fetching/choosing.html"><strong>Fetchers</strong></a>·- <a href="https://scrapling.readthedocs.io/en/latest/spiders/architecture.html"><strong>Spiders</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/spiders/architecture.html"><strong>Spiders</strong></a>·- <a href="https://scrapling.readthedocs.io/en/latest/spiders/proxy-blocking.html"><strong>Rotation de proxy</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/spiders/proxy-blocking.html"><strong>Rotation des proxies</strong></a>·- <a href="https://scrapling.readthedocs.io/en/latest/cli/overview.html"><strong>CLI</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/cli/overview.html"><strong>CLI</strong></a>·- <a href="https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html"><strong>MCP</strong></a>+ <a href="https://scrapling.readthedocs.io/en/latest/fr/ai/mcp-server.html"><strong>MCP</strong></a></p>-Scrapling est un framework de Web Scraping en Python qui rĂ©unit des requĂȘtes HTTP rapides, des navigateurs furtifs, un parser puissant et du crawling concurrent dans une seule bibliothĂšque.+Scrapling est un framework de web scraping pour Python. Il rĂ©unit des requĂȘtes HTTP rapides, des navigateurs furtifs, lâanalyse de pages et lâexploration simultanĂ©e de sites dans une seule bibliothĂšque.-Extrayez des donnĂ©es de pages statiques, exĂ©cutez JavaScript, interagissez avec les sites web et rĂ©cupĂ©rez les donnĂ©es des appels API qui les alimentent. CrĂ©ez des crawlers avec des sessions rĂ©utilisables, la rotation de proxys, des rĂ©essais automatiques, la pause/reprise et des exports de donnĂ©es intĂ©grĂ©s.+Extrayez les donnĂ©es de pages statiques, exĂ©cutez JavaScript, interagissez avec les sites et accĂ©dez aux API quâils utilisent. CrĂ©ez des crawlers avec des sessions rĂ©utilisables, la rotation des proxies, de nouvelles tentatives automatiques, la pause et la reprise, et des exports intĂ©grĂ©s.-Utilisez-le depuis Python, le terminal ou votre agent IA grĂące Ă son serveur MCP et son Agent Skill. De l'extraction de quelques champs Ă la collecte d'un site web entier en Markdown propre, Scrapling couvre tout le processus de scraping.+Utilisez Scrapling depuis Python, le terminal ou votre agent IA grĂące au serveur MCP et Ă lâAgent Skill. Il couvre tout le processus, de lâextraction de quelques champs Ă lâenregistrement dâun site entier en fichiers Markdown propres.## Ce que vous pouvez faire avec Scrapling-- **[RĂ©cupĂ©rer des pages et interagir](https://scrapling.readthedocs.io/en/latest/fetching/choosing.html)** : RequĂȘtes HTTP rapides, navigateurs furtifs, rendu JavaScript, gestion de Cloudflare Turnstile/Interstitial, sessions persistantes et capture des appels API en arriĂšre-plan.-- **[Analyser et extraire](https://scrapling.readthedocs.io/en/latest/parsing/selection.html)** : CSS, XPath, recherche par texte et expressions rĂ©guliĂšres, suivi adaptatif des Ă©lĂ©ments, recherche d'Ă©lĂ©ments similaires et sortie en Markdown propre.-- **[Crawler et exporter](https://scrapling.readthedocs.io/en/latest/spiders/getting-started.html)** : Spiders concurrents, rotation de proxys, rĂ©essais, AutoThrottle, pause/reprise, streaming, modĂšles prĂȘts Ă l'emploi et exports JSON/JSONL/CSV/XML.-- **[Scraper avec l'IA ou depuis votre terminal](https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html)** : Un serveur MCP pour que les agents IA naviguent et extraient des donnĂ©es, un Agent Skill, des commandes CLI et un shell interactif.+- **[RĂ©cupĂ©rer des pages et interagir](https://scrapling.readthedocs.io/en/latest/fr/fetching/choosing.html)** : RequĂȘtes HTTP rapides, navigateurs furtifs, exĂ©cution de JavaScript, gestion de Cloudflare Turnstile et Interstitial, sessions persistantes et capture des rĂ©ponses des API en arriĂšre-plan.+- **[Analyser et extraire](https://scrapling.readthedocs.io/en/latest/fr/parsing/selection.html)** : Recherche par CSS, XPath, texte et expressions rĂ©guliĂšres, suivi des Ă©lĂ©ments aprĂšs un changement de page, recherche dâĂ©lĂ©ments similaires et sortie en Markdown propre.+- **[Explorer et exporter](https://scrapling.readthedocs.io/en/latest/fr/spiders/getting-started.html)** : Spiders simultanĂ©s, rotation des proxies, nouvelles tentatives, AutoThrottle, pause et reprise, rĂ©sultats en streaming, modĂšles prĂȘts Ă lâemploi et exports en JSON, JSONL, CSV et XML.+- **[Extraire avec lâIA ou depuis le terminal](https://scrapling.readthedocs.io/en/latest/fr/ai/mcp-server.html)** : Un serveur MCP pour que les agents IA naviguent et extraient des donnĂ©es, une Agent Skill, des commandes CLI et un shell interactif.-Commencez par une seule page :+Commencez par une seule page :```pythonfrom scrapling.fetchers import Fetcher@@ -72,7 +72,7 @@ quotes = page.css('.quote .text::text').getall()print(quotes)```-Ou montez en charge avec un Spider :+Ou extrayez plus de donnĂ©es avec un spider :```pythonfrom scrapling.spiders import Spider, Response@@ -93,7 +93,7 @@ print(len(result.items))result.items.to_json("quotes.json")```-Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json`.+Cet exemple affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json`.<p align="center"><a href="https://dataimpulse.com/?utm_source=scrapling&utm_medium=banner&utm_campaign=scrapling" target="_blank" style="display:flex; justify-content:center; padding:4px 0;">@@ -110,7 +110,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://go.nodemaven.com/scraplingseptember" target="_blank">NodeMaven</a> - le fournisseur de proxys le plus efficace pour le Web Scraping et l'automatisation, avec la meilleure qualitĂ© d'IP du marchĂ©. Utilisez le code SCRAPLING35 pour obtenir 35% de rĂ©duction.+ <a href="https://go.nodemaven.com/scraplingseptember" target="_blank">NodeMaven</a> - le fournisseur de proxys le plus efficace pour le Web Scraping et l'automatisation, avec la meilleure qualitĂ© d'IP du marchĂ©. Utilisez le code SCRAPLING35 pour obtenir 35âŻ% de rĂ©duction.</td></tr><tr>@@ -132,7 +132,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json<td><a href="https://evomi.com?utm_source=github&utm_medium=banner&utm_campaign=d4vinci-scrapling"><b>Evomi</b>- </a> : proxies rĂ©sidentiels Ă partir de 0,49 $/Go. Navigateur de scraping avec Chromium entiĂšrement falsifiĂ©, IPs rĂ©sidentielles, rĂ©solution automatique de CAPTCHA et contournement anti-bot. </br>+ </a> : proxies rĂ©sidentiels Ă partir de 0,49 $/Go. Navigateur de scraping avec Chromium dont lâempreinte est entiĂšrement modifiĂ©e, IPs rĂ©sidentielles, rĂ©solution automatique de CAPTCHA et contournement anti-bot. </br><b>API Scraper pour des rĂ©sultats sans tracas. IntĂ©grations MCP et N8N disponibles.</b></td></tr>@@ -143,7 +143,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://tikhub.io/?utm_source=github.com/D4Vinci/Scrapling&utm_medium=marketing_social&utm_campaign=retargeting&utm_content=carousel_ad" target="_blank">TikHub.io</a> propose plus de 900 APIs stables sur plus de 16 plateformes, dont TikTok, X, YouTube et Instagram, avec plus de 40M de jeux de donnĂ©es. <br /> Propose Ă©galement des <a href="https://ai.tikhub.io/?ref=KarimShoair" target="_blank">modĂšles IA Ă prix rĂ©duit</a> - Claude, GPT, GEMINI et plus, jusqu'Ă 71% de rĂ©duction.+ <a href="https://tikhub.io/?utm_source=github.com/D4Vinci/Scrapling&utm_medium=marketing_social&utm_campaign=retargeting&utm_content=carousel_ad" target="_blank">TikHub.io</a> propose plus de 900 API stables sur plus de 16 plateformes, dont TikTok, X, YouTube et Instagram, avec plus de 40 millions de jeux de donnĂ©es. <br /> Propose Ă©galement des <a href="https://ai.tikhub.io/?ref=KarimShoair" target="_blank">modĂšles IA Ă prix rĂ©duit</a> - Claude, GPT, GEMINI et plus, jusqu'Ă 71âŻ% de rĂ©duction.</td></tr><tr>@@ -163,7 +163,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://www.swiftproxy.net/?ref=D4Vinci" target="_blank">Swiftproxy</a> propose des proxys rĂ©sidentiels Ă©volutifs avec plus de 80 millions d'IPs dans plus de 195 pays, offrant des connexions rapides et fiables, une rotation automatique et de solides performances anti-blocage. Essai gratuit disponible.+ <a href="https://www.swiftproxy.net/?ref=D4Vinci" target="_blank">Swiftproxy</a> propose des proxys rĂ©sidentiels Ă©volutifs avec plus de 80 millions d'IPs dans plus de 195 pays, offrant des connexions rapides et fiables, une rotation automatique et des fonctions pour Ă©viter les blocages. Essai gratuit disponible.</td></tr><tr>@@ -173,7 +173,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://byteful.com/?utm_source=github&utm_medium=github-sponsor&utm_campaign=scrapling_github_sponsor" target="_blank">Byteful</a> fournit des proxys rĂ©sidentiels, mobiles, ISP et de centres de donnĂ©es issus de sources Ă©thiques, ainsi que des outils de scraping et dâautomatisation par IA. Utilisez le code SCRAPLING10 pour obtenir 10 % de rĂ©duction sur les proxys rĂ©sidentiels.+ <a href="https://byteful.com/?utm_source=github&utm_medium=github-sponsor&utm_campaign=scrapling_github_sponsor" target="_blank">Byteful</a> fournit des proxys rĂ©sidentiels, mobiles, ISP et de centres de donnĂ©es issus de sources Ă©thiques, ainsi que des outils de scraping et dâautomatisation par IA. Utilisez le code SCRAPLING10 pour obtenir 10âŻ% de rĂ©duction sur les proxys rĂ©sidentiels.</td></tr><tr>@@ -183,7 +183,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://proxylane.dev/?utm_source=scrapling&utm_medium=partnership&utm_campaign=scrapling_platinum_202609&utm_content=github_readme" target="_blank">ProxyLane</a> : RĂ©duisez les blocages et les CAPTCHAs de 90 %. 28 millions dâadresses IP rĂ©sidentielles premium pour le scraping web intensif. 195 pays. Ciblage par ville/ISP/code postal. Sessions fixes ou rotatives. Trafic sans expiration Ă partir de $2/GB. Code <strong>SCRAPEANDTAKE</strong> : <em>25 % de rĂ©duction</em>.+ <a href="https://proxylane.dev/?utm_source=scrapling&utm_medium=partnership&utm_campaign=scrapling_platinum_202609&utm_content=github_readme" target="_blank">ProxyLane</a> : RĂ©duisez les blocages et les CAPTCHAs de 90âŻ%. 28 millions dâadresses IP rĂ©sidentielles premium pour le scraping web intensif. 195 pays. Ciblage par ville/ISP/code postal. Sessions fixes ou rotatives. Trafic sans expiration Ă partir de $2/GB. Code <strong>SCRAPEANDTAKE</strong> : <em>25âŻ% de rĂ©duction</em>.</td></tr><tr>@@ -193,7 +193,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</a></td><td>- <a href="https://www.lundproxy.com?utm_source=github&utm_medium=sponsorship&utm_campaign=scrapling&utm_content=text" target="_blank">LundProxy</a> : Ne payez plus par GB. Trafic rĂ©sidentiel illimitĂ©, plus de 100 millions dâIP, plus de 190 pays. Payez selon la bande passante. Demandez un essai gratuit de proxies rĂ©sidentiels Ă 50 Mbps.+ <a href="https://www.lundproxy.com?utm_source=github&utm_medium=sponsorship&utm_campaign=scrapling&utm_content=text" target="_blank">LundProxy</a> : Ne payez plus par GB. Trafic rĂ©sidentiel illimitĂ©, plus de 100 millions dâIP, plus de 190 pays. Payez selon la bande passante. Demandez un essai gratuit de proxies rĂ©sidentiels Ă 50 Mbps.</td></tr><tr>@@ -208,7 +208,7 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json</tr></table>-<i><sub>Vous souhaitez afficher votre publicitĂ© ici ? Cliquez [ici](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=586646)</sub></i>+<i><sub>Vous souhaitez afficher votre publicitĂ© ici ? Cliquez [ici](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=586646)</sub></i># Sponsors<!-- sponsors -->@@ -226,71 +226,77 @@ Cela affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json<!-- /sponsors -->-<i><sub>Vous souhaitez afficher votre publicitĂ© ici ? Cliquez [ici](https://github.com/sponsors/D4Vinci) et choisissez le niveau qui vous convient !</sub></i>+<i><sub>Vous souhaitez afficher votre publicitĂ© ici ? Cliquez [ici](https://github.com/sponsors/D4Vinci) et choisissez le niveau qui vous convient !</sub></i>----## FonctionnalitĂ©s principales--### Spiders - Un framework de crawling complet-- đ·ïž **API Spider Ă la Scrapy** : DĂ©finissez des spiders avec `start_urls`, des callbacks async `parse` et des objets `Request`/`Response`.-- ⥠**Crawling concurrent** : Limites de concurrence configurables, throttling par domaine et dĂ©lais de tĂ©lĂ©chargement.-- đ **Support multi-sessions** : Interface unifiĂ©e pour les requĂȘtes HTTP et les navigateurs headless furtifs dans un seul spider - routez les requĂȘtes vers diffĂ©rentes sessions par ID.-- đŸ **Pause et reprise** : Enregistrez les requĂȘtes en attente et les URL dĂ©jĂ vues avec `crawldir`. ArrĂȘtez proprement avec Ctrl+C, puis relancez avec le mĂȘme dossier.-- đĄ **Mode streaming** : Diffusez les Ă©lĂ©ments scrapĂ©s en temps rĂ©el via `async for item in spider.stream()` avec des statistiques en temps rĂ©el - idĂ©al pour les UI, pipelines et crawls de longue durĂ©e.-- đĄïž **DĂ©tection des requĂȘtes bloquĂ©es** : DĂ©tection automatique et rĂ©essai des requĂȘtes bloquĂ©es avec une logique personnalisable.-- đŠ **AutoThrottle** : Fini les dĂ©lais devinĂ©s. Le spider ajuste tout seul le dĂ©lai de chaque domaine selon la vitesse de rĂ©ponse du site, le double (ou attend ce que demande `Retry-After`) dĂšs que le site se met Ă vous bloquer ou Ă vous limiter, et rĂ©accĂ©lĂšre quand cela s'arrĂȘte.-- đ€ **ConformitĂ© robots.txt** : Flag optionnel `robots_txt_obey` qui respecte les directives `Disallow`, `Crawl-delay` et `Request-rate` avec mise en cache par domaine.-- đ§Ș **Mode dĂ©veloppement** : Mettez les rĂ©ponses en cache sur le disque lors de la premiĂšre exĂ©cution et rejouez-les lors des exĂ©cutions suivantes - itĂ©rez sur votre logique `parse()` sans solliciter Ă nouveau les serveurs cibles.-- đ§© **ModĂšles de Spider prĂȘts Ă l'emploi** : Ăvitez le code rĂ©pĂ©titif avec `CrawlSpider` pour le suivi de liens par rĂšgles, `SitemapSpider` pour les crawls pilotĂ©s par sitemap/robots.txt, `XMLFeedSpider`/`CSVFeedSpider` pour parcourir des flux XML/RSS et CSV et `ShopifySpider` pour collecter les produits des boutiques Shopify publiques, un Ă©lĂ©ment par variante.-- đ **Extraction de liens** : Un primitif `LinkExtractor` autonome avec motifs allow/deny, filtres de domaines, dĂ©limitation CSS/XPath, filtrage des extensions et canonicalisation - utilisable dans les modĂšles ou seul.-- đŠ **Export intĂ©grĂ©** : Exportez les rĂ©sultats via des hooks et votre propre pipeline ou les exports JSON/JSONL/CSV/XML intĂ©grĂ©s avec `result.items.to_json()`, `to_jsonl()`, `to_csv()` et `to_xml()`.--### RĂ©cupĂ©ration avancĂ©e de sites web avec support de sessions-- **RequĂȘtes HTTP** : RequĂȘtes HTTP rapides et furtives avec la classe `Fetcher`. Peut imiter l'empreinte TLS des navigateurs, les headers et utiliser HTTP/3.-- **Chargement dynamique** : RĂ©cupĂ©rez des sites web dynamiques avec une automatisation complĂšte du navigateur via la classe `StealthyFetcher` supportant Chromium de Playwright et Google Chrome.-- **Contournement anti-bot** : CapacitĂ©s de furtivitĂ© avancĂ©es avec `StealthyFetcher` et falsification des empreintes. Contourne facilement tous les types de Turnstile/Interstitial de Cloudflare grĂące Ă l'automatisation.-- **Gestion de sessions** : Support de sessions persistantes avec les classes `FetcherSession` et `StealthySession` pour la gestion des cookies et de l'Ă©tat entre les requĂȘtes.-- **Rotation de proxy** : `ProxyRotator` intĂ©grĂ© avec des stratĂ©gies de rotation cycliques ou personnalisĂ©es sur tous les types de sessions, plus des surcharges de proxy par requĂȘte.-- **Blocage de domaines et publicitĂ©s** : Bloquez les requĂȘtes vers des domaines spĂ©cifiques (et leurs sous-domaines) ou activez le blocage de publicitĂ©s intĂ©grĂ© (~3 500 domaines publicitaires/traceurs connus) dans les fetchers basĂ©s sur navigateur.-- **PrĂ©vention des fuites DNS** : Support optionnel de DNS-over-HTTPS pour router les requĂȘtes DNS via le DoH de Cloudflare, empĂȘchant les fuites DNS lors de l'utilisation de proxies.-- **Navigateurs distants** : Au lieu de lancer un navigateur localement, connectez-vous via CDP avec `cdp_url` Ă un navigateur dĂ©jĂ en cours d'exĂ©cution, qu'il soit sur la mĂȘme machine, sur un autre hĂŽte ou chez un fournisseur de navigateurs managĂ©s. Vous pouvez aussi pointer n'importe quel fetcher navigateur vers votre propre build de Chromium avec `executable_path`.-- **Capture des API en arriĂšre-plan** : Activez `record_requests=True` dans une session de navigateur, puis recherchez les rĂ©ponses enregistrĂ©es avec `session.network.search(limit=None)`. Lisez les donnĂ©es API et les erreurs HTTP entre les chargements de pages sans renvoyer les requĂȘtes. L'historique est limitĂ© et conserve les corps de rĂ©ponse textuels.-- **Support async** : Support async complet sur tous les fetchers et classes de sessions async dĂ©diĂ©es.--### Analyse et extraction de donnĂ©es-- đ **Suivi intelligent des Ă©lĂ©ments** : Relocalisez les Ă©lĂ©ments aprĂšs des modifications de site web en utilisant des algorithmes de similaritĂ© intelligents.-- đŻ **SĂ©lection flexible intelligente** : SĂ©lecteurs CSS, sĂ©lecteurs XPath, recherche par filtres, recherche textuelle, recherche regex et plus encore.-- đ **Trouver des Ă©lĂ©ments similaires** : Localisez automatiquement des Ă©lĂ©ments similaires aux Ă©lĂ©ments trouvĂ©s.--### FonctionnalitĂ©s IA-- đ€ **Serveur MCP** : Laissez les chatbots et agents IA (Claude/Cursor/etc.) scraper via Scrapling avec les requĂȘtes HTTP, les actions du navigateur, les captures dâĂ©cran, les connexions enregistrĂ©es et les rĂ©ponses API en arriĂšre-plan. Il utilise notre navigateur furtif avec les bons outils pour permettre aux modĂšles IA adaptĂ©s de contourner tous les CAPTCHA rencontrĂ©s pendant leur travail (sans parler de notre solveur Cloudflare). Il combine de nombreuses mĂ©thodes pour rĂ©duire le contenu envoyĂ© au modĂšle, bloquer les publicitĂ©s et le protĂ©ger contre les injections de prompts. Les navigateurs distants via CDP et le transport HTTP avec options dâauthentification sont inclus. ([VidĂ©o de dĂ©monstration](https://www.youtube.com/watch?v=qyFk3ZNwOxE))-- đ§ **Agent Skill** : Un [Agent Skill](https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html) prĂȘt Ă installer qui enseigne toute la bibliothĂšque aux agents de codage, pour que le code qu'ils Ă©crivent avec Scrapling corresponde Ă l'API actuelle au lieu d'ĂȘtre devinĂ©.-- đ **Markdown prĂȘt pour le RAG** : Transformez n'importe quelle page en Markdown propre, assaini et prĂȘt pour les LLM en une ligne (`page.markdown()`), ou crawlez un site entier en un corpus Markdown avec le template `ContentSpider`, le tout sans LLM dans la boucle. ([documentation](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html))--### Architecture haute performance et Ă©prouvĂ©e-- đ **Ultra rapide** : Performance optimisĂ©e surpassant la plupart des bibliothĂšques de scraping Python.-- đ **Ăconome en mĂ©moire** : Structures de donnĂ©es optimisĂ©es et chargement paresseux pour une empreinte mĂ©moire minimale.-- ⥠**SĂ©rialisation JSON rapide** : 10x plus rapide que la bibliothĂšque standard.-- đïž **ĂprouvĂ© en conditions rĂ©elles** : Non seulement Scrapling dispose d'une couverture de tests de 92% et d'une couverture complĂšte des type hints, mais il est utilisĂ© quotidiennement par des centaines de Web Scrapers depuis l'annĂ©e derniĂšre.--### ExpĂ©rience conviviale pour dĂ©veloppeurs/Web Scrapers-- đŻ **Shell interactif de Web Scraping** : Shell IPython intĂ©grĂ© optionnel avec intĂ©gration Scrapling, raccourcis et nouveaux outils pour accĂ©lĂ©rer le dĂ©veloppement de scripts de Web Scraping, comme la conversion de requĂȘtes curl en requĂȘtes Scrapling et l'affichage des rĂ©sultats dans votre navigateur.-- đ **Utilisez-le directement depuis le terminal** : Optionnellement, vous pouvez utiliser Scrapling pour scraper une URL sans Ă©crire une seule ligne de code !-- đ ïž **API de navigation riche** : TraversĂ©e avancĂ©e du DOM avec des mĂ©thodes de navigation parent, frĂšre et enfant.-- đ§Ź **Traitement de texte amĂ©liorĂ©** : Regex intĂ©grĂ©es, mĂ©thodes de nettoyage et opĂ©rations sur les chaĂźnes optimisĂ©es.-- đ **GĂ©nĂ©ration automatique de sĂ©lecteurs** : GĂ©nĂ©rez des sĂ©lecteurs CSS/XPath robustes pour n'importe quel Ă©lĂ©ment.-- đ **API familiĂšre** : Similaire Ă Scrapy/BeautifulSoup avec les mĂȘmes pseudo-Ă©lĂ©ments utilisĂ©s dans Scrapy/Parsel.-- đ€ **IntĂ©gration directe avec Scrapy** : DĂ©jĂ investi dans Scrapy ? DĂ©corez n'importe quel callback avec `scrapling_response` pour analyser avec le parseur de Scrapling les rĂ©ponses que vous rĂ©cupĂ©rez dĂ©jĂ , sans rien réécrire.-- đ **Couverture de types complĂšte** : Type hints complets pour un excellent support IDE et la complĂ©tion de code. L'ensemble de la base de code est automatiquement analysĂ© avec **PyRight** et **MyPy** Ă chaque modification.-- đ **Image Docker prĂȘte Ă l'emploi** : Ă chaque version, une image Docker contenant tous les navigateurs est automatiquement construite et publiĂ©e.+## Fonctions principales++### Spiders : un framework complet dâexploration de sites++- đ·ïž **API de Spider proche de Scrapy** : DĂ©finissez des spiders avec `start_urls`, des callbacks `parse` asynchrones et des objets `Request` et `Response`.+- ⥠**Exploration simultanĂ©e** : RĂ©glez le nombre de requĂȘtes simultanĂ©es, les limites par domaine et le dĂ©lai entre les tĂ©lĂ©chargements.+- đ **Plusieurs sessions** : Utilisez des requĂȘtes HTTP et des navigateurs furtifs sans interface graphique dans le mĂȘme spider. Dirigez les requĂȘtes vers diffĂ©rentes sessions grĂące Ă leur ID.+- đŸ **Pause et reprise** : Enregistrez les requĂȘtes en attente et les URL visitĂ©es avec `crawldir`. Appuyez sur Ctrl+C pour arrĂȘter proprement, puis relancez avec le mĂȘme dossier.+- đĄ **RĂ©sultats en streaming** : Recevez les Ă©lĂ©ments dĂšs leur extraction avec `async for item in spider.stream()`, avec des statistiques en temps rĂ©el. Utile pour les interfaces, les traitements de donnĂ©es et les explorations longues.+- đĄïž **DĂ©tection des requĂȘtes bloquĂ©es** : DĂ©tectez et relancez les requĂȘtes bloquĂ©es automatiquement. Vous pouvez adapter ce comportement.+- đŠ **AutoThrottle** : Le spider ajuste le dĂ©lai de chaque domaine selon la vitesse de rĂ©ponse du site. Si le site bloque ou limite les requĂȘtes, il double le dĂ©lai ou respecte la durĂ©e indiquĂ©e par `Retry-After`. Il accĂ©lĂšre Ă nouveau quand la limitation prend fin.+- đ€ **Respect de robots.txt** : Activez `robots_txt_obey` pour respecter les directives `Disallow`, `Crawl-delay` et `Request-rate`, avec un cache par domaine.+- đ§Ș **Mode dĂ©veloppement** : Enregistrez les rĂ©ponses sur disque lors de la premiĂšre exĂ©cution et rĂ©utilisez-les ensuite. Vous pouvez ainsi ajuster `parse()` sans envoyer de nouvelles requĂȘtes aux serveurs.+- đ§© **ModĂšles de spider prĂȘts Ă lâemploi** : Utilisez `CrawlSpider` pour suivre les liens selon des rĂšgles, `SitemapSpider` pour explorer Ă partir de sitemaps ou de robots.txt, `XMLFeedSpider` et `CSVFeedSpider` pour lire des flux XML, RSS et CSV, et `ShopifySpider` pour collecter les produits des boutiques Shopify publiques, avec un Ă©lĂ©ment par variante.+- đ **Extraction de liens** : `LinkExtractor` permet dâaccepter ou de refuser des liens selon des motifs, de filtrer les domaines et les extensions, de limiter la recherche avec CSS ou XPath et de normaliser les URL. Utilisez-le avec les modĂšles ou seul.+- đŠ **Export intĂ©grĂ©** : Exportez les rĂ©sultats avec des hooks et votre propre traitement de donnĂ©es, ou utilisez les formats JSON, JSONL, CSV et XML intĂ©grĂ©s : `result.items.to_json()`, `to_jsonl()`, `to_csv()` et `to_xml()`.++### RĂ©cupĂ©ration de pages avec des sessions++- **RequĂȘtes HTTP** : Envoyez des requĂȘtes HTTP rapides et furtives avec `Fetcher`. Vous pouvez imiter lâempreinte TLS et les en-tĂȘtes dâun navigateur, et utiliser HTTP/3.+- **Chargement dynamique** : RĂ©cupĂ©rez les sites dynamiques avec une automatisation complĂšte du navigateur grĂące Ă `StealthyFetcher`, compatible avec le Chromium de Playwright et Google Chrome.+- **Contournement des systĂšmes antibot** : `StealthyFetcher` masque lâautomatisation et imite les empreintes du navigateur. Il peut franchir automatiquement les diffĂ©rents types de Cloudflare Turnstile et Interstitial.+- **Gestion des sessions** : `FetcherSession` et `StealthySession` conservent les cookies et lâĂ©tat entre les requĂȘtes.+- **Rotation des proxies** : `ProxyRotator` permet une rotation cyclique ou personnalisĂ©e dans tous les types de sessions. Vous pouvez aussi choisir un proxy pour une requĂȘte prĂ©cise.+- **Blocage des domaines et des publicitĂ©s** : Bloquez les requĂȘtes vers certains domaines et leurs sous-domaines, ou activez le blocage des publicitĂ©s des fetchers de navigateur. Il couvre environ 3âŻ500 domaines connus de publicitĂ© et de suivi.+- **PrĂ©vention des fuites DNS** : Activez DNS-over-HTTPS pour envoyer les requĂȘtes DNS par le service DoH de Cloudflare et Ă©viter les fuites lorsque vous utilisez des proxies.+- **Navigateurs distants** : Connectez-vous par CDP Ă un navigateur dĂ©jĂ ouvert avec `cdp_url`, sur votre ordinateur, un autre serveur ou un service de navigateurs. Vous pouvez aussi utiliser votre propre version de Chromium avec tout fetcher de navigateur grĂące Ă `executable_path`.+- **Capture des API en arriĂšre-plan** : Activez `record_requests=True` dans une session de navigateur et cherchez les rĂ©ponses enregistrĂ©es avec `session.network.search(limit=None)`. Lisez les donnĂ©es des API et les erreurs HTTP de plusieurs chargements sans rĂ©pĂ©ter les requĂȘtes. Lâhistorique a une taille limitĂ©e et conserve le contenu des rĂ©ponses textuelles.+- **Mode asynchrone** : Tous les fetchers peuvent fonctionner en mode asynchrone, avec des classes de session propres Ă ce mode.++### Analyse de pages et extraction de donnĂ©es++- đ **Suivi des Ă©lĂ©ments** : Retrouvez les Ă©lĂ©ments aprĂšs un changement du site grĂące Ă des algorithmes de similaritĂ©.+- đŻ **SĂ©lection souple** : Utilisez CSS, XPath, les filtres, le texte, les expressions rĂ©guliĂšres et plus encore.+- đ **ĂlĂ©ments similaires** : Trouvez automatiquement des Ă©lĂ©ments proches de ceux que vous avez dĂ©jĂ trouvĂ©s.++### Fonctions pour lâIA++- đ€ **Serveur MCP** : Permet aux assistants et agents IA, comme Claude et Cursor, dâextraire des donnĂ©es avec Scrapling par des requĂȘtes HTTP, des actions du navigateur, des captures dâĂ©cran, un Ă©tat de connexion enregistrĂ© et des rĂ©ponses dâAPI en arriĂšre-plan. Il utilise notre navigateur furtif et des outils qui aident les modĂšles adaptĂ©s Ă rĂ©soudre les CAPTCHA, en plus du solveur Cloudflare. Il rĂ©duit le contenu envoyĂ© au modĂšle, bloque les publicitĂ©s et protĂšge contre les injections de prompts. Il permet aussi dâutiliser des navigateurs distants par CDP et des connexions HTTP avec des options dâauthentification. ([VidĂ©o de dĂ©monstration](https://www.youtube.com/watch?v=qyFk3ZNwOxE))+- đ§ **Agent Skill** : Une [Agent Skill](https://scrapling.readthedocs.io/en/latest/fr/ai/agent-skill.html) prĂȘte Ă installer qui enseigne la bibliothĂšque aux agents de programmation pour quâils Ă©crivent du code conforme Ă lâAPI actuelle.+- đ **Markdown prĂȘt pour le RAG** : Convertissez une page en Markdown propre et adaptĂ© aux modĂšles de langage avec une ligne (`page.markdown()`), ou enregistrez un site entier en fichiers Markdown avec le modĂšle `ContentSpider`. Le processus ne demande aucun modĂšle de langage. ([Documentation](https://scrapling.readthedocs.io/en/latest/fr/ai/building-rag-systems.html))++### Performances et usage rĂ©el++- đ **Grande vitesse** : Des performances optimisĂ©es qui dĂ©passent la plupart des bibliothĂšques de web scraping pour Python.+- đ **Faible usage de la mĂ©moire** : Des structures de donnĂ©es optimisĂ©es et un chargement Ă la demande.+- ⥠**Conversion rapide en JSON** : 10 fois plus rapide que la bibliothĂšque standard.+- đïž **TestĂ© en pratique** : Les tests couvrent 92âŻ% de Scrapling et tout le code a des annotations de type. Des centaines de personnes lâont utilisĂ© chaque jour pour extraire des donnĂ©es pendant lâannĂ©e passĂ©e.++### Outils pour dĂ©velopper et extraire des donnĂ©es++- đŻ **Shell interactif** : Un shell IPython en option, intĂ©grĂ© Ă Scrapling, avec des raccourcis et des outils pour crĂ©er des scripts plus vite. Convertissez les requĂȘtes curl en requĂȘtes Scrapling et consultez les rĂ©sultats dans votre navigateur.+- đ **Usage depuis le terminal** : Extrayez les donnĂ©es dâune URL sans Ă©crire de code.+- đ ïž **Navigation dans le DOM** : AccĂ©dez aux Ă©lĂ©ments parents, frĂšres et enfants.+- đ§Ź **Traitement du texte** : Expressions rĂ©guliĂšres, nettoyage du texte et opĂ©rations optimisĂ©es sur les chaĂźnes.+- đ **CrĂ©ation de sĂ©lecteurs** : GĂ©nĂ©rez des sĂ©lecteurs CSS et XPath fiables pour tout Ă©lĂ©ment.+- đ **API familiĂšre** : Proche de Scrapy et BeautifulSoup, avec les mĂȘmes pseudo-Ă©lĂ©ments que Scrapy et Parsel.+- đ€ **IntĂ©gration directe avec Scrapy** : Ajoutez le dĂ©corateur `scrapling_response` Ă un callback pour analyser les rĂ©ponses que vous rĂ©cupĂ©rez dĂ©jĂ avec le parser de Scrapling, sans réécrire votre programme.+- đ **Annotations de type complĂštes** : Elles aident lâĂ©diteur Ă vĂ©rifier et Ă complĂ©ter le code. Tout le code est vĂ©rifiĂ© automatiquement par **PyRight** et **MyPy** Ă chaque changement.+- đ **Image Docker prĂȘte Ă lâemploi** : Une image Docker avec tous les navigateurs est créée et publiĂ©e automatiquement Ă chaque version.## Pour commencer-Voici un aperçu rapide de ce que Scrapling peut faire sans entrer dans les dĂ©tails.+Voici quelques exemples de ce que vous pouvez faire avec Scrapling.### Utilisation de base-RequĂȘtes HTTP avec support de sessions+RequĂȘtes HTTP avec des sessions```pythonfrom scrapling.fetchers import Fetcher, FetcherSession@@ -328,7 +334,7 @@ data = page.css('.quote .text::text').getall()```### Spiders-Construisez des crawlers complets avec des requĂȘtes concurrentes, plusieurs types de sessions et pause/reprise :+CrĂ©ez des crawlers complets avec des requĂȘtes simultanĂ©es, plusieurs types de sessions, la pause et la reprise :```pythonfrom scrapling.spiders import Spider, Response@@ -352,7 +358,7 @@ result = QuotesSpider().start()print(f"{len(result.items)} citations scrapĂ©es")result.items.to_json("quotes.json")```-Utilisez plusieurs types de sessions dans un seul spider :+Utilisez plusieurs types de sessions dans un seul spider :```pythonfrom scrapling.spiders import Spider, Request, Responsefrom scrapling.fetchers import FetcherSession, AsyncStealthySession@@ -373,13 +379,13 @@ class MultiSessionSpider(Spider):else:yield Request(link, sid="fast", callback=self.parse) # Callback explicite```-Mettez en pause et reprenez les longs crawls avec des checkpoints en lançant le spider ainsi :+Enregistrez la progression pour mettre en pause et reprendre les explorations longues. Lancez le spider ainsi :```pythonQuotesSpider(crawldir="./crawl_data").start()```-Avec `crawldir`, Ctrl+C enregistre les requĂȘtes en attente et les URL dĂ©jĂ vues. Relancez avec le mĂȘme `crawldir` pour reprendre. Enregistrez les donnĂ©es extraites sĂ©parĂ©ment.+Avec `crawldir`, Ctrl+C enregistre les requĂȘtes en attente et les URL visitĂ©es. Relancez avec le mĂȘme `crawldir` pour reprendre. Enregistrez les donnĂ©es extraites sĂ©parĂ©ment.-Ou Ă©vitez complĂštement d'Ă©crire la logique de crawl grĂące aux modĂšles prĂȘts Ă l'emploi, par exemple pour rĂ©cupĂ©rer tout le catalogue d'une boutique Shopify :+Vous pouvez aussi utiliser un modĂšle prĂȘt Ă lâemploi. Par exemple, rĂ©cupĂ©rez tout le catalogue dâune boutique Shopify :```pythonfrom scrapling.spiders import ShopifySpider@@ -388,9 +394,9 @@ class MyStore(ShopifySpider):result = MyStore().start() # Tous les produits de la boutique, un Ă©lĂ©ment par variante```-Le modĂšle lit les produits exposĂ©s par les endpoints publics des collections, un Ă©lĂ©ment par variante.+Le modĂšle lit les produits disponibles sur les endpoints publics des collections, avec un Ă©lĂ©ment par variante.-### Parsing avancĂ© & Navigation+### Analyse avancĂ©e et navigation```pythonfrom scrapling.fetchers import Fetcher@@ -420,15 +426,15 @@ parent_container = first_quote.parentsimilar_elements = first_quote.find_similar()below_elements = first_quote.below_elements```-Vous pouvez utiliser le parser directement si vous ne souhaitez pas rĂ©cupĂ©rer de sites web, comme ci-dessous :+Vous pouvez utiliser le parser directement, sans rĂ©cupĂ©rer de page web :```pythonfrom scrapling.parser import Selectorpage = Selector("<html>...</html>")```-Et cela fonctionne exactement de la mĂȘme maniĂšre !+Il fonctionne de la mĂȘme façon.-### Exemples de gestion de sessions async+### Exemples de sessions asynchrones```pythonimport asynciofrom scrapling.fetchers import FetcherSession, AsyncStealthySession@@ -447,13 +453,13 @@ async def main():asyncio.run(main())```-## CLI & Shell interactif+## CLI et shell interactif-Scrapling inclut une interface en ligne de commande puissante :+Vous pouvez aussi utiliser Scrapling depuis le terminal :[](https://asciinema.org/a/736339)-Lancer le shell interactif de Web Scraping+Lancez le shell interactif de web scraping :```bashpip install "scrapling[shell]"scrapling shell@@ -467,52 +473,52 @@ scrapling extract fetch 'https://nopecha.com/demo/cloudflare' captchas.html --cs```> [!NOTE]-> Il existe de nombreuses fonctionnalitĂ©s supplĂ©mentaires, mais nous souhaitons garder cette page concise, y compris le serveur MCP et le shell interactif de Web Scraping. Consultez la documentation complĂšte [ici](https://scrapling.readthedocs.io/en/latest/)+> Consultez les autres fonctions, dont le serveur MCP et le shell interactif, dans la [documentation complĂšte](https://scrapling.readthedocs.io/en/latest/fr/).-## Benchmarks de performance+## Tests de performance-Scrapling n'est pas seulement puissant - il est aussi ultra rapide. Les benchmarks suivants comparent le parser de Scrapling avec les derniĂšres versions d'autres bibliothĂšques populaires.+Scrapling se distingue aussi par sa vitesse. Ces tests comparent son parser aux derniĂšres versions dâautres bibliothĂšques connues.-### Test de vitesse d'extraction de texte (5000 Ă©lĂ©ments imbriquĂ©s)+### Vitesse dâextraction du texte (5âŻ000 Ă©lĂ©ments imbriquĂ©s)-| # | BibliothĂšque | Temps (ms) | vs Scrapling |+| # | BibliothĂšque | Temps (ms) | Par rapport Ă Scrapling ||---|:-----------------:|:----------:|:------------:|-| 1 | Scrapling | 1.99 | 1.0x |-| 2 | Parsel/Scrapy | 2.06 | 1.035 |-| 3 | Raw Lxml | 2.56 | 1.286 |-| 4 | PyQuery | 23.98 | ~12x |-| 5 | Selectolax | 197.02 | ~99x |-| 6 | MechanicalSoup | 1545.15 | ~776.5x |-| 7 | BS4 with Lxml | 1562.1 | ~785.0x |-| 8 | BS4 with html5lib | 3412.73 | ~1714.9x |+| 1 | Scrapling | 1,99 | 1,0x |+| 2 | Parsel/Scrapy | 2,06 | 1,035 |+| 3 | Lxml seul | 2,56 | 1,286 |+| 4 | PyQuery | 23,98 | ~12x |+| 5 | Selectolax | 197,02 | ~99x |+| 6 | MechanicalSoup | 1545,15 | ~776,5x |+| 7 | BS4 avec Lxml | 1562,1 | ~785,0x |+| 8 | BS4 avec html5lib | 3412,73 | ~1714,9x |-### Performance de similaritĂ© d'Ă©lĂ©ments & recherche textuelle+### Recherche dâĂ©lĂ©ments similaires et de texte-Les capacitĂ©s adaptatives de recherche d'Ă©lĂ©ments de Scrapling surpassent significativement les alternatives :+La recherche adaptative dâĂ©lĂ©ments de Scrapling est plus rapide que les autres solutions :-| BibliothĂšque | Temps (ms) | vs Scrapling |+| BibliothĂšque | Temps (ms) | Par rapport Ă Scrapling ||--------------|:----------:|:------------:|-| Scrapling | 2.3 | 1.0x |-| AutoScraper | 12.58 | 5.47x |+| Scrapling | 2,3 | 1,0x |+| AutoScraper | 12,58 | 5,47x |-> Tous les benchmarks reprĂ©sentent des moyennes de plus de 100 exĂ©cutions. Voir [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) pour la mĂ©thodologie.+> Chaque rĂ©sultat est la moyenne dâau moins 100 exĂ©cutions. Consultez [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) pour connaĂźtre la mĂ©thode.## Installation-Scrapling nĂ©cessite Python 3.10 ou supĂ©rieur :+Scrapling demande Python 3.10 ou une version plus rĂ©cente :```bashpip install scrapling```> [!IMPORTANT]-> Cette installation n'inclut que le moteur de parsing et ses dĂ©pendances, sans aucun fetcher ni dĂ©pendance en ligne de commande. Importer quoi que ce soit depuis `scrapling.fetchers` ou `scrapling.spiders`, comme dans les exemples ci-dessus, lĂšvera donc une `ModuleNotFoundError` avec cette seule installation. Si vous comptez utiliser l'un des fetchers ou spiders, installez d'abord les dĂ©pendances des fetchers comme indiquĂ© ci-dessous.+> Cette commande installe seulement le parser et ses dĂ©pendances, sans fetchers ni outils en ligne de commande. Avec cette seule installation, importer depuis `scrapling.fetchers` ou `scrapling.spiders`, comme dans les exemples prĂ©cĂ©dents, provoque `ModuleNotFoundError`. Pour utiliser les fetchers ou les spiders, installez dâabord les dĂ©pendances des fetchers comme indiquĂ© ci-dessous.-### DĂ©pendances optionnelles+### DĂ©pendances facultatives-1. Si vous allez utiliser l'une des fonctionnalitĂ©s supplĂ©mentaires ci-dessous, les fetchers ou leurs classes, vous devrez installer les dĂ©pendances des fetchers et leurs dĂ©pendances navigateur comme suit :+1. Pour utiliser les fetchers, leurs classes ou les fonctions supplĂ©mentaires suivantes, installez les dĂ©pendances des fetchers et des navigateurs :```bashpip install "scrapling[fetchers]"@@ -520,9 +526,9 @@ pip install scraplingscrapling install --force # rĂ©installation forcĂ©e```- Cela tĂ©lĂ©charge tous les navigateurs, ainsi que leurs dĂ©pendances systĂšme et les dĂ©pendances de manipulation d'empreintes.+ Cette commande tĂ©lĂ©charge tous les navigateurs, leurs dĂ©pendances systĂšme et les outils de modification des empreintes du navigateur.- Ou vous pouvez les installer depuis le code au lieu d'exĂ©cuter une commande :+ Vous pouvez aussi les installer depuis Python, au lieu de lancer une commande :```pythonfrom scrapling.cli import install@@ -530,47 +536,47 @@ pip install scraplinginstall(["--force"], standalone_mode=False) # rĂ©installation forcĂ©e```-2. FonctionnalitĂ©s supplĂ©mentaires :- - Installer la fonctionnalitĂ© serveur MCP :+2. Fonctions supplĂ©mentaires :+ - Installer le serveur MCP :```bashpip install "scrapling[ai]"```- - Installer les dĂ©pendances pour ([construire des systĂšmes RAG](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html)) :+ - Installer les dĂ©pendances pour [crĂ©er des systĂšmes RAG](https://scrapling.readthedocs.io/en/latest/fr/ai/building-rag-systems.html) :```bashpip install "scrapling[rag]"```- - Installer les fonctionnalitĂ©s shell (shell de Web Scraping et la commande `extract`) :+ - Installer le shell interactif et la commande `extract` :```bashpip install "scrapling[shell]"```- - Tout installer :+ - Tout installer :```bashpip install "scrapling[all]"```- Lancez `scrapling install` si vous utilisez les fetchers avec navigateur. Les requĂȘtes HTTP ne nĂ©cessitent pas de navigateur.+ Lancez `scrapling install` pour utiliser les fetchers de navigateur. Les requĂȘtes HTTP ne demandent pas de navigateur.### Docker-Vous pouvez Ă©galement installer une image Docker avec tous les extras et navigateurs avec la commande suivante depuis DockerHub :+Vous pouvez aussi tĂ©lĂ©charger depuis DockerHub une image Docker avec tous les extras et navigateurs :```bashdocker pull pyd4vinci/scrapling```-Ou tĂ©lĂ©chargez-la depuis le registre GitHub :+Ou la tĂ©lĂ©charger depuis le registre GitHub :```bashdocker pull ghcr.io/d4vinci/scrapling:latest```-Cette image est automatiquement construite et publiĂ©e en utilisant GitHub Actions et la branche principale du dĂ©pĂŽt.+Lâimage est créée Ă partir de la branche principale du dĂ©pĂŽt et publiĂ©e automatiquement par GitHub Actions.## Contribuer-Les contributions sont les bienvenues ! Veuillez lire nos [directives de contribution](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md) avant de commencer.+Les contributions sont les bienvenuesâŻ! Lisez nos [consignes de contribution](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md) avant de commencer.## Avertissement> [!CAUTION]-> Cette bibliothĂšque est fournie uniquement Ă des fins Ă©ducatives et de recherche. En utilisant cette bibliothĂšque, vous acceptez de vous conformer aux lois locales et internationales sur le scraping de donnĂ©es et la confidentialitĂ©. Les auteurs et contributeurs ne sont pas responsables de toute utilisation abusive de ce logiciel. Respectez toujours les conditions d'utilisation des sites web et les fichiers robots.txt.+> Cette bibliothĂšque est destinĂ©e Ă lâenseignement et Ă la recherche. En lâutilisant, vous acceptez de respecter les lois locales et internationales sur lâextraction de donnĂ©es et la vie privĂ©e. Les auteurs et contributeurs ne sont pas responsables dâun usage abusif de ce logiciel. Respectez les conditions dâutilisation des sites et les fichiers robots.txt.## đ Citations-Si vous avez utilisĂ© notre bibliothĂšque Ă des fins de recherche, veuillez nous citer avec la rĂ©fĂ©rence suivante :+Si vous avez utilisĂ© cette bibliothĂšque dans vos recherches, citez-la avec cette rĂ©fĂ©rence :```text@misc{scrapling,author = {Karim Shoair},@@ -583,11 +589,11 @@ Si vous avez utilisĂ© notre bibliothĂšque Ă des fins de recherche, veuillez nou## Licence-Ce travail est sous licence BSD-3-Clause.+Ce projet utilise la licence BSD-3-Clause.## Remerciements-Ce projet inclut du code adaptĂ© de :+Ce projet inclut du code adaptĂ© de :- Parsel (Licence BSD) - UtilisĂ© pour le sous-module [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/translator.py)---diff --git a/docs/locales/fr/ai/agent-skill.md b/docs/locales/fr/ai/agent-skill.mdnew file mode 100644index 0000000..9876465--- /dev/null+++ b/docs/locales/fr/ai/agent-skill.md@@ -0,0 +1,42 @@+---+title: "Agent Skill de Scrapling : installation et utilisation"+description: "Installez la skill Scrapling pour votre agent de programmation. Donnez-lui des exemples et des rĂ©fĂ©rences de lâAPI actuelle pour rĂ©cupĂ©rer des pages, extraire des donnĂ©es et explorer des sites."+---++# Agent Skill de Scrapling {#scrapling-agent-skill}++Le [serveur MCP](mcp-server.md) donne aux chatbots IA des outils pour extraire des donnĂ©es sur le Web. Lâ**Agent Skill de Scrapling** apprend aux agents de programmation Ă utiliser la bibliothĂšque elle-mĂȘme. Le code quâils Ă©crivent avec Scrapling suit ainsi lâAPI actuelle, sans dĂ©pendre dâinformations anciennes issues de leur entraĂźnement.++La skill suit la spĂ©cification [AgentSkills](https://agentskills.io/specification). Elle peut donc ĂȘtre lue par [Claude Code](https://claude.com/product/claude-code), [OpenClaw](https://github.com/openclaw/openclaw) et dâautres outils Ă base dâagents. Elle contient des guides en Markdown sur la rĂ©cupĂ©ration de pages, lâanalyse, lâexploration de sites, MCP et RAG. Lâagent les charge quand il en a besoin. Des exemples prĂȘts Ă exĂ©cuter lui permettent aussi de rĂ©pondre Ă la plupart des questions sur Scrapling et dâĂ©crire du code dâextraction correct sans quitter votre Ă©diteur.++La skill se trouve dans le dossier [agent-skill](https://github.com/D4Vinci/Scrapling/tree/main/agent-skill) du dĂ©pĂŽt, sous le nom `scrapling-official`. Sa version suit toujours celle de la bibliothĂšque.++## Installation {#installation}++### Skills.sh {#skillssh}++Installez la skill depuis le dĂ©pĂŽt avec la CLI de [skills.sh](https://skills.sh) :+```bash+npx skills add D4Vinci/Scrapling --skill scrapling-official+```+La CLI dĂ©tecte les agents installĂ©s et leur ajoute la skill.++### Clawhub {#clawhub}++Si vous utilisez OpenClaw, vous pouvez installer la skill avec [Clawhub](https://docs.openclaw.ai/tools/clawhub) :+```bash+clawhub install scrapling-official+```+Ou installez-la depuis sa [page Clawhub](https://clawhub.ai/D4Vinci/scrapling-official).++### TĂ©lĂ©chargement manuel {#manual-download}++TĂ©lĂ©chargez le fichier ZIP de la skill [directement depuis le dĂ©pĂŽt](https://github.com/D4Vinci/Scrapling/raw/refs/heads/main/agent-skill/Scrapling-Skill.zip), puis extrayez son contenu dans le dossier des skills de votre agent. Pour Claude Code, il sâagit de `~/.claude/skills/`.++## Contenu de la skill {#whats-inside}++- **`SKILL.md`** : Le premier fichier que lâagent lit. Il prĂ©sente la configuration, le choix du fetcher et les rĂšgles de sĂ©curitĂ© Ă suivre. Par exemple, toujours passer `--ai-targeted` aux commandes de la CLI pour se protĂ©ger contre lâinjection dâinstructions.+- **`references/`** : Des copies en Markdown des pages de documentation sur lâanalyse, la rĂ©cupĂ©ration de pages, les spiders, le serveur MCP et les intĂ©grations. Elles sont chargĂ©es Ă la demande pour ne pas occuper le contexte de lâagent avant dâĂȘtre utiles.+- **`examples/`** : Des scripts prĂȘts Ă exĂ©cuter dont lâagent peut sâinspirer.++Nous avons testĂ© la skill avec OpenClaw et Claude Code. Si vous rencontrez un problĂšme, ouvrez un [ticket](https://github.com/D4Vinci/Scrapling/issues/new/choose) ou contactez-nous sur notre [serveur Discord](https://discord.gg/EMgGbDceNQ).diff --git a/docs/locales/fr/ai/building-rag-systems.md b/docs/locales/fr/ai/building-rag-systems.mdnew file mode 100644index 0000000..15a1097--- /dev/null+++ b/docs/locales/fr/ai/building-rag-systems.md@@ -0,0 +1,109 @@+---+title: "Convertir des sites en Markdown pour RAG avec Scrapling"+description: "Convertissez les rĂ©ponses des pages en Markdown ou utilisez ContentSpider pour collecter un site. PrĂ©parez les textes Ă dĂ©couper et Ă indexer dans un systĂšme RAG."+---++# CrĂ©er des systĂšmes RAG avec Scrapling {#building-rag-systems-with-scrapling}++La qualitĂ© dâun systĂšme RAG dĂ©pend du texte quâil reçoit. Le HTML brut consomme des tokens pour les balises, la navigation, les scripts et le contenu de suivi. Il peut mĂȘme transmettre des instructions malveillantes cachĂ©es Ă votre LLM. Scrapling transforme des pages et des sites entiers en Markdown propre et supprime ce contenu cachĂ©, sans utiliser de LLM. La collecte est donc rapide et ne coĂ»te rien par page.++## Installation {#installation}++```bash+pip install "scrapling[rag]"++scrapling install+```++Lâextra `rag` installe les fetchers avec la conversion en Markdown. Les extras `ai`, `shell` et `all` lâincluent aussi. La commande `scrapling install` tĂ©lĂ©charge les dĂ©pendances du navigateur, nĂ©cessaires uniquement aux fetchers qui utilisent un navigateur.++## Convertir une page en Markdown {#one-page-to-markdown}++Chaque [Response](../fetching/choosing.md#response-object) possĂšde une mĂ©thode `markdown()` :++```python+from scrapling.fetchers import Fetcher++markdown = Fetcher.get("https://example.com").markdown(main_content_only=True)+```++Elle fonctionne avec tous les fetchers. Vous pouvez donc aussi rĂ©cupĂ©rer une page protĂ©gĂ©e par Cloudflare en une ligne :++```python+from scrapling.fetchers import StealthyFetcher++markdown = StealthyFetcher.fetch("https://protected.example.com", solve_cloudflare=True).markdown(main_content_only=True)+```++Deux arguments contrĂŽlent le rĂ©sultat :++- `main_content_only` : Convertit uniquement le contenu Ă lâintĂ©rieur de la balise `<body>` de la page.+- `css_selector` : Convertit uniquement les Ă©lĂ©ments qui correspondent Ă un sĂ©lecteur CSS, puis rĂ©unit toutes les correspondances. Utilisez-le pour extraire exactement la partie utile Ă votre traitement et Ă©conomiser des tokens :++```python+markdown = Fetcher.get("https://example.com/docs/page").markdown(css_selector="article")+```++Quels que soient les arguments, les scripts, les styles et le contenu cachĂ© sont toujours supprimĂ©s avant la conversion. Câest le mĂȘme nettoyage que celui du [serveur MCP](mcp-server.md) pour protĂ©ger les agents IA contre lâinjection dâinstructions. Il supprime les Ă©lĂ©ments cachĂ©s par des styles en ligne, ceux avec `aria-hidden="true"`, les slots cachĂ©s, les balises `<template>`, les commentaires HTML et les caractĂšres de largeur nulle. Le serveur MCP applique ce nettoyage avec `main_content_only=True`.++## Convertir un site entier en un ensemble de fichiers Markdown {#a-whole-website-to-a-markdown-corpus}++Le modĂšle `ContentSpider` explore un site et convertit chaque page. Il utilise le [systĂšme de spiders](../spiders/architecture.md), qui fournit dĂ©jĂ la concurrence, AutoThrottle, le respect de robots.txt et la pause avec reprise :++```python+from scrapling.spiders import ContentSpider++class DocsSpider(ContentSpider):+ name = "docs"+ start_urls = ["https://example.com/docs/"]+ allowed_domains = {"example.com"}+ output_dir = "docs_markdown"+ max_pages = 200++result = DocsSpider().start()+result.items.to_jsonl("docs.jsonl")+```++Chaque page explorĂ©e devient un Ă©lĂ©ment avec les clĂ©s `url`, `title` et `markdown`. Si vous dĂ©finissez `output_dir`, chaque page est aussi enregistrĂ©e dans un fichier Markdown dont le nom est basĂ© sur son URL. Lâexemple ci-dessus produit donc un dossier de fichiers `.md` et un fichier `docs.jsonl` prĂȘt Ă charger.++Le modĂšle exige `allowed_domains` pour limiter lâexploration au site visĂ©. Voici les options :++- `css_selector` / `main_content_only` : PassĂ©s Ă `markdown()` pour chaque page. `main_content_only` est activĂ© par dĂ©faut.+- `output_dir` : Sâil est dĂ©fini, Ă©crit un fichier Markdown par page.+- `max_pages` : Nombre maximal de pages Ă convertir. Les requĂȘtes dĂ©jĂ en attente lorsque la limite est atteinte peuvent encore ĂȘtre envoyĂ©es, mais leurs pages ne sont pas converties. La valeur par dĂ©faut, `0`, dĂ©sactive la limite.++Par dĂ©faut, tous les liens dans `allowed_domains` sont suivis. Comme le modĂšle repose sur [CrawlSpider](../spiders/generic-templates.md#crawlspider), vous pouvez redĂ©finir `rules()` avec votre propre [LinkExtractor](../spiders/generic-templates.md#linkextractor-reference) pour contrĂŽler lâexploration. `allow` la limite aux motifs dâURL souhaitĂ©s, et `deny` exclut les motifs indĂ©sirables, comme ceux des pages de connexion, des listes de tags ou des versions Ă imprimer :++```python+from scrapling.spiders import CrawlRule, LinkExtractor, ContentSpider++class DocsSpider(ContentSpider):+ name = "docs"+ start_urls = ["https://example.com/"]+ allowed_domains = {"example.com"}++ def rules(self):+ return [CrawlRule(LinkExtractor(allow=r"/docs/", deny=[r"/docs/changelog/", r"\?print="]))]+```++`deny` est prioritaire sur `allow`. Une rĂšgle peut inclure `priority` ou un hook `process_request`, comme avec tout **CrawlSpider**.++## Charger les donnĂ©es dans une base vectorielle {#feeding-a-vector-store}++Vous pouvez utiliser le fichier JSONL dans tout processus de crĂ©ation dâembeddings. Voici un exemple minimal :++```python+import json++with open("docs.jsonl", encoding="utf-8") as f:+ for line in f:+ page = json.loads(line)+ for chunk in split_into_chunks(page["markdown"]):+ vector_store.add(text=chunk, metadata={"url": page["url"], "title": page["title"]})+```++Utilisez `css_selector` dans le spider pour retirer le contenu rĂ©pĂ©titif avant de dĂ©couper le texte, plutĂŽt que de le nettoyer aprĂšs. Moins vos embeddings contiennent de contenu inutile, meilleurs seront les rĂ©sultats de recherche.++## Solutions interactives {#interactive-alternatives}++Si vous prĂ©fĂ©rez extraire les donnĂ©es par une conversation, le [serveur MCP](mcp-server.md) donne Ă votre chatbot IA des outils avec la mĂȘme extraction en Markdown. Lâ[Agent skill](agent-skill.md) apprend aux agents de programmation Ă Ă©crire ce code eux-mĂȘmes.diff --git a/docs/locales/fr/ai/mcp-server.md b/docs/locales/fr/ai/mcp-server.mdnew file mode 100644index 0000000..9ba2251--- /dev/null+++ b/docs/locales/fr/ai/mcp-server.md@@ -0,0 +1,510 @@+---+title: "Serveur MCP de Scrapling : configuration et extraction de donnĂ©es"+description: "Connectez un client IA Ă Scrapling pour extraire des donnĂ©es par HTTP ou avec un navigateur. Utilisez les sessions, lâĂ©tat de connexion sauvegardĂ©, les actions, les filtres et lâhistorique des API."+---++# Guide du serveur MCP de Scrapling {#scrapling-mcp-server-guide}++<iframe width="560" height="315" src="https://www.youtube.com/embed/qyFk3ZNwOxE?si=3FHzgcYCb66iJ6e3" title="Lecteur vidĂ©o YouTube" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>++Le **serveur MCP de Scrapling** met les fonctions dâextraction de donnĂ©es web de Scrapling Ă la disposition de votre chatbot ou agent IA. Vous pouvez lui demander de visiter des sites, dâextraire des donnĂ©es et de contourner les protections antibot au cours dâune conversation dans Claude ou dans toute interface compatible avec MCP.++## Fonctions {#features}++Le serveur MCP de Scrapling fournit seize outils pour extraire des donnĂ©es web et interagir avec le navigateur. Les outils Ă usage unique rĂ©cupĂšrent une URL, puis ferment leur navigateur ou client. Les outils de session gardent les cookies et les rĂ©glages entre les appels. LâIA peut ainsi poursuivre ses actions dans le mĂȘme onglet et consulter lâhistorique rĂ©seau.++### Outils Ă usage unique {#one-shot-tools}++#### đ Extraction de base par HTTP {#basic-http-scraping}++- **`make_request`** : Des requĂȘtes HTTP rapides avec nâimporte quelle mĂ©thode (GET, POST, PUT, DELETE) et imitation de lâempreinte du navigateur. Cet outil gĂ©nĂšre de vrais en-tĂȘtes de navigateur correspondant Ă la version TLS, prend en charge HTTP/3 et plus encore.++#### đ Extraction avec le navigateur Stealthy {#stealth-browser-scraping}++- **`browser_fetch_once`** : ExĂ©cute JavaScript et extrait des donnĂ©es de pages dynamiques avec notre navigateur Stealthy. Lâoutil permet de modifier lâempreinte du navigateur, de contourner Turnstile et Interstitial de Cloudflare, et de contrĂŽler le navigateur comme la requĂȘte.++### Outils de session {#session-tools}++#### đ Gestion des sessions {#session-management}++- **`browser_open`** : CrĂ©e une session persistante de navigateur Stealthy qui reste ouverte entre les appels Ă `browser_fetch`. Il nâest donc pas nĂ©cessaire de lancer un navigateur Ă chaque fois. Elle garde la configuration du navigateur et renvoie seulement `session_id` et `session_type`. Utilisez `list_sessions` pour voir sa configuration effective dans `settings`, qui est vide pour les sessions CDP.+- **`open_request_session`** : CrĂ©e une session HTTP persistante sans navigateur, Ă utiliser avec `session_make_request`. Elle garde les cookies, les connexions et lâempreinte du navigateur (`impersonate`) entre les requĂȘtes. Elle renvoie seulement `session_id` et `session_type`, avec le type `static`. Utilisez `list_sessions` pour voir sa configuration effective dans `settings`.+- **`close_session`** : Ferme une session persistante de navigateur ou de requĂȘtes et libĂšre ses ressources.+- **`list_sessions`** : Liste toutes les sessions actives avec leurs dĂ©tails et leur `settings`.++#### Ătat du navigateur {#browser-state}++- **`browser_save_state`** : Enregistre les cookies, le stockage local et IndexedDB dans un fichier JSON compatible avec Playwright. Vous pouvez ainsi rĂ©utiliser lâĂ©tat de connexion aprĂšs la fin de la session du navigateur. Lâenregistrement remplace le fichier sâil existe dĂ©jĂ .+- **`browser_load_state`** : Restaure un fichier enregistrĂ© dans une session de navigateur ouverte, mĂȘme avant le premier chargement de page. Le contenu remplace lâĂ©tat stockĂ© actuel sans fermer les onglets ni changer de page. RĂ©cupĂ©rez ou rechargez la page pour utiliser la connexion restaurĂ©e.++Les fichiers dâĂ©tat se trouvent sur lâordinateur qui exĂ©cute le serveur MCP. Ils ne contiennent pas `sessionStorage`, les onglets ouverts ni les rĂ©glages du navigateur.++#### đŻ RĂ©cupĂ©rer des pages dans une session {#fetching-through-a-session}++- **`browser_fetch`** : ExĂ©cute JavaScript et extrait les donnĂ©es dâune URL dans une session ouverte de navigateur Stealthy. Lâoutil permet de modifier lâempreinte du navigateur et de contourner Turnstile et Interstitial de Cloudflare. Il peut aussi crĂ©er une vue structurĂ©e de la page avec les rĂ©fĂ©rences, positions et tailles des Ă©lĂ©ments, pour aider lâIA Ă repĂ©rer les contrĂŽles et Ă prĂ©parer les actions de la souris.+- **`session_make_request`** : Envoie des requĂȘtes HTTP rapides avec nâimporte quelle mĂ©thode (GET, POST, PUT, DELETE), imitation de lâempreinte du navigateur, en-tĂȘtes correspondants et prise en charge dâHTTP/3. RĂ©utilise les cookies, les connexions et lâempreinte du navigateur dans une session ouverte avec `open_request_session`.++#### đž Captures dâĂ©cran {#screenshots}++- **`browser_screenshot`** : Capture la page actuelle ou un Ă©lĂ©ment en PNG ou JPEG sans la recharger. Vous pouvez vĂ©rifier les champs remplis, les menus ouverts, les graphiques ou les cartes de rĂ©sultats. Capturer un seul Ă©lĂ©ment rĂ©duit le contenu inutile. Lâoutil accepte la zone visible, la page entiĂšre ou un Ă©lĂ©ment, avec une qualitĂ© JPEG rĂ©glable. La capture est renvoyĂ©e sous forme de bloc dâimage rĂ©el que le modĂšle peut voir directement.++#### Contenu de la page actuelle {#current-page-content}++- **`browser_extract`** : Lit la page actuelle ou un Ă©lĂ©ment sous forme de vue structurĂ©e pour lâIA, de HTML, de Markdown ou de texte, sans rechargement. Extrayez les rĂ©sultats aprĂšs avoir rempli un formulaire ou chargĂ© plus de contenu. Les vues incluent les rĂŽles, noms, rĂ©fĂ©rences, positions et tailles des Ă©lĂ©ments pour les actions suivantes. La recherche par expression rĂ©guliĂšre renvoie les lignes correspondantes avec le contexte proche et les nĆuds parents.++#### Actions du navigateur {#browser-actions}++- **`browser_actions`** : EnchaĂźne les actions de la souris, le remplissage des champs, les raccourcis clavier, les rĂ©ponses aux boĂźtes de dialogue et les attentes dans un seul appel. Accepte ou ferme les alertes et confirmations du navigateur, ou saisit du texte dans les boĂźtes de saisie. Par exemple, remplit un champ de recherche, envoie la requĂȘte, attend les rĂ©sultats et en ouvre un. LâIA peut regrouper les Ă©tapes connues et demander des vues sĂ©parĂ©es lorsquâelle doit vĂ©rifier une modification de la page.++ Affiche les menus et infobulles au survol, clique sur les boutons et liens, ou place la souris sur un panneau imbriquĂ© pour le faire dĂ©filer verticalement ou horizontalement. Les dĂ©placements et clics acceptent des sĂ©lecteurs, des rĂ©fĂ©rences de la vue structurĂ©e ou des coordonnĂ©es. Pour les Ă©lĂ©ments ciblĂ©s, lâoutil attend automatiquement leur prĂ©sence et fait dĂ©filer la page pour les rendre visibles. Il accepte les dĂ©placements par coordonnĂ©es en plusieurs Ă©tapes, les clics gauche, droit et central, ainsi que les doubles clics.++ Ciblez les champs nâimporte oĂč sur la page avec des sĂ©lecteurs ou des rĂ©fĂ©rences. Saisissez du texte, cochez ou dĂ©cochez des cases, sĂ©lectionnez des boutons radio et choisissez une ou plusieurs options de listes dĂ©roulantes natives par leur libellĂ© visible. Le texte peut remplacer le contenu, lâeffacer ou continuer Ă la position du curseur. Les raccourcis clavier permettent de sĂ©lectionner et supprimer du texte, de changer le focus, dâenvoyer des formulaires ou de fermer des menus. Le mode lent saisit un caractĂšre Ă la fois, avec des pauses alĂ©atoires entre les caractĂšres et entre toutes les actions.++ Attendez que les rĂ©sultats apparaissent, que les couches de chargement disparaissent ou que les Ă©vĂ©nements de chargement de la page se produisent avant lâaction suivante. Lâoutil accepte aussi les pauses fixes et lâattente dâune stabilisation de lâactivitĂ© rĂ©seau.++#### JavaScript {#javascript}++- **`browser_evaluate`** : ExĂ©cute JavaScript sur la page actuelle pour une extraction personnalisĂ©e, des calculs ou des tĂąches propres Ă la page. LâIA peut rĂ©unir des donnĂ©es de plusieurs Ă©lĂ©ments, lire lâĂ©tat de lâapplication ou modifier le contenu. Lâoutil accepte les scripts asynchrones et renvoie leurs rĂ©sultats en JSON.++#### Historique rĂ©seau {#network-history}++- **`browser_network_requests`** : Recherche les requĂȘtes terminĂ©es parmi les onglets, les chargements de page et les actions du navigateur. Trouvez les appels dâAPI derriĂšre les donnĂ©es dâune page, vĂ©rifiez les erreurs HTTP et suivez les redirections enregistrĂ©es. Les ressources statiques sont cachĂ©es par dĂ©faut pour rĂ©duire le rĂ©sultat. Les dĂ©tails sont renvoyĂ©s en JSON, avec une pagination pour les longs historiques.+- **`browser_network_request`** : Consulte le rĂ©sumĂ©, les en-tĂȘtes, les donnĂ©es envoyĂ©es ou le corps textuel de la rĂ©ponse dâune requĂȘte enregistrĂ©e. Renvoie toute la partie choisie en JSON structurĂ© sans charger la page ni renvoyer la requĂȘte. Les rĂ©ponses enregistrĂ©es restent disponibles aprĂšs un changement de page. Des limites sâappliquent Ă la taille de lâhistorique ; une note explique les corps non textuels, trop volumineux ou impossibles Ă lire. Lisez les dĂ©tails nĂ©cessaires avant de fermer la session MCP.++Les corps de rĂ©ponse sont lus et enregistrĂ©s uniquement pour les valeurs de `Content-Type` textuelles prises en charge, comme HTML, JSON, XML ou JavaScript. Pour les types binaires, absents ou inconnus, les mĂ©tadonnĂ©es et en-tĂȘtes de la requĂȘte sont conservĂ©s, sans lire ni enregistrer le corps. Le navigateur continue de charger les ressources normalement.++Seules les requĂȘtes terminĂ©es sont enregistrĂ©es, y compris les rĂ©ponses HTTP 4xx et 5xx. Les requĂȘtes en Ă©chec ou encore en cours sont omises. Les entrĂ©es apparaissent une fois la capture terminĂ©e ; lire lâhistorique ou fermer la session nâattend pas les captures. Celles qui sont encore en cours lors dâune navigation ou dâune fermeture peuvent ĂȘtre omises. Les octets enregistrĂ©s viennent du navigateur et peuvent diffĂ©rer de ceux du serveur. Le texte suit le dĂ©codage UTF-8 de Playwright lorsquâil est valide, sinon lâencodage dĂ©clarĂ©.++### Shadow DOM {#shadow-dom}++DĂ©finissez `pierce_shadow=true` dans `browser_fetch_once` ou dans chaque appel Ă `browser_fetch` pour inclure le contenu des Shadow DOM ouverts. La valeur par dĂ©faut est `false`. Consultez [Shadow DOM](../fetching/stealthy.md#shadow-dom) pour voir des exemples de sĂ©lecteurs et leurs limites.++### Fonctions principales {#key-capabilities}++- **Extraction de contenu** : Convertissez des pages ou des Ă©lĂ©ments en Markdown ou HTML, ou extrayez une version propre du texte.+- **SĂ©lecteurs CSS** : Utilisez le moteur de Scrapling pour choisir des Ă©lĂ©ments prĂ©cis avant de transmettre le contenu Ă lâIA.+- **Contournement des protections antibot** : GĂ©rez Turnstile, Interstitial et dâautres protections de Cloudflare.+- **Proxies** : Utilisez des proxies pour masquer votre adresse et choisir la localisation des requĂȘtes.+- **Imitation du navigateur** : Imitez de vrais navigateurs avec lâempreinte TLS, des en-tĂȘtes correspondant Ă leur version et dâautres options.+- **Sessions persistantes** : RĂ©utilisez les sessions du navigateur entre les requĂȘtes pour amĂ©liorer les performances.+- **Blocage des publicitĂ©s** : Tous les outils de navigateur bloquent automatiquement les requĂȘtes vers environ 3 500 domaines connus de publicitĂ© et de suivi. Cela Ă©conomise des tokens et accĂ©lĂšre le chargement.+- **Protection contre lâinjection dâinstructions** : Supprime automatiquement le contenu cachĂ© qui pourrait servir Ă attaquer le modĂšle : Ă©lĂ©ments cachĂ©s par des styles en ligne, aria-hidden, slots cachĂ©s, caractĂšres de largeur nulle, commentaires HTML et balises template.++#### Pourquoi utiliser le serveur MCP de Scrapling plutĂŽt que dâautres outils ? {#but-why-use-scrapling-mcp-server-instead-of-other-available-tools}++En plus de masquer lâautomatisation et de contourner Turnstile et Interstitial de Cloudflare, le serveur de Scrapling est le seul qui permet de choisir les Ă©lĂ©ments Ă envoyer Ă lâIA. Cela Ă©conomise beaucoup de temps et de tokens !++Les autres serveurs extraient le contenu et le transmettent en entier Ă lâIA pour quâelle trouve les champs souhaitĂ©s. Le modĂšle consomme alors beaucoup de tokens pour du contenu inutile. Scrapling permet de limiter le contenu avec un sĂ©lecteur CSS avant de lâenvoyer Ă lâIA, ce qui rend tout le processus plus rapide et plus efficace.++Si vous ne savez pas Ă©crire ou utiliser des sĂ©lecteurs CSS, ne vous inquiĂ©tez pas. Demandez Ă lâIA dâen Ă©crire pour les champs recherchĂ©s, puis laissez-la essayer diffĂ©rentes combinaisons jusquâĂ trouver la bonne. Nous le montrerons dans les exemples.++## Installation {#installation}++Installez Scrapling avec la prise en charge de MCP, puis vĂ©rifiez que les dĂ©pendances du navigateur sont aussi installĂ©es.++```bash+# Install Scrapling with MCP server dependencies+pip install "scrapling[ai]"++# Install browser dependencies+scrapling install+```++Vous pouvez aussi utiliser lâimage Docker directement depuis le registre Docker :+```bash+docker pull pyd4vinci/scrapling+```+Ou la tĂ©lĂ©charger depuis le registre GitHub :+```bash+docker pull ghcr.io/d4vinci/scrapling:latest+```++## Configurer le serveur MCP {#setting-up-the-mcp-server}++Voici comment ajouter le serveur MCP de Scrapling Ă [Claude Desktop](https://claude.ai/download) et [Claude Code](https://www.anthropic.com/claude-code). Les mĂȘmes Ă©tapes gĂ©nĂ©rales sâappliquent aux autres chatbots compatibles avec MCP :++!!! note "Note"+ La commande `scrapling-mcp` des exemples a Ă©tĂ© ajoutĂ©e dans la version 0.4.13 comme raccourci de `scrapling mcp`. Elle facilite lâajout de Scrapling aux registres et clients MCP qui attendent une seule commande. Avec une version plus ancienne, utilisez la commande `scrapling` avec `mcp` comme premier argument.++### Claude Desktop {#claude-desktop}++1. Ouvrez Claude Desktop.+2. Cliquez sur le menu (â°) en haut Ă gauche, puis sur Settings â Developer â Edit Config.+3. Ajoutez la configuration du serveur MCP de Scrapling :+```json+"ScraplingServer": {+ "command": "scrapling-mcp"+}+```+Sâil sâagit de votre premier serveur MCP, utilisez ce contenu pour le fichier :+```json+{+ "mcpServers": {+ "ScraplingServer": {+ "command": "scrapling-mcp"+ }+ }+}+```+Selon lâ[article officiel](https://modelcontextprotocol.io/quickstart/user), cette action crĂ©e un fichier de configuration sâil nâexiste pas encore, ou ouvre le fichier existant. Il se trouve ici :++1. **MacOS** : `~/Library/Application Support/Claude/claude_desktop_config.json`+2. **Windows** : `%APPDATA%\Claude\claude_desktop_config.json`++Pour vous assurer que cela fonctionne, utilisez le chemin complet de lâexĂ©cutable `scrapling-mcp`. Vous pouvez le trouver avec :++1. **MacOS** : `which scrapling-mcp`+2. **Windows** : `where scrapling-mcp`++Sur mon Mac, le rĂ©sultat Ă©tait `/Users/<MyUsername>/.venv/bin/scrapling-mcp`. Jâai donc utilisĂ© cette configuration :+```json+{+ "mcpServers": {+ "ScraplingServer": {+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp"+ }+ }+}+```+#### Docker {#docker}++Si vous utilisez lâimage Docker, la configuration ressemble Ă ceci :+```json+{+ "mcpServers": {+ "ScraplingServer": {+ "command": "docker",+ "args": [+ "run", "-i", "--rm", "pyd4vinci/scrapling", "mcp"+ ]+ }+ }+}+```++La mĂȘme logique sâapplique Ă [Cursor](https://cursor.com/docs/context/mcp), [WindSurf](https://windsurf.com/university/tutorials/configuring-first-mcp-server) et aux autres clients.++### Claude Code {#claude-code}++Avec [Claude Code](https://www.anthropic.com/claude-code), câest plus simple :++```bash+claude mcp add ScraplingServer "/Users/<MyUsername>/.venv/bin/scrapling-mcp"+```+Pour obtenir le chemin de lâexĂ©cutable de Scrapling :++1. **MacOS** : `which scrapling-mcp`+2. **Windows** : `where scrapling-mcp`++Consultez lâarticle dâAnthropic sur [lâajout de serveurs MCP Ă Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#option-1%3A-add-a-local-stdio-server) pour plus de dĂ©tails.++AprĂšs lâajout du serveur, quittez complĂštement lâapplication et relancez-la. Dans Claude Desktop, vous devriez voir lâindicateur de serveur MCP (đ§) en bas Ă droite du champ de saisie, ou `ScraplingServer` dans le menu `Search and tools` de ce champ.++### ExĂ©cutable de navigateur personnalisĂ© {#custom-browser-executable}++Les outils `browser_fetch_once` et `browser_open` peuvent utiliser un exĂ©cutable de navigateur compatible avec Chromium Ă la place du Chromium fourni. Cela convient aux versions personnalisĂ©es du navigateur ou aux moteurs lĂ©gers.++Pour le dĂ©finir une seule fois pour tout le serveur MCP, passez le chemin de lâexĂ©cutable au dĂ©marrage :++```bash+scrapling-mcp --executable-path "/path/to/chromium"+```++Dans la configuration de Claude Desktop, ajoutez lâoption aux arguments du serveur :++```json+{+ "mcpServers": {+ "ScraplingServer": {+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp",+ "args": [+ "--executable-path",+ "/path/to/chromium"+ ]+ }+ }+}+```++Vous pouvez aussi dĂ©finir la variable dâenvironnement `SCRAPLING_EXECUTABLE_PATH` avant de dĂ©marrer le serveur. LâIA peut toujours choisir un autre exĂ©cutable pour une rĂ©cupĂ©ration avec `browser_fetch_once` ou Ă lâouverture dâune session avec `browser_open`.++### Se connecter Ă des navigateurs distants {#connecting-to-remote-browsers}++`browser_open` nâa pas besoin de lancer un navigateur local. Passez une URL CDP pour vous connecter Ă un navigateur dĂ©jĂ ouvert avec le [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/). Il peut se trouver sur le mĂȘme ordinateur, sur un autre ou chez un fournisseur de navigateurs gĂ©rĂ©s :+```+Open a stealthy browser session on wss://cdp.provider.example/session/abc123, then use it to scrape the product details from https://shop.example.com. Close the session when you're done.+```+Le `session_id` renvoyĂ© sâutilise comme dâhabitude avec `browser_fetch`, `browser_extract`, `browser_actions`, `browser_evaluate`, `browser_screenshot`, `browser_network_requests`, `browser_network_request`, `browser_save_state` et `browser_load_state`.++LâURL peut ĂȘtre un endpoint WebSocket (`ws://`/`wss://`), comme ceux fournis par les services de navigateurs, ou lâendpoint HTTP dâun navigateur que vous avez lancĂ© avec le port de dĂ©bogage distant activĂ© :+```commandline+chrome --remote-debugging-port=9222+```+Dans ce cas, connectez-vous avec `cdp_url="http://localhost:9222"`, ou avec lâadresse de lâhĂŽte si le navigateur tourne sur un autre ordinateur.++!!! note "Notes"++ * Comme le navigateur est dĂ©jĂ ouvert, les sessions CDP ignorent les options qui ne servent quâau lancement : `headless`, `real_chrome` et `executable_path`, y compris la valeur par dĂ©faut du serveur dĂ©crite plus haut.<br/>+ * Les autres options sâappliquent toujours (`locale`, `useragent`, `proxy`, `cookies`, `timezone_id`, etc.), car chaque session crĂ©e son propre contexte dans le navigateur distant.++### Streamable HTTP {#streamable-http}++Depuis la version 0.3.6, le serveur MCP peut utiliser le transport 'Streamable HTTP' Ă la place du transport classique 'stdio'.++Au lieu de cette commande pour 'stdio' :+```bash+scrapling-mcp+```+Utilisez la suivante pour activer 'Streamable HTTP' :+```bash+scrapling-mcp --http+```+Par dĂ©faut, le serveur Ă©coute sur '127.0.0.1', au port 8000. Vous pouvez modifier ces deux valeurs :+```bash+scrapling-mcp --http --host '0.0.0.0' --port 8000+```+La configuration par dĂ©faut nâaccepte que les connexions du mĂȘme ordinateur. Passez `--host '0.0.0.0'` pour rendre le serveur accessible depuis le rĂ©seau. Ce choix est indĂ©pendant de lâauthentification dĂ©crite ci-dessous.++Si vous exĂ©cutez 'Streamable HTTP' dans Docker, vous devez utiliser '0.0.0.0' et dĂ©finir un token. Sinon, le port publiĂ© ne peut pas atteindre le serveur, car le '127.0.0.1' du conteneur nâest visible que depuis lâintĂ©rieur :+```bash+docker run -p 8000:8000 -e SCRAPLING_MCP_AUTH_TOKEN="<your-token>" pyd4vinci/scrapling mcp --http --host '0.0.0.0'+```++### Authentification {#authentication}++Seul le programme qui a lancĂ© le serveur peut accĂ©der au transport 'stdio'. Avec 'Streamable HTTP', toute personne qui peut atteindre le port peut appeler tous les outils. Cela inclut lâaccĂšs Ă nâimporte quelle URL depuis lâordinateur qui exĂ©cute le serveur. Câest pourquoi 'Streamable HTTP' exige une authentification : `--http` seul refuse de dĂ©marrer et demande un token :+```bash+scrapling-mcp --http --auth-token "$(openssl rand -hex 32)"+```+Les clients doivent envoyer ce token dans un en-tĂȘte `Authorization`. Toute requĂȘte sans token est rejetĂ©e avec un `401` :+```json+{+ "mcpServers": {+ "ScraplingServer": {+ "url": "https://your-server.example.com/mcp",+ "headers": {+ "Authorization": "Bearer <your-token>"+ }+ }+ }+}+```+Passer le token sur la ligne de commande le laisse dans lâhistorique du shell et dans la liste des processus. PrĂ©fĂ©rez donc la variable dâenvironnement `SCRAPLING_MCP_AUTH_TOKEN` :+```bash+export SCRAPLING_MCP_AUTH_TOKEN="<your-token>"+scrapling-mcp --http+```+Si vous voulez vraiment un serveur sans authentification, par exemple pour un test local sur lâadresse par dĂ©faut '127.0.0.1', indiquez-le avec `--no-auth` :+```bash+scrapling-mcp --http --no-auth+```+Combiner `--no-auth` avec `--host '0.0.0.0'` rend tous les outils accessibles Ă toute personne qui peut atteindre le port. Ăvitez cette combinaison en dehors dâun rĂ©seau de confiance.++Quand le serveur Ă©coute sur une adresse publique, indiquez aussi les noms dâhĂŽte quâil doit accepter. Cela active la protection contre le DNS rebinding, une attaque oĂč un site visitĂ© essaie de communiquer avec votre serveur. Vous pouvez rĂ©pĂ©ter lâoption :+```bash+scrapling-mcp --http --allowed-host 'your-server.example.com:8000'+```++!!! note "Notes"++ * Lâauthentification sâapplique uniquement Ă 'Streamable HTTP'. Avec 'stdio', elle est ignorĂ©e et le serveur lâindique par un avertissement dans les logs.<br/>+ * HTTP non chiffrĂ© envoie le token en clair. Avant dâexposer le serveur sur Internet, placez-le derriĂšre un proxy inverse qui reçoit les connexions TLS et transmet les requĂȘtes au serveur.<br/>+ * Il sâagit dâune seule clĂ© partagĂ©e, pas dâidentifiants propres Ă chaque client. Tous les clients utilisent le mĂȘme token et il faut redĂ©marrer le serveur pour le changer.<br/>+ * DĂ©marrer le serveur avec `--http --no-auth` produit tout de mĂȘme un avertissement indiquant lâabsence dâauthentification.<br/>+ * Si vous passez `--auth-token` et `--no-auth` ensemble, le token est conservĂ© et le serveur garde lâauthentification.++## Exemples {#examples}++Voici quelques prompts utilisĂ©s pour tester le serveur MCP. Vous en trouverez sĂ»rement dâautres encore meilleurs :)++Nous allons passer des instructions simples aux plus complexes. Les exemples utilisent Claude Desktop, mais la mĂȘme logique vaut pour les autres clients.++1. **Extraction de donnĂ©es web de base**++ Extrayez le contenu principal dâune page en Markdown :++ ```+ Scrape the main content from https://example.com and convert it to markdown format.+ ```++ Claude peut utiliser `make_request` pour rĂ©cupĂ©rer la page et renvoyer un contenu propre et lisible. Les requĂȘtes HTTP ont trois tentatives par dĂ©faut, avec une seconde dâattente entre elles. Si la page demande JavaScript ou bloque les requĂȘtes HTTP, lâIA peut utiliser `browser_fetch_once`. Les deux outils ferment leurs propres ressources aprĂšs lâappel.++ Une version plus prĂ©cise du mĂȘme prompt serait :+ ```+ Use regular requests to scrape the main content from https://example.com and convert it to markdown format.+ ```+ Vous indiquez ainsi Ă Claude quel outil utiliser, sans le laisser deviner. Parfois il commence par des requĂȘtes classiques ; parfois il choisit un navigateur sans raison claire. En rĂšgle gĂ©nĂ©rale, prĂ©cisez lâoutil Ă utiliser pour Ă©conomiser du temps et de lâargent et obtenir des rĂ©sultats constants.++2. **Extraction de donnĂ©es ciblĂ©es**++ Extrayez des Ă©lĂ©ments prĂ©cis avec des sĂ©lecteurs CSS :++ ```+ Get all product titles from https://shop.example.com using the CSS selector '.product-title'. If the request fails, retry up to 5 times every 10 seconds.+ ```++ Le serveur extrait uniquement les Ă©lĂ©ments correspondant au sĂ©lecteur et les renvoie sous forme de liste structurĂ©e. Dans cet exemple, jâai demandĂ© jusquâĂ cinq tentatives en cas de problĂšme de connexion au site. La valeur par dĂ©faut suffit toutefois dans la plupart des cas.++3. **Collecter des donnĂ©es de boutiques en ligne**++ Voici un prompt un peu plus complexe :+ ```+ Open a stealthy browser session and visit these e-commerce URLs one at a time:+ - https://shop1.com/product-a+ - https://shop2.com/product-b+ - https://shop3.com/product-c++ Get the product names, prices, and descriptions from each page. Close the session when done.+ ```++ Claude peut rĂ©utiliser une session de navigateur, appeler `browser_fetch` pour chaque URL dans lâordre, puis analyser les donnĂ©es extraites.++4. **Un processus plus avancĂ©**++ Imaginons que je veuille tous les jeux dâaction prĂ©sents sur la premiĂšre page du PlayStation Store. Je peux utiliser ce prompt :+ ```+ Extract the URLs of all games on this page, then visit each game in order and return a list of all action games: https://store.playstation.com/en-us/pages/browse+ ```+ Demandez Ă lâIA de rĂ©utiliser une session HTTP pour Ă©viter de lancer un navigateur lorsque les donnĂ©es sont accessibles par des requĂȘtes classiques :+ ```+ Open an HTTP session, extract the URLs of all games on this page, then fetch each game in order and return a list of all action games. Close the session when done: https://store.playstation.com/en-us/pages/browse+ ```+ Si vous savez Ă©crire des sĂ©lecteurs CSS, vous pouvez limiter le contenu avant que lâIA le lise :+ ```+ Use an HTTP session to extract the URLs of all games on the page below, then fetch each game in order and return a list of all action games.+ The selector for games in the first page is `[href*="/concept/"]` and the selector for the genre in each game page is `[data-qa="gameInfo#releaseInformation#genre-value"]`.+ Close the session when done.++ URL: https://store.playstation.com/en-us/pages/browse+ ```++5. **Obtenir les donnĂ©es dâun site protĂ©gĂ© par Cloudflare**++ Si vous pensez que le site utilise Cloudflare, dites-le Ă Claude pour quâil nâait pas Ă le dĂ©couvrir seul.+ ```+ What's the price of this product? Be cautious, as it utilizes Cloudflare's Turnstile protection. Make the browser visible while you work.++ https://ao.com/product/oo101uk-ninja-woodfire-outdoor-pizza-oven-brown-99357-685.aspx+ ```++6. **Un processus long**++ Vous pouvez utiliser un prompt comme celui-ci :+ ```+ Extract all product URLs for the following category, then return the prices and details for the first 3 products.++ https://www.arnotts.ie/furniture/bedroom/bed-frames/+ ```+ Mais celui-ci serait meilleur :+ ```+ Go to the following category URL and extract all product URLs using the CSS selector "a". Then, reuse the session to fetch the first 3 product pages in order and extract each productâs price and details. Close the session when done.++ Keep the output in markdown format to reduce irrelevant content.++ Category URL:+ https://www.arnotts.ie/furniture/bedroom/bed-frames/+ ```++7. **Utiliser des sessions persistantes**++ Pour extraire des donnĂ©es de plusieurs pages du mĂȘme site, utilisez une session de navigateur persistante. Vous Ă©vitez ainsi de lancer un navigateur Ă chaque requĂȘte :+ ```+ Open a stealthy browser session, then use it to scrape the main details from the first 5 product pages on https://shop.example.com. Close the session when you're done.+ ```+ Claude utilise `browser_open` pour crĂ©er un navigateur persistant, appelle `browser_fetch` pour chaque page de produit dans cette session, puis appelle `close_session` Ă la fin. Câest bien plus rapide que de lancer un navigateur pour chaque page.++ !!! danger "Danger"++ Fermez toujours les sessions persistantes quand vous avez terminĂ© ! Sinon, elles restent ouvertes.++8. **Utiliser une session persistante pour un processus long**++ Voici un autre exemple long qui fait rĂ©flĂ©chir Claude :++ ```+ Use Scrapling MCP to do the following in this order:++ 1. Open a stealthy browser session with headless mode off.+ 2. Go to this page and collect the number of stars: https://github.com/D4Vinci/Scrapling+ 3. From the README, get the URL that shows the number of downloads and go to it.+ 4. Get the number of downloads and the top 3 countries from the graph.+ 5. Prepare a report with the results.+ 6. Close the browser.+ ```++Et ainsi de suite. Votre crĂ©ativitĂ© est la clĂ©.++## Bonnes pratiques {#best-practices}++Voici quelques conseils techniques pour utiliser le serveur.++### 1. Choisir le bon outil {#1-choose-the-right-tool}++- **`make_request`** : RequĂȘtes HTTP rapides pour une seule page ou un appel dâAPI.+- **`browser_fetch_once`** : Une page JavaScript ou dynamique, ou un site protĂ©gĂ©, y compris par Cloudflare.+- **Outils de session** : RequĂȘtes liĂ©es, actions du navigateur, captures dâĂ©cran et historique rĂ©seau.++### 2. AmĂ©liorer les performances {#2-optimize-performance}++- RĂ©utilisez une session et rĂ©cupĂ©rez chaque URL dans lâordre.+- DĂ©sactivez les ressources inutiles.+- DĂ©finissez des dĂ©lais dâexpiration adaptĂ©s.+- Utilisez des sĂ©lecteurs CSS pour extraire uniquement le contenu voulu.++### 3. GĂ©rer le contenu dynamique {#3-handle-dynamic-content}++- Utilisez `network_idle` pour les applications Ă page unique (SPA).+- DĂ©finissez `wait_selector` pour attendre des Ă©lĂ©ments prĂ©cis.+- Augmentez le dĂ©lai dâexpiration pour les sites lents.++### 4. QualitĂ© des donnĂ©es {#4-data-quality}++- Utilisez `main_content_only=true` pour sĂ©lectionner et nettoyer le corps de la page.+- Choisissez un `extraction_type` adaptĂ© Ă votre besoin.++### 5. Protection contre lâinjection dâinstructions {#5-prompt-injection-protection}++Le serveur MCP nettoie automatiquement le contenu extrait quand `main_content_only` est activĂ©, comme câest le cas par dĂ©faut. Il retire le contenu cachĂ© quâun site malveillant pourrait utiliser pour injecter des instructions dans le contexte de lâIA :++- **Styles en ligne qui masquent le contenu** : `display:none`, `visibility:hidden` et valeurs nulles pour lâopacitĂ©, la taille de police, la hauteur, la largeur, la hauteur maximale et la largeur maximale.+- **ĂlĂ©ments cachĂ©s pour lâaccessibilitĂ©** : `aria-hidden="true"`.+- **Balises de template et slots cachĂ©s** : ĂlĂ©ments `<template>` et `<slot hidden>`.+- **Commentaires HTML** : `<!-- ... -->`.+- **CaractĂšres de largeur nulle** : CaractĂšres Unicode invisibles, comme les espaces de largeur nulle.++Cette protection sâapplique automatiquement Ă lâextraction HTML, Markdown et texte. Gardez `main_content_only=true`, la valeur par dĂ©faut, pour une protection maximale.++### 6. GĂ©rer les sessions {#6-manage-sessions}++- Utilisez `make_request` ou `browser_fetch_once` pour une rĂ©cupĂ©ration indĂ©pendante. Ces outils ferment leurs propres ressources et ne laissent pas de session pour les appels suivants.+- Utilisez `browser_open` pour crĂ©er une session persistante lorsque vous travaillez sur plusieurs pages. Appelez ensuite `browser_fetch` pour chaque page dans cette session.+- Pour plusieurs requĂȘtes HTTP sans navigateur, utilisez `open_request_session`, puis `session_make_request` pour chacune. La session conserve les cookies, les connexions et lâempreinte du navigateur (`impersonate`) entre les appels.+- Les sessions gardent la configuration dĂ©finie Ă leur ouverture : headless, locale, cookies et options de discrĂ©tion pour les navigateurs ; `impersonate` et `proxy` pour les sessions HTTP. Les options propres Ă une requĂȘte, comme timeout, wait_selector, network_idle et solve_cloudflare, sont passĂ©es Ă `browser_fetch`/`session_make_request` Ă chaque appel. Leurs valeurs par dĂ©faut figurent dans les schĂ©mas des outils.+- `browser_fetch` peut rĂ©soudre les dĂ©fis Cloudflare dans la session ouverte de navigateur Stealthy.+- Fermez toujours les sessions avec `close_session` Ă la fin pour libĂ©rer les ressources.+- Utilisez `list_sessions` pour vĂ©rifier quelles sessions restent actives et consulter le `settings` utilisĂ© Ă leur crĂ©ation. Il est renvoyĂ© Ă lâagent IA et reste vide pour les sessions CDP.+- Passez votre propre `session_id` aux outils dâouverture pour donner des noms clairs aux sessions, comme `"search"` ou `"checkout"`, plutĂŽt que la valeur hexadĂ©cimale alĂ©atoire. Les outils lĂšvent une erreur si lâidentifiant est dĂ©jĂ utilisĂ©, pour que vous dĂ©tectiez le conflit dĂšs le dĂ©part.++### 7. Captures dâĂ©cran {#7-capturing-screenshots}++- `browser_screenshot` capture la page dĂ©jĂ ouverte avec `browser_fetch` dans une session de navigateur Stealthy. Il ne la recharge pas. LâIA peut donc vĂ©rifier les champs remplis, les menus ouverts et les autres rĂ©sultats de ses actions.+- Lâimage est renvoyĂ©e sous forme de bloc `ImageContent` rĂ©el pour que le modĂšle voie la page directement.+- Capturez la zone visible ou la page entiĂšre, y compris le contenu hors Ă©cran.+- Capturez un champ, un graphique, une carte ou un rĂ©sultat pour lâinspecter avec moins de contenu autour. La capture dâun Ă©lĂ©ment peut faire dĂ©filer la page pour le rendre visible.+- Choisissez PNG pour une image sans perte ou JPEG avec une qualitĂ© rĂ©glable pour rĂ©duire la taille.+- LâIA peut utiliser `browser_actions` pour attendre le contenu ou terminer les interactions avant la capture.++## Aspects juridiques et Ă©thiques {#legal-and-ethical-considerations}++â ïž **Consignes importantes :**++- **Consultez robots.txt** : Ouvrez `https://website.com/robots.txt` pour voir les rĂšgles dâexploration.+- **Respectez les limites de requĂȘtes** : Ne surchargez pas les serveurs.+- **Conditions dâutilisation** : Lisez et respectez les conditions du site.+- **Droits dâauteur** : Respectez les droits de propriĂ©tĂ© intellectuelle.+- **Vie privĂ©e** : Tenez compte des lois sur la protection des donnĂ©es personnelles.+- **Usage commercial** : Assurez-vous dâavoir lâautorisation dâutiliser les donnĂ©es Ă des fins commerciales.++---++*Créé avec â€ïž par lâĂ©quipe de Scrapling. Bonne extraction !*diff --git a/docs/locales/fr/api-reference/custom-types.md b/docs/locales/fr/api-reference/custom-types.mdnew file mode 100644index 0000000..56673dd--- /dev/null+++ b/docs/locales/fr/api-reference/custom-types.md@@ -0,0 +1,26 @@+---+title: "RĂ©fĂ©rence de lâAPI de TextHandler et AttributesHandler"+description: "Consultez les outils de texte, listes de texte et attributs de Scrapling : expressions rĂ©guliĂšres, conversion JSON et recherche de valeurs."+---++# RĂ©fĂ©rence des types personnalisĂ©s {#custom-types-api-reference}++Vous trouverez ici les paramĂštres, attributs et mĂ©thodes des classes de types personnalisĂ©s de Scrapling.++Vous pouvez les importer directement :++```python+from scrapling.core.custom_types import TextHandler, TextHandlers, AttributesHandler+```++## ::: scrapling.core.custom_types.TextHandler+ handler: python+ :docstring:++## ::: scrapling.core.custom_types.TextHandlers+ handler: python+ :docstring:++## ::: scrapling.core.custom_types.AttributesHandler+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/fetchers.md b/docs/locales/fr/api-reference/fetchers.mdnew file mode 100644index 0000000..12b208f--- /dev/null+++ b/docs/locales/fr/api-reference/fetchers.md@@ -0,0 +1,48 @@+---+title: "RĂ©fĂ©rence de lâAPI des fetchers HTTP et de navigateur"+description: "Consultez les API de Fetcher, AsyncFetcher, StealthyFetcher et des sessions : requĂȘtes, rĂ©glages du navigateur et types de retour."+---++# Classes des fetchers {#fetchers-classes}++Vous trouverez ici les paramĂštres, attributs et mĂ©thodes de toutes les classes des fetchers.++Vous pouvez les importer directement :++```python+from scrapling.fetchers import (+ Fetcher, AsyncFetcher, StealthyFetcher,+ FetcherSession, AsyncStealthySession, StealthySession+)+```++## ::: scrapling.fetchers.Fetcher+ handler: python+ :docstring:++## ::: scrapling.fetchers.AsyncFetcher+ handler: python+ :docstring:++## ::: scrapling.fetchers.StealthyFetcher+ handler: python+ :docstring:+++## Classes des sessions {#session-classes}++### Sessions HTTP {#http-sessions}++## ::: scrapling.fetchers.FetcherSession+ handler: python+ :docstring:++### Sessions furtives {#stealth-sessions}++## ::: scrapling.fetchers.StealthySession+ handler: python+ :docstring:++## ::: scrapling.fetchers.AsyncStealthySession+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/mcp-server.md b/docs/locales/fr/api-reference/mcp-server.mdnew file mode 100644index 0000000..9461a9f--- /dev/null+++ b/docs/locales/fr/api-reference/mcp-server.md@@ -0,0 +1,96 @@+---+title: "RĂ©fĂ©rence de lâAPI du serveur MCP de Scrapling"+description: "Consultez les outils du serveur MCP et ses modĂšles de requĂȘtes, rĂ©ponses et sessions pour extraire des donnĂ©es par HTTP ou navigateur."+---++# RĂ©fĂ©rence du serveur MCP {#mcp-server-api-reference}++Le **serveur MCP de Scrapling** propose seize outils pour extraire des donnĂ©es et interagir avec le navigateur via le Model Context Protocol (MCP). IntĂ©grez Scrapling aux assistants et agents IA pour extraire des donnĂ©es par la conversation, avec des fonctions contre la dĂ©tection des bots.++DĂ©marrez le serveur MCP avec cette commande :++```bash+scrapling mcp+```++Ou importez directement la classe du serveur :++```python+from scrapling.core.ai import ScraplingMCPServer++server = ScraplingMCPServer()+server.serve(http=False, host="127.0.0.1", port=8000)+```++Pour utiliser votre propre exĂ©cutable de navigateur compatible avec Chromium, passez `executable_path` :++```python+server = ScraplingMCPServer(executable_path="/path/to/chromium")+```++## ModĂšle de rĂ©ponse {#response-model}++Les outils de rĂ©cupĂ©ration de pages et de requĂȘtes HTTP renvoient cette structure, avec une rĂ©ponse par appel. Les outils de gestion des sessions utilisent les modĂšles suivants. `browser_screenshot` renvoie une image de la page ou dâun Ă©lĂ©ment, avec lâURL actuelle, sous forme de blocs image et texte. `browser_extract` et `browser_actions` renvoient du texte brut. Les deux outils rĂ©seau renvoient du JSON structurĂ© avec les modĂšles suivants. `browser_evaluate` renvoie le rĂ©sultat en JSON dans un bloc texte.++## ::: scrapling.core.ai.server.ResponseModel+ handler: python+ :docstring:++## ModĂšles des requĂȘtes rĂ©seau {#network-request-models}++`browser_network_requests` renvoie `NetworkRequestsModel` avec `requests`, `next_cursor`, `has_more` et `dropped_count`. Chaque `NetworkRequestInfo` contient `id`, `url`, `method`, `resource_type` et `status`. Pour continuer, passez `next_cursor` comme `after_id`. `has_more` indique sâil reste des rĂ©sultats dans lâhistorique actuel.++`browser_network_request` renvoie `NetworkRequestModel` avec `request_id`, `part`, `data` et `note`. Les rĂ©sumĂ©s et les en-tĂȘtes sont des objets. Le contenu complet enregistrĂ© est renvoyĂ© comme une chaĂźne, mĂȘme si la rĂ©ponse contient du JSON. `note` explique si des donnĂ©es du contenu manquent ou si les en-tĂȘtes sont incomplets.++## ::: scrapling.core.ai._network_formatting.NetworkRequestInfo+ handler: python+ :docstring:++## ::: scrapling.core.ai.server.NetworkRequestsModel+ handler: python+ :docstring:++## ::: scrapling.core.ai._network_formatting.NetworkRequestModel+ handler: python+ :docstring:++## ModĂšles des sessions {#session-models}++Classes de modĂšles pour gĂ©rer les sessions :++## ::: scrapling.core.ai.server.SessionInfo+ handler: python+ :docstring:++## ::: scrapling.core.ai.server.SessionCreatedModel+ handler: python+ :docstring:++## ::: scrapling.core.ai.server.SessionClosedModel+ handler: python+ :docstring:++## Classe du serveur MCP {#mcp-server-class}++La classe principale du serveur MCP propose les outils suivants :++- **`make_request`** : RĂ©cupĂšre une URL par HTTP avec imitation du navigateur et fermeture automatique du client. Accepte GET, POST, PUT et DELETE.+- **`browser_fetch_once`** : RĂ©cupĂšre une URL avec un navigateur furtif, exĂ©cute JavaScript, gĂšre Cloudflare et ferme le navigateur. Utilisez une session persistante si vous devez agir ensuite ou consulter lâhistorique rĂ©seau.++- **`browser_extract`** : Lit la page actuelle ou un Ă©lĂ©ment sous forme de vue structurĂ©e pour lâIA, de HTML, de Markdown ou de texte, sans recharger. Conserve les rĂ©sultats des formulaires et des actions. Les vues structurĂ©es incluent les rĂŽles, noms, rĂ©fĂ©rences, positions et tailles des Ă©lĂ©ments. La recherche par expression rĂ©guliĂšre renvoie les lignes correspondantes, le contexte proche et les nĆuds parents.+- **`browser_actions`** : EnchaĂźne les mouvements de souris, survols, clics, dĂ©filements, saisies, raccourcis clavier, rĂ©ponses aux boĂźtes de dialogue et attentes dans un appel. Acceptez ou fermez les alertes et confirmations, ou saisissez du texte dans une boĂźte de dialogue. Vous pouvez saisir une recherche, lâenvoyer, attendre et ouvrir un rĂ©sultat sans faire un appel par Ă©tape.++ Les mouvements et clics acceptent des sĂ©lecteurs, des rĂ©fĂ©rences de vues structurĂ©es ou des coordonnĂ©es. Lâoutil attend les Ă©lĂ©ments et les amĂšne dans la zone visible. Il accepte les mouvements par Ă©tapes, les clics gauche, droit et central, le double-clic et le dĂ©filement dans des panneaux imbriquĂ©s.++ SĂ©lectionnez les champs par sĂ©lecteur ou rĂ©fĂ©rence de vue structurĂ©e. Saisissez du texte, cochez ou dĂ©cochez des cases, sĂ©lectionnez des boutons radio et choisissez une ou plusieurs options de listes natives par leur libellĂ©. Remplacez ou effacez le texte, ou Ă©crivez Ă la position du curseur. Les raccourcis utilisent le focus actuel. Le mode lent ajoute des pauses alĂ©atoires entre les caractĂšres et les actions.++ Attendez le contenu ou la disparition des indicateurs de chargement avec des sĂ©lecteurs ou des rĂ©fĂ©rences de vues structurĂ©es. Vous pouvez aussi attendre des Ă©vĂ©nements de chargement, la fin de lâactivitĂ© rĂ©seau ou une durĂ©e fixe.++- **`browser_evaluate`** : ExĂ©cute du JavaScript dans la page actuelle pour extraire des donnĂ©es personnalisĂ©es, faire des calculs, lire lâĂ©tat de lâapplication ou modifier le contenu. Accepte les scripts asynchrones et renvoie leurs rĂ©sultats en JSON.+- **`browser_network_requests`** : Recherche les requĂȘtes du navigateur terminĂ©es entre les onglets, navigations et actions. Trouvez les appels API, erreurs HTTP et redirections enregistrĂ©s. Masque les ressources statiques par dĂ©faut pour rĂ©duire les rĂ©sultats. Ignore les requĂȘtes en Ă©chec ou incomplĂštes. Renvoie des donnĂ©es structurĂ©es avec pagination.+- **`browser_network_request`** : Lit le rĂ©sumĂ©, les en-tĂȘtes, les donnĂ©es envoyĂ©es ou le contenu textuel dâune requĂȘte enregistrĂ©e sous forme de JSON structurĂ©, sans la rĂ©pĂ©ter. Renvoie toute la partie choisie. Les rĂ©ponses enregistrĂ©es restent disponibles aprĂšs un changement de page, y compris les rĂ©ponses HTTP 4xx et 5xx. Les entrĂ©es apparaissent quand la capture se termine. Consulter lâhistorique ou fermer la session nâattend pas les captures en cours, qui peuvent ĂȘtre perdues lors de la navigation ou de la fermeture. Les octets viennent de Playwright et peuvent diffĂ©rer de ceux envoyĂ©s par le serveur. Le texte utilise le dĂ©codage UTF-8 de Playwright lorsquâil est valide, sinon lâencodage dĂ©clarĂ©. Seul le contenu avec un `Content-Type` textuel compatible est lu et enregistrĂ©. Pour les types binaires, absents ou inconnus, les mĂ©tadonnĂ©es et les en-tĂȘtes sont conservĂ©s sans lire le contenu. Cela ne change pas le chargement de la page. Lâhistorique a des limites de taille. Une note facultative explique si le contenu nâest pas du texte, est trop grand ou ne peut pas ĂȘtre lu. Lisez les donnĂ©es nĂ©cessaires avant de fermer la session MCP.+- **`browser_fetch`** : RĂ©cupĂšre une page dans une session ouverte de navigateur furtif et extrait du HTML, du Markdown, du texte ou une vue structurĂ©e. Ces vues peuvent couvrir toute la page ou un Ă©lĂ©ment et incluent des rĂ©fĂ©rences, positions et tailles pour agir ensuite.++## ::: scrapling.core.ai.server.ScraplingMCPServer+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/proxy-rotation.md b/docs/locales/fr/api-reference/proxy-rotation.mdnew file mode 100644index 0000000..af697d4--- /dev/null+++ b/docs/locales/fr/api-reference/proxy-rotation.md@@ -0,0 +1,18 @@+---+title: "RĂ©fĂ©rence de lâAPI de ProxyRotator"+description: "Consultez ProxyRotator et les stratĂ©gies de sĂ©lection et de rotation des proxies pour les sessions HTTP et de navigateur."+---++# Rotation des proxies {#proxy-rotation}++La classe `ProxyRotator` permet de changer de proxy en toute sĂ©curitĂ© depuis plusieurs threads, dans tout fetcher ou toute session.++Vous pouvez lâimporter directement :++```python+from scrapling.fetchers import ProxyRotator+```++## ::: scrapling.engines.toolbelt.proxy_rotation.ProxyRotator+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/response.md b/docs/locales/fr/api-reference/response.mdnew file mode 100644index 0000000..e2c4ba1--- /dev/null+++ b/docs/locales/fr/api-reference/response.md@@ -0,0 +1,18 @@+---+title: "RĂ©fĂ©rence de lâAPI de Response"+description: "Consultez le statut, les en-tĂȘtes, le contenu, les mĂ©tadonnĂ©es, la conversion Markdown et follow. Extrayez des donnĂ©es avec les mĂ©thodes hĂ©ritĂ©es de Selector."+---++# Classe Response {#response-class}++La classe `Response` contient les rĂ©ponses HTTP de tous les fetchers. Elle donne accĂšs au statut, aux en-tĂȘtes, au contenu et aux cookies, et permet dâutiliser un `Selector` pour analyser la rĂ©ponse.++Vous pouvez importer la classe `Response` ainsi :++```python+from scrapling.engines.toolbelt.custom import Response+```++## ::: scrapling.engines.toolbelt.custom.Response+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/selector.md b/docs/locales/fr/api-reference/selector.mdnew file mode 100644index 0000000..c041ba0--- /dev/null+++ b/docs/locales/fr/api-reference/selector.md@@ -0,0 +1,24 @@+---+title: "RĂ©fĂ©rence de lâAPI de Selector et Selectors"+description: "Consultez les mĂ©thodes dâanalyse HTML, de sĂ©lection, dâextraction, de navigation et de suivi adaptatif de Selector et Selectors."+---++# Classe Selector {#selector-class}++`Selector` est la classe principale de Scrapling pour analyser le HTML et sĂ©lectionner les Ă©lĂ©ments.++Vous trouverez ici tous les paramĂštres, attributs et mĂ©thodes de `Selector`.++Vous pouvez importer `Selector` directement depuis `scrapling` :++```python+from scrapling.parser import Selector+```++## ::: scrapling.parser.Selector+ handler: python+ :docstring:++## ::: scrapling.parser.Selectors+ handler: python+ :docstring:diff --git a/docs/locales/fr/api-reference/spiders.md b/docs/locales/fr/api-reference/spiders.mdnew file mode 100644index 0000000..aac3272--- /dev/null+++ b/docs/locales/fr/api-reference/spiders.md@@ -0,0 +1,42 @@+---+title: "RĂ©fĂ©rence de lâAPI des spiders, requĂȘtes et rĂ©sultats"+description: "Consultez les hooks des spiders, les requĂȘtes, les sessions, les statistiques dâexploration et les mĂ©thodes dâexport."+---++# Classes des spiders {#spider-classes}++Vous trouverez ici les paramĂštres, attributs et mĂ©thodes des classes du framework de spiders.++Vous pouvez les importer directement :++```python+from scrapling.spiders import Spider, Request, CrawlResult, SessionManager, Response+```++## ::: scrapling.spiders.Spider+ handler: python+ :docstring:++## ::: scrapling.spiders.Request+ handler: python+ :docstring:++## Classes des rĂ©sultats {#result-classes}++## ::: scrapling.spiders.result.CrawlResult+ handler: python+ :docstring:++## ::: scrapling.spiders.result.CrawlStats+ handler: python+ :docstring:++## ::: scrapling.spiders.result.ItemList+ handler: python+ :docstring:++## Gestion des sessions {#session-management}++## ::: scrapling.spiders.session.SessionManager+ handler: python+ :docstring:diff --git a/docs/locales/fr/assets b/docs/locales/fr/assetsnew file mode 120000index 0000000..41aef43--- /dev/null+++ b/docs/locales/fr/assets@@ -0,0 +1 @@+../../assets\ No newline at end of filediff --git a/docs/locales/fr/benchmarks.md b/docs/locales/fr/benchmarks.mdnew file mode 100644index 0000000..254e204--- /dev/null+++ b/docs/locales/fr/benchmarks.md@@ -0,0 +1,33 @@+---+title: "Tests de performance des parsers HTML : Scrapling et autres bibliothĂšques"+description: "Comparez Scrapling Ă dâautres bibliothĂšques Python pour lâanalyse HTML, lâextraction de texte et la recherche dâĂ©lĂ©ments similaires."+---++# Tests de performance {#performance-benchmarks}++Scrapling se distingue aussi par sa vitesse. Ces tests comparent son parser Ă dâautres bibliothĂšques connues.++### Vitesse dâextraction du texte (5âŻ000 Ă©lĂ©ments imbriquĂ©s) {#text-extraction-speed-test-5000-nested-elements}++| # | BibliothĂšque | Temps (ms) | Par rapport Ă Scrapling |+|---|:-----------------:|:---------:|:------------:|+| 1 | Scrapling | 1,99 | 1,0x |+| 2 | Parsel/Scrapy | 2,06 | 1,035 |+| 3 | Lxml seul | 2,56 | 1,286 |+| 4 | PyQuery | 23,98 | ~12x |+| 5 | Selectolax | 197,02 | ~99x |+| 6 | MechanicalSoup | 1545,15 | ~776,5x |+| 7 | BS4 avec Lxml | 1562,1 | ~785,0x |+| 8 | BS4 avec html5lib | 3412,73 | ~1714,9x |+++### Recherche dâĂ©lĂ©ments similaires et de texte {#element-similarity-text-search-performance}++La recherche adaptative dâĂ©lĂ©ments de Scrapling est plus rapide que les autres solutions :++| BibliothĂšque | Temps (ms) | Par rapport Ă Scrapling |+|-------------|:---------:|:------------:|+| Scrapling | 2,3 | 1,0x |+| AutoScraper | 12,58 | 5,47x |++> Chaque rĂ©sultat est la moyenne de 100 exĂ©cutions chronomĂ©trĂ©es. Consultez [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) pour connaĂźtre la mĂ©thode.diff --git a/docs/locales/fr/cli/extract-commands.md b/docs/locales/fr/cli/extract-commands.mdnew file mode 100644index 0000000..209c659--- /dev/null+++ b/docs/locales/fr/cli/extract-commands.md@@ -0,0 +1,325 @@+---+title: "Enregistrer des pages en Markdown, HTML ou texte depuis la CLI"+description: "Utilisez scrapling extract pour enregistrer les rĂ©sultats HTTP ou du navigateur. Filtrez le contenu avec CSS, ajustez les requĂȘtes et choisissez le format de sortie."+---++# Guide de la commande dâextraction de Scrapling {#scrapling-extract-command-guide}++**Extrayez des donnĂ©es web depuis le terminal sans programmer !**++La commande `scrapling extract` permet de tĂ©lĂ©charger et dâextraire le contenu de sites directement depuis le terminal, sans Ă©crire de code. Elle est utile aux dĂ©butants, aux chercheurs et Ă toute personne qui veut extraire rapidement des donnĂ©es web.++!!! success "Avant de commencer"++ 1. Lisez la page sur les [bases des fetchers](../fetching/choosing.md) pour comprendre lâ[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.+ 2. Lisez la page sur la [sĂ©lection dâĂ©lĂ©ments](../parsing/selection.md) pour apprendre Ă trouver et extraire des Ă©lĂ©ments dâun objet [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).+ 3. Lisez la page des [classes principales](../parsing/main_classes.md) pour connaĂźtre les propriĂ©tĂ©s et mĂ©thodes hĂ©ritĂ©es par [Response](../fetching/choosing.md#response-object) de [Selector](../parsing/main_classes.md#selector).+ 4. Lisez au moins une page de la section des fetchers pour les requĂȘtes que vous utiliserez ici : [requĂȘtes HTTP](../fetching/static.md) ou [rĂ©cupĂ©ration avec un navigateur](../fetching/stealthy.md).++## Quâest-ce que le groupe de commandes Extract ? {#what-is-the-extract-command-group}++Câest un ensemble dâoutils simples pour le terminal qui permet de :++- **TĂ©lĂ©charger des pages web** et enregistrer leur contenu dans des fichiers.+- **Convertir le HTML dans des formats faciles Ă lire**, comme Markdown, le garder en HTML ou extraire seulement le texte de la page.+- **Utiliser vos propres sĂ©lecteurs CSS** pour extraire certaines parties de la page.+- **Envoyer des requĂȘtes HTTP et rĂ©cupĂ©rer des pages avec un navigateur**.+- **RĂ©gler presque toutes les options** disponibles dans le code, comme les en-tĂȘtes, les cookies et les proxies, aussi depuis la ligne de commande.++!!! tip "Mode pour lâIA"++ Toutes les commandes dâextraction acceptent lâoption `--ai-targeted`. Lorsquâelle est activĂ©e, seul le contenu principal du corps de la page est extrait. Elle supprime aussi les balises sans texte utile (script, style, noscript, svg), les Ă©lĂ©ments cachĂ©s qui pourraient servir Ă injecter des instructions (Ă©lĂ©ments masquĂ©s par des styles en ligne, aria-hidden, slots cachĂ©s et balises template), les caractĂšres Unicode de largeur nulle et les commentaires HTML. Avec la commande de navigateur (`fetch`), elle active aussi le blocage des publicitĂ©s. Ce mode est utile lorsque le rĂ©sultat est destinĂ© Ă un modĂšle dâIA.++## DĂ©marrage rapide {#quick-start}++- **TĂ©lĂ©charger une page**++ TĂ©lĂ©chargez le contenu dâune page sous forme de texte propre et lisible :+ ```bash+ scrapling extract get "https://example.com" page_content.txt+ ```+ Cette commande envoie une requĂȘte HTTP GET et enregistre le texte de la page dans `page_content.txt`.++- **Enregistrer dans dâautres formats**++ Choisissez le format de sortie en changeant lâextension du fichier :+ ```bash+ # Convert the HTML content to Markdown, then save it to the file (great for documentation)+ scrapling extract get "https://blog.example.com" article.md++ # Save the HTML content as it is to the file+ scrapling extract get "https://example.com" page.html++ # Save a clean version of the text content of the webpage to the file+ scrapling extract get "https://example.com" content.txt++ # Or use the Docker image with something like this:+ docker run -v $(pwd)/output:/output pyd4vinci/scrapling extract get "https://blog.example.com" /output/article.md+ ```++- **Extraire un contenu prĂ©cis**++ Toutes les commandes peuvent utiliser des sĂ©lecteurs CSS pour extraire certaines parties de la page avec `--css-selector` ou `-s`, comme dans les exemples ci-dessous.++## Commandes disponibles {#available-commands}++ExĂ©cutez `scrapling extract --help` pour afficher cette liste de commandes :+```bash+Usage: scrapling extract [OPTIONS] COMMAND [ARGS]...++ Fetch web pages using various fetchers and extract full/selected HTML content as HTML, Markdown, or extract text content.++Options:+ --help Show this message and exit.++Commands:+ get Perform a GET request and save the content to a file.+ post Perform a POST request and save the content to a file.+ put Perform a PUT request and save the content to a file.+ delete Perform a DELETE request and save the content to a file.+ fetch Use StealthyFetcher to fetch content with advanced stealth features.+```++Nous allons dĂ©tailler chacune dâelles.++### RequĂȘtes HTTP {#http-requests}++1. **RequĂȘte GET**++ La commande la plus courante pour tĂ©lĂ©charger le contenu dâun site :++ ```bash+ scrapling extract get [URL] [OUTPUT_FILE] [OPTIONS]+ ```++ **Exemples :**+ ```bash+ # Basic download+ scrapling extract get "https://news.site.com" news.md++ # Download with custom timeout+ scrapling extract get "https://example.com" content.txt --timeout 60++ # Extract only specific content using CSS selectors+ scrapling extract get "https://blog.example.com" articles.md --css-selector "article"++ # Send a request with cookies+ scrapling extract get "https://scrapling.requestcatcher.com" content.md --cookies "session=abc123; user=john"++ # Add user agent+ scrapling extract get "https://api.site.com" data.txt -H "User-Agent: MyBot 1.0"++ # Add multiple headers+ scrapling extract get "https://site.com" page.html -H "Accept: text/html" -H "Accept-Language: en-US"+ ```+ Consultez les options avec `scrapling extract get --help` :+ ```bash+ Usage: scrapling extract get [OPTIONS] URL OUTPUT_FILE++ Perform a GET request and save the content to a file.++ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.++ Options:+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"+ --timeout INTEGER Request timeout in seconds (default: 30)+ --proxy TEXT Proxy URL in format "http://username:password@host:port"+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)+ --verify / --no-verify Whether to verify SSL certificates (default: True)+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)+ --help Show this message and exit.++ ```+ Ces options fonctionnent de la mĂȘme façon pour les autres commandes de requĂȘte. Il nâest donc pas nĂ©cessaire de rĂ©pĂ©ter leur explication.++2. **RequĂȘte POST**++ ```bash+ scrapling extract post [URL] [OUTPUT_FILE] [OPTIONS]+ ```++ **Exemples :**+ ```bash+ # Submit form data+ scrapling extract post "https://api.site.com/search" results.html --data "query=python&type=tutorial"++ # Send JSON data+ scrapling extract post "https://api.site.com" response.txt --json '{"username": "test", "action": "search"}'+ ```+ Consultez les options avec `scrapling extract post --help` :+ ```bash+ Usage: scrapling extract post [OPTIONS] URL OUTPUT_FILE++ Perform a POST request and save the content to a file.++ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.++ Options:+ -d, --data TEXT Form data to include in the request body (as string, ex: "param1=value1¶m2=value2")+ -j, --json TEXT JSON data to include in the request body (as string)+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"+ --timeout INTEGER Request timeout in seconds (default: 30)+ --proxy TEXT Proxy URL in format "http://username:password@host:port"+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)+ --verify / --no-verify Whether to verify SSL certificates (default: True)+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)+ --help Show this message and exit.++ ```++3. **RequĂȘte PUT**++ ```bash+ scrapling extract put [URL] [OUTPUT_FILE] [OPTIONS]+ ```++ **Exemples :**+ ```bash+ # Send data+ scrapling extract put "https://scrapling.requestcatcher.com/put" results.html --data "update=info" --impersonate "firefox"++ # Send JSON data+ scrapling extract put "https://scrapling.requestcatcher.com/put" response.txt --json '{"username": "test", "action": "search"}'+ ```+ Consultez les options avec `scrapling extract put --help` :+ ```bash+ Usage: scrapling extract put [OPTIONS] URL OUTPUT_FILE++ Perform a PUT request and save the content to a file.++ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.++ Options:+ -d, --data TEXT Form data to include in the request body+ -j, --json TEXT JSON data to include in the request body (as string)+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"+ --timeout INTEGER Request timeout in seconds (default: 30)+ --proxy TEXT Proxy URL in format "http://username:password@host:port"+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)+ --verify / --no-verify Whether to verify SSL certificates (default: True)+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)+ --help Show this message and exit.+ ```++4. **RequĂȘte DELETE**++ ```bash+ scrapling extract delete [URL] [OUTPUT_FILE] [OPTIONS]+ ```++ **Exemples :**+ ```bash+ # Send data+ scrapling extract delete "https://scrapling.requestcatcher.com/delete" results.html++ # Send JSON data+ scrapling extract delete "https://scrapling.requestcatcher.com/" response.txt --impersonate "chrome"+ ```+ Consultez les options avec `scrapling extract delete --help` :+ ```bash+ Usage: scrapling extract delete [OPTIONS] URL OUTPUT_FILE++ Perform a DELETE request and save the content to a file.++ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.++ Options:+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"+ --timeout INTEGER Request timeout in seconds (default: 30)+ --proxy TEXT Proxy URL in format "http://username:password@host:port"+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)+ --verify / --no-verify Whether to verify SSL certificates (default: True)+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)+ --help Show this message and exit.+ ```++### RĂ©cupĂ©rer des pages avec un navigateur {#browser-fetching}++Utilisez `fetch` pour les pages JavaScript, lâautomatisation du navigateur et les sites protĂ©gĂ©s. Cette commande exĂ©cute `StealthyFetcher` avec toutes les options disponibles pour masquer lâautomatisation.++```bash+scrapling extract fetch "https://scrapling.requestcatcher.com/" content.md --network-idle+scrapling extract fetch "https://scrapling.requestcatcher.com/" data.txt --wait-selector ".content-loaded"+scrapling extract fetch "https://scrapling.requestcatcher.com/" page.html --no-headless --disable-resources+scrapling extract fetch "https://nopecha.com/demo/cloudflare" data.txt --solve-cloudflare --css-selector "#padded_content a"+scrapling extract fetch "https://site.com" content.md --proxy "http://proxy-server:8080"+```++Utilisez `--pierce-shadow` pour inclure le contenu des Shadow DOM ouverts. Lâoption est dĂ©sactivĂ©e par dĂ©faut ; `--no-pierce-shadow` la dĂ©sactive explicitement. Consultez [Shadow DOM](../fetching/stealthy.md#shadow-dom) pour voir des exemples de sĂ©lecteurs et leurs limites.++```bash+scrapling extract fetch "https://example.com" content.md --pierce-shadow+```++ExĂ©cutez `scrapling extract fetch --help` pour afficher toutes les options :++```text+Usage: scrapling extract fetch [OPTIONS] URL OUTPUT_FILE++ Use StealthyFetcher to fetch content with advanced stealth features.++Options:+ --headless / --no-headless Run browser in headless mode (default: True)+ --disable-resources / --enable-resources Drop unnecessary resources for speed boost (default: False)+ --block-webrtc / --allow-webrtc Block WebRTC entirely (default: False)+ --solve-cloudflare / --no-solve-cloudflare Solve Cloudflare challenges (default: False)+ --allow-webgl / --block-webgl Allow WebGL (default: True)+ --pierce-shadow / --no-pierce-shadow Include open Shadow DOM content (default: False)+ --network-idle / --no-network-idle Wait for network idle (default: False)+ --real-chrome/--no-real-chrome If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it. (default: False)+ --timeout INTEGER Timeout in milliseconds (default: 30000)+ --wait INTEGER Additional wait time in milliseconds after page load (default: 0)+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.+ --wait-selector TEXT CSS selector to wait for before proceeding+ --hide-canvas / --show-canvas Add noise to canvas operations (default: False)+ --locale TEXT Specify user locale. Defaults to the system default locale.+ --proxy TEXT Proxy URL in format "http://username:password@host:port"+ -H, --extra-headers TEXT Extra headers in format "Key: Value" (can be used multiple times)+ --dns-over-https / --no-dns-over-https Route DNS through Cloudflare's DoH to prevent DNS leaks when using proxies (default: False)+ --block-ads / --no-block-ads Block requests to known ad and tracker domains (default: False)+ --executable-path TEXT Path to a custom Chromium-compatible browser executable. Falls back to the SCRAPLING_EXECUTABLE_PATH environment variable when not set.+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)+ --help Show this message and exit.+```++## Quand utiliser chaque commande {#when-to-use-each-command}++Si vous dĂ©butez dans lâextraction de donnĂ©es web, ces rĂšgles vous aideront Ă choisir :++- Utilisez **`get`** pour les sites simples, les blogs ou les articles de presse.+- Utilisez **`fetch`** pour les pages JavaScript, lâautomatisation du navigateur ou les sites protĂ©gĂ©s, y compris ceux qui utilisent Cloudflare.++## Aspects juridiques et Ă©thiques {#legal-and-ethical-considerations}++â ïž **Consignes importantes :**++- **Consultez robots.txt** : Ouvrez `https://website.com/robots.txt` pour voir les rĂšgles dâexploration.+- **Respectez les limites de requĂȘtes** : Ne surchargez pas les serveurs.+- **Conditions dâutilisation** : Lisez et respectez les conditions du site.+- **Droits dâauteur** : Respectez les droits de propriĂ©tĂ© intellectuelle.+- **Vie privĂ©e** : Tenez compte des lois sur la protection des donnĂ©es personnelles.+- **Usage commercial** : Assurez-vous dâavoir lâautorisation dâutiliser les donnĂ©es Ă des fins commerciales.++---++*Bonne extraction ! Pensez Ă respecter les rĂšgles des sites et toutes les lois et rĂ©glementations applicables.*diff --git a/docs/locales/fr/cli/interactive-shell.md b/docs/locales/fr/cli/interactive-shell.mdnew file mode 100644index 0000000..8c2b18c--- /dev/null+++ b/docs/locales/fr/cli/interactive-shell.md@@ -0,0 +1,236 @@+---+title: "Tester lâextraction de donnĂ©es dans le shell interactif de Scrapling"+description: "RĂ©cupĂ©rez des pages, testez des sĂ©lecteurs et vĂ©rifiez les rĂ©sultats dans un shell IPython. Convertissez des commandes curl, rĂ©utilisez les rĂ©ponses rĂ©centes et testez votre code."+---++# Guide du shell interactif de Scrapling {#scrapling-interactive-shell-guide}++<script src="https://asciinema.org/a/736339.js" id="asciicast-736339" async data-autoplay="1" data-loop="1" data-cols="225" data-rows="40" data-start-at="00:06" data-speed="1.5" data-theme="tango"></script>++**Un environnement REPL dâextraction de donnĂ©es web pour les dĂ©veloppeurs et les spĂ©cialistes des donnĂ©es**++Le shell interactif de Scrapling est un environnement basĂ© sur IPython, conçu pour extraire des donnĂ©es web. Il donne accĂšs Ă toutes les fonctions de Scrapling, Ă des raccourcis pratiques, Ă la gestion automatique des pages et Ă des outils comme la conversion de commandes curl.++!!! success "Avant de commencer"++ 1. Lisez la page sur les [bases des fetchers](../fetching/choosing.md) pour comprendre lâ[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.+ 2. Lisez la page sur la [sĂ©lection dâĂ©lĂ©ments](../parsing/selection.md) pour apprendre Ă trouver et extraire des Ă©lĂ©ments dâun objet [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).+ 3. Lisez la page des [classes principales](../parsing/main_classes.md) pour connaĂźtre les propriĂ©tĂ©s et mĂ©thodes hĂ©ritĂ©es par [Response](../fetching/choosing.md#response-object) de [Selector](../parsing/main_classes.md#selector).+ 4. Lisez au moins une page de la section des fetchers pour les requĂȘtes que vous utiliserez ici : [requĂȘtes HTTP](../fetching/static.md) ou [rĂ©cupĂ©ration avec un navigateur](../fetching/stealthy.md).++## Pourquoi utiliser le shell interactif ? {#why-use-the-interactive-shell}++Le shell interactif permet dâexplorer et de tester tout de suite, sans modifier puis exĂ©cuter un script Ă chaque essai. Il est utile pour :++- **CrĂ©er rapidement des prototypes** : Testez vos mĂ©thodes dâextraction sur le moment.+- **Explorer les donnĂ©es** : Parcourez des sites et extrayez leurs donnĂ©es de façon interactive.+- **Apprendre Scrapling** : Essayez ses fonctions en temps rĂ©el.+- **DĂ©boguer des scrapers** : Suivez les requĂȘtes et vĂ©rifiez leurs rĂ©sultats Ă©tape par Ă©tape.+- **Convertir des commandes** : Transformez une commande curl des DevTools du navigateur en requĂȘte Fetcher avec une ligne.++## Premiers pas {#getting-started}++### Lancer le shell {#launch-the-shell}++```bash+# Start the interactive shell+scrapling shell++# Execute code and exit (useful for scripting)+scrapling shell -c "get('https://quotes.toscrape.com'); print(len(page.css('.quote')))"++# Set logging level+scrapling shell --loglevel info+```++Au lancement, vous verrez la banniĂšre de Scrapling et pourrez commencer Ă extraire des donnĂ©es, comme dans la vidĂ©o ci-dessus :++```python+# No imports needed - everything is ready!+get('https://news.ycombinator.com')++# Explore the page structure+page.css('a')[:5] # Look at first 5 links++# Refine your selectors+stories = page.css('.titleline>a')+len(stories) # 30++# Extract specific data+for story in stories[:3]:+ title = story.text+ url = story['href']+ print(f"{title}: {url}")++# Try different approaches+titles = page.css('.titleline>a::text') # Direct text extraction+urls = page.css('.titleline>a::attr(href)') # Direct attribute extraction+```++## Raccourcis intĂ©grĂ©s {#built-in-shortcuts}++Le shell propose des raccourcis pour Ă©viter le code rĂ©pĂ©titif :++- **`get(url, **kwargs)`** - RequĂȘte HTTP GET (au lieu de `Fetcher.get`).+- **`post(url, **kwargs)`** - RequĂȘte HTTP POST (au lieu de `Fetcher.post`).+- **`put(url, **kwargs)`** - RequĂȘte HTTP PUT (au lieu de `Fetcher.put`).+- **`delete(url, **kwargs)`** - RequĂȘte HTTP DELETE (au lieu de `Fetcher.delete`).+- **`fetch(url, **kwargs)`** - RĂ©cupĂ©ration avec le navigateur Stealthy (au lieu de `StealthyFetcher.fetch`).++Les classes les plus courantes sont disponibles sans importation, notamment `Fetcher`, `AsyncFetcher`, `StealthyFetcher` et `Selector`.++### Gestion automatique des pages {#smart-page-management}++Le shell suit vos requĂȘtes et vos pages :++- **AccĂšs Ă la page actuelle**++ `page` et `response` sont mis Ă jour automatiquement avec la derniĂšre page rĂ©cupĂ©rĂ©e :++ ```python+ get('https://quotes.toscrape.com')+ # 'page' and 'response' both refer to the last fetched page+ page.url # 'https://quotes.toscrape.com'+ response.status # Prints 200; Same as page.status+ ```++- **Historique des pages**++ `pages` conserve les cinq derniĂšres pages dans un objet `Selectors` :++ ```python+ get('https://site1.com')+ get('https://site2.com')+ get('https://site3.com')++ # Access last 5 pages+ len(pages) # `Selectors` object with `page` history -> 3+ pages[0].url # First page in history -> 'https://site1.com'+ pages[-1].url # Most recent page -> 'https://site3.com'++ # Work with historical pages+ for i, old_page in enumerate(pages):+ print(f"Page {i}: {old_page.url} - {old_page.status}")+ ```++## Autres commandes utiles {#additional-helpful-commands}++### Afficher la page {#page-visualization}++Ouvrez les pages rĂ©cupĂ©rĂ©es dans votre navigateur :++```python+get('https://quotes.toscrape.com')+view(page) # Opens the page HTML in your default browser+```++### IntĂ©gration des commandes curl {#curl-command-integration}++Le shell fournit les fonctions `uncurl` et `curl2fetcher` pour convertir les commandes curl des DevTools du navigateur en requĂȘtes `Fetcher`.++Commencez par copier une requĂȘte sous forme de commande curl :++<img src="../assets/scrapling_shell_curl.png" title="Copier une requĂȘte de Chrome sous forme de commande curl" alt="Copier une requĂȘte de Chrome sous forme de commande curl" style="width: 70%;"/>++- **Convertir une commande curl en objet de requĂȘte**++ ```python+ curl_cmd = '''curl 'https://scrapling.requestcatcher.com/post' \+ -X POST \+ -H 'Content-Type: application/json' \+ -d '{"name": "test", "value": 123}' '''++ request = uncurl(curl_cmd)+ request.method # -> 'post'+ request.url # -> 'https://scrapling.requestcatcher.com/post'+ request.headers # -> {'Content-Type': 'application/json'}+ ```++- **ExĂ©cuter directement une commande curl**++ ```python+ # Convert and execute in one step+ curl2fetcher(curl_cmd)+ page.status # -> 200+ ```++### Fonctions dâIPython {#ipython-features}++Le shell hĂ©rite de toutes les fonctions dâIPython :++```python+# Magic commands+%time page = get('https://example.com') # Time execution+%history # Show command history+%save filename.py 1-10 # Save commands 1-10 to file++# Tab completion works everywhere+page.c<TAB> # Shows: css, cookies, headers, etc.+Fetcher.<TAB> # Shows all Fetcher methods++# Object inspection+get? # Show get documentation+```++## Exemples {#examples}++Voici quelques exemples gĂ©nĂ©rĂ©s avec lâIA :++#### Collecter des donnĂ©es de boutiques en ligne {#e-commerce-data-collection}++```python+# Start with product listing page+catalog = get('https://shop.example.com/products')++# Find product links+product_links = catalog.css('.product-link::attr(href)').getall()+print(f"Found {len(product_links)} products")++# Sample a few products first+for link in product_links[:3]:+ product = get(catalog.urljoin(link))+ name = product.css('.product-name::text').get('')+ price = product.css('.price::text').get('')+ print(f"{name}: {price}")++# Scale up with sessions for efficiency+from scrapling.fetchers import FetcherSession+with FetcherSession() as session:+ products = []+ for link in product_links:+ product = session.get(catalog.urljoin(link))+ products.append({+ 'name': product.css('.product-name::text').get(''),+ 'price': product.css('.price::text').get(''),+ 'url': link+ })+```++#### IntĂ©grer et tester des API {#api-integration-and-testing}++```python+>>> # Test API endpoints interactively+>>> response = get('https://jsonplaceholder.typicode.com/posts/1')+>>> response.json()+{'userId': 1, 'id': 1, 'title': 'sunt aut...', 'body': 'quia et...'}++>>> # Test POST requests+>>> new_post = post('https://jsonplaceholder.typicode.com/posts',+... json={'title': 'Test Post', 'body': 'Test content', 'userId': 1})+>>> new_post.json()['id']+101++>>> # Test with different data+>>> updated = put('https://jsonplaceholder.typicode.com/posts/1',+... json={'title': 'Updated Title'})+```++## Obtenir de lâaide {#getting-help}++Si vous avez besoin dâaide au-delĂ de celle proposĂ©e dans le terminal, consultez :++- [Documentation de Scrapling](https://scrapling.readthedocs.io/en/latest/fr/)+- [CommunautĂ© Discord](https://discord.gg/EMgGbDceNQ)+- [Tickets GitHub](https://github.com/D4Vinci/Scrapling/issues)++VoilĂ ! Bonne extraction. Avec le shell, extraire des donnĂ©es web devient aussi simple quâune conversation.diff --git a/docs/locales/fr/cli/overview.md b/docs/locales/fr/cli/overview.mdnew file mode 100644index 0000000..a762336--- /dev/null+++ b/docs/locales/fr/cli/overview.md@@ -0,0 +1,36 @@+---+title: "CLI de Scrapling : extraire des donnĂ©es depuis le terminal"+description: "Installez les outils de terminal de Scrapling et choisissez entre les commandes dâextraction, le shell interactif et le serveur MCP. Suivez le guide adaptĂ© Ă votre tĂąche."+---++# Interface en ligne de commande {#command-line-interface}++Depuis la version 0.3, Scrapling inclut une interface en ligne de commande avec trois fonctions principales :++1. **Shell interactif** : Un environnement dâextraction de donnĂ©es web basĂ© sur IPython, avec de nombreux raccourcis et outils utiles.+2. **Commandes dâextraction** : Extrayez des donnĂ©es de sites depuis le terminal sans programmer.+3. **Commandes utilitaires** : Des outils dâinstallation et de gestion.++```bash+# Launch interactive shell+scrapling shell++# Convert the content of a page to markdown and save it to a file+scrapling extract get "https://example.com" content.md++# Get help for any command+scrapling --help+scrapling extract --help+```++## PrĂ©requis {#requirements}++Pour utiliser les outils de cette section, installez le groupe de dĂ©pendances supplĂ©mentaires `shell` :+```bash+pip install "scrapling[shell]"+```+Pour rĂ©cupĂ©rer des pages avec un navigateur, installez aussi ses dĂ©pendances :+```bash+scrapling install+```+Cette commande tĂ©lĂ©charge Chromium et ses dĂ©pendances systĂšme, puis met Ă jour la liste des TLD. Les requĂȘtes HTTP nâont pas besoin de cette Ă©tape.diff --git a/docs/locales/fr/development/adaptive_storage_system.md b/docs/locales/fr/development/adaptive_storage_system.mdnew file mode 100644index 0000000..080737e--- /dev/null+++ b/docs/locales/fr/development/adaptive_storage_system.md@@ -0,0 +1,72 @@+---+title: "CrĂ©ez un systĂšme de stockage pour lâanalyse adaptative"+description: "ImplĂ©mentez save et retrieve pour lâanalyse adaptative de Scrapling. CrĂ©ez un systĂšme Redis pour enregistrer et retrouver les propriĂ©tĂ©s des Ă©lĂ©ments."+---++# CrĂ©er votre propre systĂšme de stockage {#writing-your-retrieval-system}++Scrapling utilise SQLite par dĂ©faut. Ce guide montre comment crĂ©er votre propre systĂšme pour enregistrer les propriĂ©tĂ©s des Ă©lĂ©ments utilisĂ©es par la fonction `adaptive`.++Vous pouvez par exemple utiliser Firebase pour partager une base de donnĂ©es entre plusieurs spiders sur diffĂ©rentes machines. Une base de donnĂ©es en ligne leur permet de partager les donnĂ©es adaptatives.++Pour fonctionner, votre classe de stockage doit respecter trois conditions :++1. HĂ©riter de la classe abstraite `scrapling.core.storage.StorageSystemMixin` et accepter un argument de type chaĂźne, `url`, pour conserver la logique de la bibliothĂšque.+2. Utiliser le dĂ©corateur `functools.lru_cache` sur la classe pour suivre le modĂšle Singleton, comme les autres classes.+3. ImplĂ©menter les mĂ©thodes `save` et `retrieve` selon leurs annotations de type :+ - La mĂ©thode `save` ne renvoie rien et reçoit deux arguments de la bibliothĂšque :+ * Le premier est lâĂ©lĂ©ment lui-mĂȘme, de type `lxml.html.HtmlElement`. Convertissez-le en dictionnaire avec la fonction `element_to_dict` du sous-module `scrapling.core.utils._StorageTools` pour garder le mĂȘme format, puis enregistrez-le dans votre base de donnĂ©es.+ * Le second est une chaĂźne contenant lâidentifiant utilisĂ© pour retrouver lâĂ©lĂ©ment. La combinaison de cet identifiant et de lâargument `url` reçu Ă la crĂ©ation de lâinstance doit ĂȘtre unique pour chaque ligne. Sinon, les donnĂ©es de `adaptive` seront mĂ©langĂ©es.+ - La mĂ©thode `retrieve` reçoit une chaĂźne contenant lâidentifiant. Utilisez-le avec lâ`url` reçue Ă la crĂ©ation de lâinstance pour retrouver le dictionnaire de lâĂ©lĂ©ment. Renvoyez ce dictionnaire sâil existe, ou `None` sinon.++> Vous pouvez consulter un exemple avec SQLite3 dans le fichier [storage_adaptors](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py).++Si votre classe respecte ces conditions, la suite est simple. Si vous prĂ©voyez dâutiliser la bibliothĂšque dans une application avec plusieurs threads, assurez-vous que votre classe le permet sans conflit. La classe par dĂ©faut le permet dĂ©jĂ .++La classe abstraite contient aussi des fonctions utilitaires que vous pouvez utiliser. Consultez le [code](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py), qui contient de nombreux commentaires :)++## Exemple pratique : stockage avec Redis {#real-world-example-redis-storage}++Voici un exemple pratique avec Redis, gĂ©nĂ©rĂ© par IA :++```python+import redis+import orjson+from functools import lru_cache+from scrapling.core.storage import StorageSystemMixin+from scrapling.core.utils import _StorageTools++@lru_cache(None)+class RedisStorage(StorageSystemMixin):+ def __init__(self, host='localhost', port=6379, db=0, url=None):+ super().__init__(url)+ self.redis = redis.Redis(+ host=host,+ port=port,+ db=db,+ decode_responses=False+ )++ def save(self, element, identifier: str) -> None:+ # Convert element to dictionary+ element_dict = _StorageTools.element_to_dict(element)++ # Create key+ key = f"scrapling:{self._get_base_url()}:{identifier}"++ # Store as JSON+ self.redis.set(+ key,+ orjson.dumps(element_dict)+ )++ def retrieve(self, identifier: str) -> dict | None:+ # Get data+ key = f"scrapling:{self._get_base_url()}:{identifier}"+ data = self.redis.get(key)++ # Parse JSON if exists+ if data:+ return orjson.loads(data)+ return None+```diff --git a/docs/locales/fr/development/scrapling_custom_types.md b/docs/locales/fr/development/scrapling_custom_types.mdnew file mode 100644index 0000000..f06e06e--- /dev/null+++ b/docs/locales/fr/development/scrapling_custom_types.md@@ -0,0 +1,28 @@+---+title: "Utilisez les types de texte et dâattributs de Scrapling dans votre code"+description: "Utilisez TextHandler, TextHandlers et AttributesHandler hors de lâanalyseur. DĂ©couvrez leurs types de base Python, les fonctions JSON et les attributs en lecture seule."+---++# Utiliser les types propres Ă Scrapling {#using-scraplings-custom-types}++> Vous pouvez utiliser les types créés pour Scrapling en dehors de la bibliothĂšque. Câest plus simple que de copier leur code :)++### Vous pouvez importer chaque type sĂ©parĂ©ment {#all-current-types-can-be-imported-alone-like-below}++```python+from scrapling.core.custom_types import TextHandler, AttributesHandler++somestring = TextHandler('{}')+parsed = somestring.json()+somedict_1 = AttributesHandler({'a': 1})+somedict_2 = AttributesHandler(a=1)+```++`TextHandler` est une sous-classe de `str` de Python. Toutes les opĂ©rations et mĂ©thodes habituelles des chaĂźnes fonctionnent donc avec elle.+`parsed` est le dictionnaire `{}`, pas la chaĂźne `'{}'`. Pour vĂ©rifier une instance, utilisez `isinstance(somestring, TextHandler)`. Pour vĂ©rifier une classe, utilisez `issubclass(TextHandler, str)`.++`AttributesHandler` est une sous-classe de `collections.abc.Mapping`. Elle est immuable, donc en lecture seule, et hĂ©rite de ses opĂ©rations. Vous pouvez accĂ©der aux donnĂ©es par la propriĂ©tĂ© `_data`, mais elle est aussi en lecture seule : son type est `types.MappingProxyType`, un peu plus rapide que `collections.abc.Mapping`.++Si vous dĂ©butez en Python, voyez `AttributesHandler` comme un `dict` que vous pouvez consulter, mais dont vous ne pouvez pas modifier les donnĂ©es. Les opĂ©rations et mĂ©thodes habituelles des dictionnaires fonctionnent, sauf celles qui changent les donnĂ©es.++Pour modifier les donnĂ©es de `AttributesHandler`, convertissez-les dâabord en dictionnaire, par exemple avec `dict`, puis modifiez cette copie.diff --git a/docs/locales/fr/donate.md b/docs/locales/fr/donate.mdnew file mode 100644index 0000000..341b951--- /dev/null+++ b/docs/locales/fr/donate.md@@ -0,0 +1,37 @@+---+title: "Soutenez Scrapling et sponsorisez son dĂ©veloppement"+description: "Soutenez Scrapling via GitHub Sponsors ou Buy Me a Coffee. Consultez les offres de publicitĂ© et leurs avantages."+---++# Soutien et publicitĂ© {#support-and-advertisement}++Je crĂ©e ces projets pendant mon temps libre et jây consacre des ressources et des efforts pour les offrir gratuitement Ă la communautĂ©. Votre soutien mâaide Ă couvrir mes dĂ©penses, Ă remplir mes responsabilitĂ©s, Ă amĂ©liorer les projets et Ă en crĂ©er dâautres. Il finance aussi mes rĂ©serves de cafĂ©.++Vous pouvez me soutenir via [GitHub Sponsors](https://github.com/sponsors/D4Vinci) ou [Buy Me a Coffee](https://buymeacoffee.com/d4vinci).++MerciâŻ! Continuez Ă apprendre et Ă explorer. â€ïž++## PublicitĂ© {#advertisement}+Si vous souhaitez **faire connaĂźtre** votre entreprise Ă notre communautĂ©, consultez les [offres disponibles](https://github.com/sponsors/D4Vinci) :++### 1. [Offre Silver](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=435495) (100 $/mois) {#1-the-silver-tier-100month}+Avantages :++1. Votre logo apparaĂźtra [en haut de la page Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).+2. Le mĂȘme logo apparaĂźtra [en haut de la page PyPI](https://pypi.org/project/scrapling/) et sur [la page de lâimage Docker](https://hub.docker.com/r/pyd4vinci/scrapling), comme sur la page du projet.++### 2. [Offre Gold](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=591422) (200 $/mois) {#2-the-gold-tier-200month}+Avantages :++1. Votre logo apparaĂźtra [en haut de la page Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).+2. Le mĂȘme logo apparaĂźtra [en haut de la page PyPI](https://pypi.org/project/scrapling/) et sur [la page de lâimage Docker](https://hub.docker.com/r/pyd4vinci/scrapling), comme sur la page du projet.+3. Votre logo apparaĂźtra parmi les sponsors principaux du [site Scrapling](https://scrapling.readthedocs.io/en/latest/fr/).++### 3. [Offre Platinum](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=586646) (300 $/mois) {#3-the-platinum-tier-300month}+Avantages :++1. Votre logo sera mis en avant [tout en haut de la page Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#platinum-sponsors), avec un paragraphe de 25 mots maximum.+2. Le mĂȘme logo apparaĂźtra sur [la page PyPI](https://pypi.org/project/scrapling/) et [la page Docker](https://hub.docker.com/r/pyd4vinci/scrapling), comme sur la page du projet.+3. Votre logo sera mis en avant parmi les sponsors principaux du [site Scrapling](https://scrapling.readthedocs.io/en/latest/fr/).+4. Vous recevrez le rĂŽle de partenaire sur notre serveur Discord et une annonce sur Twitter et Discord.+5. Vous serez citĂ© Ă la fin des notes de chaque version.\ No newline at end of filediff --git a/docs/locales/fr/fetching/choosing.md b/docs/locales/fr/fetching/choosing.mdnew file mode 100644index 0000000..a3156c6--- /dev/null+++ b/docs/locales/fr/fetching/choosing.md@@ -0,0 +1,95 @@+---+title: "Choisissez des requĂȘtes HTTP ou un navigateur pour le web scraping"+description: "Choisissez Fetcher ou StealthyFetcher selon votre tĂąche. DĂ©couvrez quand utiliser HTTP directement, exĂ©cuter JavaScript et rĂ©utiliser des sessions."+---++# Les bases des fetchers {#fetchers-basics}++## Introduction {#introduction}+Les fetchers sont des classes qui envoient des requĂȘtes ou rĂ©cupĂšrent des pages en une ligne de code, puis renvoient un objet [Response](#response-object). Depuis la v0.3, des classes de session distinctes permettent de garder la session ouverte. Par exemple, une session de navigateur garde le navigateur ouvert jusquâĂ la fin de toutes vos requĂȘtes, au lieu dâen ouvrir plusieurs. Choisissez selon vos besoins.++Ces fonctions ont Ă©tĂ© ajoutĂ©es parce quâavant la v0.2, Scrapling servait uniquement Ă analyser des pages. Lâobjectif est de couvrir peu Ă peu tous les besoins du web scraping.++> Les fetchers ne sont pas de simples enveloppes autour dâautres bibliothĂšques. Ils les utilisent comme moteurs pour envoyer des requĂȘtes et rĂ©cupĂ©rer des pages, mais ajoutent des fonctions absentes de ces moteurs. Ils tirent aussi parti de leurs capacitĂ©s et les optimisent pour le web scraping.++## Comparaison des fetchers {#fetchers-overview}++Scrapling propose des fetchers HTTP (`Fetcher` et `AsyncFetcher`) et un fetcher de navigateur (`StealthyFetcher`), avec des classes de session pour les requĂȘtes rĂ©pĂ©tĂ©es.++Ce tableau vous aide Ă comparer et Ă choisir :+++| Fonction | Fetcher | StealthyFetcher |+|--------------------|---------------------------------------------------|--------------------------------------------------------------------------------------------|+| Vitesse relative | đđđđđ | đđđ |+| DiscrĂ©tion | ââ | âââââ |+| Options contre la dĂ©tection de bots | ââ | âââââ |+| ExĂ©cution de JavaScript | â | â |+| Utilisation de la mĂ©moire | â | âââ |+| Usage conseillĂ© | Extraction simple quand les requĂȘtes HTTP suffisent | - Sites chargĂ©s dynamiquement <br/>- Petites automatisations <br/>- Protections simples ou complexes |+| Navigateurs | â | Chromium et Google Chrome |+| API de navigateur utilisĂ©e | â | Playwright |+| DifficultĂ© de configuration | Simple | Simple |++Nous dĂ©taillerons chaque outil dans les pages suivantes.++## Configurer le parser de tous les fetchers {#parser-configuration-in-all-fetchers}+Tous les fetchers sâimportent de la mĂȘme façon :+```python+from scrapling.fetchers import Fetcher, AsyncFetcher, StealthyFetcher+```+Vous pouvez ensuite les utiliser directement, sans crĂ©er dâobjet. Les rĂ©glages par dĂ©faut du parser sont appliquĂ©s :+```python+page = StealthyFetcher.fetch('https://example.com')+```+Pour configurer le parser, câest-Ă -dire la [classe Selector](../parsing/main_classes.md#selector), qui traite la rĂ©ponse avant de vous la renvoyer, faites dâabord ceci :+```python+from scrapling.fetchers import Fetcher+Fetcher.configure(adaptive=True, keep_comments=False) # and the rest+```+Ou :+```python+from scrapling.fetchers import Fetcher+Fetcher.adaptive=True+Fetcher.keep_comments=False+```+Continuez ensuite votre code normalement.++Les arguments disponibles sont `adaptive`, `adaptive_domain`, `huge_tree`, `keep_comments`, `storage` et `storage_args`. Ce sont les mĂȘmes que ceux de [Selector](../parsing/main_classes.md#selector). Vous pouvez afficher la configuration actuelle avec `<fetcher_class>.display_config()`.++!!! info "Information"++ `adaptive` est dĂ©sactivĂ© par dĂ©faut. Vous devez lâactiver pour utiliser cette fonction.++### Configurer le parser pour chaque requĂȘte {#set-parser-config-per-request}+Les rĂ©glages prĂ©cĂ©dents sâappliquent Ă toutes les requĂȘtes envoyĂ©es par cette classe pour simplifier lâutilisation.++Si vous avez besoin de rĂ©glages diffĂ©rents pour chaque requĂȘte, passez un dictionnaire Ă lâargument `selector_config` de la mĂ©thode utilisĂ©e (`fetch`/`get`/`post`/...).++## Objet Response {#response-object}+`Response` fonctionne comme [Selector](../parsing/main_classes.md#selector), mais ajoute des informations sur la rĂ©ponse, comme les en-tĂȘtes, le statut et les cookies :+```python+from scrapling.fetchers import Fetcher+page = Fetcher.get('https://example.com')++page.status # HTTP status code+page.reason # Status message+page.cookies # Response cookies as a dictionary+page.headers # Response headers+page.request_headers # Request headers+page.history # Response history of redirections, if any+page.body # Raw response body as bytes+page.encoding # Response encoding+page.meta # Response metadata dictionary (e.g., proxy used). Mainly helpful with the spiders system.+```+Tous les fetchers renvoient `Response`. Les sessions de navigateur avec `record_requests=True` renvoient aussi des objets `Response` enregistrĂ©s via `session.network.search(limit=None)` et `session.network.get(request_id)`. Consultez lâ[historique rĂ©seau](stealthy.md#network-history) pour utiliser les rĂ©ponses dâAPI enregistrĂ©es et migrer vers la v5.++`Response` peut aussi convertir la page en Markdown propre, prĂȘt pour les modĂšles de langage, en une ligne :+```python+markdown = Fetcher.get('https://example.com').markdown(main_content_only=True)+```+Avant la conversion, les scripts, les styles, le contenu cachĂ© et les tentatives dâinjection dâinstructions sont toujours supprimĂ©s. Vous pouvez passer `css_selector` pour ne convertir que certains Ă©lĂ©ments. Cela nĂ©cessite lâextra `rag`, Ă©galement inclus dans `ai`/`shell`/`all`. La page [CrĂ©er des systĂšmes RAG](../ai/building-rag-systems.md) donne plus de dĂ©tails.++!!! note "Note"++ Contrairement Ă [Selector](../parsing/main_classes.md#selector), le corps de `Response` est toujours en octets depuis la v0.4.diff --git a/docs/locales/fr/fetching/static.md b/docs/locales/fr/fetching/static.mdnew file mode 100644index 0000000..e5301a8--- /dev/null+++ b/docs/locales/fr/fetching/static.md@@ -0,0 +1,449 @@+---+title: "Web scraping HTTP en Python avec Fetcher et FetcherSession"+description: "Envoyez des requĂȘtes HTTP synchrones ou asynchrones avec imitation de navigateur, cookies, proxies et sessions rĂ©utilisables. Extrayez les donnĂ©es des rĂ©ponses avec Scrapling."+---++# RequĂȘtes HTTP {#http-requests}++`Fetcher` envoie des requĂȘtes HTTP rapides et lĂ©gĂšres grĂące Ă `curl_cffi`, une bibliothĂšque performante qui propose de nombreuses options pour Ă©viter la dĂ©tection.++!!! success "Avant de commencer"++ 1. Lisez [Les bases des fetchers](../fetching/choosing.md) pour comprendre lâ[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.+ 2. Lisez [Rechercher des Ă©lĂ©ments](../parsing/selection.md) pour savoir comment trouver et extraire des Ă©lĂ©ments de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).+ 3. Lisez [Classes principales](../parsing/main_classes.md) pour connaĂźtre les propriĂ©tĂ©s et mĂ©thodes de [Selector](../parsing/main_classes.md#selector) dont hĂ©rite [Response](../fetching/choosing.md#response-object).++## Utilisation de base {#basic-usage}+La principale façon dâimporter ce fetcher est la mĂȘme que pour les autres :++```python+from scrapling.fetchers import Fetcher+```+Consultez la configuration du parser [ici](choosing.md#parser-configuration-in-all-fetchers).++### Arguments communs {#shared-arguments}+Toutes les mĂ©thodes de requĂȘte partagent ces arguments :++- **url** : URL cible.+- **stealthy_headers** : gĂ©nĂšre et ajoute des en-tĂȘtes de navigateur rĂ©el, dont un referer Google. ActivĂ© par dĂ©faut.+- **follow_redirects** : contrĂŽle les redirections. **La valeur par dĂ©faut est `"safe"`** : suit les redirections, mais refuse celles vers des IP internes ou privĂ©es pour protĂ©ger contre le SSRF. Utilisez `True` pour les suivre sans restriction, ou `False` pour les dĂ©sactiver.+- **timeout** : dĂ©lai maximal en secondes pour terminer chaque requĂȘte. **30 secondes par dĂ©faut**.+- **retries** : nombre maximal de tentatives lorsquâune requĂȘte Ă©choue, premiĂšre tentative comprise. **3 par dĂ©faut**.+- **retry_delay** : secondes dâattente entre les tentatives. **1 seconde par dĂ©faut**.+- **impersonate** : imite lâempreinte TLS dâun navigateur. Accepte une chaĂźne ou une liste, comme `"chrome110"`, `"firefox102"` ou `"safari15_5"` pour des versions prĂ©cises. Utilisez `"chrome"`, `"firefox"`, `"safari"` ou `"edge"` pour la derniĂšre version disponible. Les requĂȘtes semblent ainsi venir dâun vrai navigateur au niveau TLS. Avec une liste, une option est choisie au hasard pour chaque requĂȘte. **Par dĂ©faut, utilise la derniĂšre version de Chrome disponible.**+- **http3** : utilise HTTP/3. **False par dĂ©faut**. Peut poser problĂšme avec `impersonate`.+- **cookies** : cookies de la requĂȘte. Accepte un dictionnaire `nameâvalue` ou une liste de dictionnaires.+- **proxy** : proxy utilisĂ© pour acheminer tout le trafic HTTP et HTTPS de cette requĂȘte. Le format est `http://username:password@localhost:8030`.+- **proxy_auth** : authentification HTTP Basic du proxy, sous forme de tuple (nom dâutilisateur, mot de passe).+- **proxies** : dictionnaire de proxies au format `{"http": proxy_url, "https": proxy_url}`.+- **proxy_rotator** : objet `ProxyRotator` pour changer automatiquement de proxy. Ne peut pas ĂȘtre combinĂ© avec `proxy` ou `proxies`.+- **headers** : en-tĂȘtes de la requĂȘte. Ils peuvent remplacer ceux gĂ©nĂ©rĂ©s par `stealthy_headers`.+- **max_redirects** : nombre maximal de redirections. **30 par dĂ©faut**. Utilisez -1 pour ne pas limiter.+- **verify** : indique si les certificats HTTPS doivent ĂȘtre vĂ©rifiĂ©s. **True par dĂ©faut**.+- **cert** : tuple des noms de fichiers (certificat, clĂ©) pour le certificat client.+- **selector_config** : dictionnaire de rĂ©glages du parser pour crĂ©er lâobjet `Selector`/`Response` final.++!!! note "Notes"++ 1. Les navigateurs disponibles pour lâimitation sont (`"edge"`, `"chrome"`, `"chrome_android"`, `"safari"`, `"safari_beta"`, `"safari_ios"`, `"safari_ios_beta"`, `"firefox"`, `"tor"`).<br/>+ 2. Les navigateurs et leurs versions apparaissent dans lâautocomplĂ©tion de lâargument et sont actualisĂ©s Ă chaque mise Ă jour de `curl_cffi`.<br/>+ 3. Si `impersonate` ou `stealthy_headers` est activĂ©, les fetchers gĂ©nĂšrent des en-tĂȘtes rĂ©els correspondant Ă la version du navigateur utilisĂ©e.++Pour dâautres rĂ©glages, vous pouvez passer Ă chaque mĂ©thode les arguments acceptĂ©s par `curl_cffi` quâelle ne gĂšre pas dĂ©jĂ .++### Encodage du texte {#text-encoding}++Si une page qui nâutilise pas UTF-8 affiche des caractĂšres incorrects, passez `default_encoding="shift_jis"`, ou lâencodage rĂ©el de la page, avec la requĂȘte. Il sera utilisĂ© si lâen-tĂȘte `Content-Type` ne prĂ©cise pas dâencodage. Il ne remplace pas lâencodage fourni par le serveur.++Si le serveur indique un mauvais encodage, vous pouvez imposer le bon avec `selector_config={"encoding": "shift_jis"}`.++### MĂ©thodes HTTP {#http-methods}+Chaque mĂ©thode a ses propres arguments, comme `params` pour GET et `data`/`json` pour POST, PUT et DELETE.++Voici quelques exemples :++> Les mĂ©thodes `OPTIONS` et `HEAD` ne sont pas disponibles.+#### GET {#get}+```python+from scrapling.fetchers import Fetcher+# Basic GET+page = Fetcher.get('https://example.com')+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)+page = Fetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')+# With parameters+page = Fetcher.get('https://example.com/search', params={'q': 'query'})++# With headers+page = Fetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})+# Basic HTTP authentication+page = Fetcher.get("https://example.com", auth=("my_user", "password123"))+# Browser impersonation+page = Fetcher.get('https://example.com', impersonate='chrome')+# HTTP/3 support+page = Fetcher.get('https://example.com', http3=True)+```+Pour les requĂȘtes asynchrones, un petit ajustement suffit :+```python+from scrapling.fetchers import AsyncFetcher+# Basic GET+page = await AsyncFetcher.get('https://example.com')+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')+# With parameters+page = await AsyncFetcher.get('https://example.com/search', params={'q': 'query'})+# With headers+page = await AsyncFetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})+# Basic HTTP authentication+page = await AsyncFetcher.get("https://example.com", auth=("my_user", "password123"))+# Browser impersonation+page = await AsyncFetcher.get('https://example.com', impersonate='chrome110')+# HTTP/3 support+page = await AsyncFetcher.get('https://example.com', http3=True)+```+Dans tous les cas, `page` est un [Response](choosing.md#response-object), qui est aussi un [Selector](../parsing/main_classes.md#selector). Vous pouvez lâutiliser directement :+```python+page.css('.something.something')++page = Fetcher.get('https://api.github.com/events')+>>> page.json()+[{'id': '<redacted>',+ 'type': 'PushEvent',+ 'actor': {'id': '<redacted>',+ 'login': '<redacted>',+ 'display_login': '<redacted>',+ 'gravatar_id': '',+ 'url': 'https://api.github.com/users/<redacted>',+ 'avatar_url': 'https://avatars.githubusercontent.com/u/<redacted>'},+ 'repo': {'id': '<redacted>',+...+```+#### POST {#post}+```python+from scrapling.fetchers import Fetcher+# Basic POST+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, params={'q': 'query'})+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")+# Another example of form-encoded data+page = Fetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)+# JSON data+page = Fetcher.post('https://example.com/api', json={'key': 'value'})+```+Pour les requĂȘtes asynchrones, un petit ajustement suffit :+```python+from scrapling.fetchers import AsyncFetcher+# Basic POST+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")+# Another example of form-encoded data+page = await AsyncFetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)+# JSON data+page = await AsyncFetcher.post('https://example.com/api', json={'key': 'value'})+```+#### PUT {#put}+```python+from scrapling.fetchers import Fetcher+# Basic PUT+page = Fetcher.put('https://example.com/update', data={'status': 'updated'})+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')+# Another example of form-encoded data+page = Fetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})+```+Pour les requĂȘtes asynchrones, un petit ajustement suffit :+```python+from scrapling.fetchers import AsyncFetcher+# Basic PUT+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'})+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')+# Another example of form-encoded data+page = await AsyncFetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})+```++#### DELETE {#delete}+```python+from scrapling.fetchers import Fetcher+page = Fetcher.delete('https://example.com/resource/123')+page = Fetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")+page = Fetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')+```+Pour les requĂȘtes asynchrones, un petit ajustement suffit :+```python+from scrapling.fetchers import AsyncFetcher+page = await AsyncFetcher.delete('https://example.com/resource/123')+page = await AsyncFetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")+page = await AsyncFetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')+```++## Gestion des sessions {#session-management}++Utilisez `FetcherSession` pour envoyer plusieurs requĂȘtes avec la mĂȘme configuration. Elle fonctionne en code synchrone et asynchrone : elle dĂ©tecte le mode utilisĂ© et adapte la session sans nĂ©cessiter une autre importation.++`FetcherSession` accepte presque tous les arguments des mĂ©thodes de requĂȘte. Vous pouvez dĂ©finir des rĂ©glages pour toute la session, puis les modifier pour une requĂȘte prĂ©cise, comme dans les exemples suivants.++```python+from scrapling.fetchers import FetcherSession++# Create a session with default configuration+with FetcherSession(+ impersonate='chrome',+ http3=True,+ stealthy_headers=True,+ timeout=30,+ retries=3+) as session:+ # Make multiple requests with the same settings and the same cookies+ page1 = session.get('https://scrapling.requestcatcher.com/get')+ page2 = session.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})+ page3 = session.get('https://api.github.com/events')++ # All requests share the same session and connection pool+```++Vous pouvez aussi utiliser `ProxyRotator` avec `FetcherSession` pour changer automatiquement de proxy entre les requĂȘtes :++```python+from scrapling.fetchers import FetcherSession, ProxyRotator++rotator = ProxyRotator([+ 'http://proxy1:8080',+ 'http://proxy2:8080',+ 'http://proxy3:8080',+])++with FetcherSession(proxy_rotator=rotator, impersonate='chrome') as session:+ # Each request automatically uses the next proxy in rotation+ page1 = session.get('https://example.com/page1')+ page2 = session.get('https://example.com/page2')++ # You can check which proxy was used via the response metadata+ print(page1.meta['proxy'])+```++Pour une requĂȘte prĂ©cise, remplacez le proxy ou le rotateur de la session en passant `proxy=` Ă la mĂ©thode :++```python+with FetcherSession(proxy='http://default-proxy:8080') as session:+ # Uses the session proxy+ page1 = session.get('https://example.com/page1')++ # Override the proxy for this specific request+ page2 = session.get('https://example.com/page2', proxy='http://special-proxy:9090')+```++Un exemple asynchrone :++```python+async with FetcherSession(impersonate='firefox', http3=True) as session:+ # All standard HTTP methods available+ response = await session.get('https://example.com')+ response = await session.post('https://scrapling.requestcatcher.com/post', json={'data': 'value'})+ response = await session.put('https://scrapling.requestcatcher.com/put', data={'update': 'info'})+ response = await session.delete('https://scrapling.requestcatcher.com/delete')+```+Ou, mieux encore :+```python+import asyncio+from scrapling.fetchers import FetcherSession++# Async session usage+async with FetcherSession(impersonate="safari") as session:+ urls = ['https://example.com/page1', 'https://example.com/page2']++ tasks = [+ session.get(url) for url in urls+ ]++ pages = await asyncio.gather(*tasks)+```++`Fetcher` utilise `FetcherSession` pour crĂ©er une session temporaire Ă chaque requĂȘte.++### Avantages des sessions {#session-benefits}++- **Plus rapides** : 10 fois plus rapides que la crĂ©ation dâune session par requĂȘte.+- **Cookies persistants** : gestion automatique des cookies entre les requĂȘtes.+- **Moins de ressources** : meilleure utilisation de la mĂ©moire et du processeur pour plusieurs requĂȘtes.+- **Configuration centralisĂ©e** : un seul endroit pour gĂ©rer les rĂ©glages.++## Exemples {#examples}+Des exemples complets pour dĂ©buter en web scraping.++### RequĂȘte HTTP simple {#basic-http-request}++```python+from scrapling.fetchers import Fetcher++# Make a request+page = Fetcher.get('https://example.com')++# Check the status+if page.status == 200:+ # Extract title+ title = page.css('title::text').get()+ print(f"Page title: {title}")++ # Extract all links+ links = page.css('a::attr(href)').getall()+ print(f"Found {len(links)} links")+```++### Extraire des produits {#product-scraping}++```python+from scrapling.fetchers import Fetcher++def scrape_products():+ page = Fetcher.get('https://example.com/products')++ # Find all product elements+ products = page.css('.product')++ results = []+ for product in products:+ results.append({+ 'title': product.css('.title::text').get(),+ 'price': product.css('.price::text').re_first(r'\d+\.\d{2}'),+ 'description': product.css('.description::text').get(),+ 'in_stock': product.has_class('in-stock')+ })++ return results+```++### TĂ©lĂ©charger des fichiers {#downloading-files}++```python+from scrapling.fetchers import Fetcher++page = Fetcher.get('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')+with open(file='main_cover.png', mode='wb') as f:+ f.write(page.body)+```++### Parcourir les pages de rĂ©sultats {#pagination-handling}++```python+from scrapling.fetchers import Fetcher++def scrape_all_pages():+ base_url = 'https://example.com/products?page={}'+ page_num = 1+ all_products = []++ while True:+ # Get current page+ page = Fetcher.get(base_url.format(page_num))++ # Find products+ products = page.css('.product')+ if not products:+ break++ # Process products+ for product in products:+ all_products.append({+ 'name': product.css('.name::text').get(),+ 'price': product.css('.price::text').get()+ })++ # Next page+ page_num += 1++ return all_products+```++### Envoyer des formulaires {#form-submission}++```python+from scrapling.fetchers import Fetcher++# Submit login form+response = Fetcher.post(+ 'https://example.com/login',+ data={+ 'username': '[email protected]',+ 'password': 'password123'+ }+)++# Check login success+if response.status == 200:+ # Extract user info+ user_name = response.css('.user-name::text').get()+ print(f"Logged in as: {user_name}")+```++### Extraire des tableaux {#table-extraction}++```python+from scrapling.fetchers import Fetcher++def extract_table():+ page = Fetcher.get('https://example.com/data')++ # Find table+ table = page.css('table')[0]++ # Extract headers+ headers = [+ th.text for th in table.css('thead th')+ ]++ # Extract rows+ rows = []+ for row in table.css('tbody tr'):+ cells = [td.text for td in row.css('td')]+ rows.append(dict(zip(headers, cells)))++ return rows+```++### Menu de navigation {#navigation-menu}++```python+from scrapling.fetchers import Fetcher++def extract_menu():+ page = Fetcher.get('https://example.com')++ # Find navigation+ nav = page.css('nav')[0]++ menu = {}+ for item in nav.css('li'):+ links = item.css('a')+ if links:+ link = links[0]+ menu[link.text] = {+ 'url': link['href'],+ 'has_submenu': bool(item.css('.submenu'))+ }++ return menu+```++## Quand utiliser chaque option {#when-to-use}++Utilisez `Fetcher` si vous :++- Avez besoin de requĂȘtes HTTP rapides.+- Voulez limiter lâutilisation des ressources.+- Nâavez pas besoin dâexĂ©cuter JavaScript, car les donnĂ©es sont accessibles par requĂȘtes HTTP.+- Avez besoin dâĂ©viter certaines dĂ©tections, par exemple si le site est protĂ©gĂ© mais nâutilise pas de dĂ©fis JavaScript.++Utilisez `FetcherSession` si vous :++- Envoyez plusieurs requĂȘtes au mĂȘme site ou Ă des sites diffĂ©rents.+- Devez conserver des cookies ou une authentification entre les requĂȘtes.+- Voulez rĂ©utiliser les connexions pour amĂ©liorer les performances.+- Devez garder les mĂȘmes rĂ©glages entre les requĂȘtes.+- Travaillez avec des API qui nĂ©cessitent un Ă©tat de session.++Utilisez dâautres fetchers si vous :++- Devez automatiser un navigateur.+- Avez besoin dâoptions avancĂ©es pour Ă©viter la dĂ©tection de bots.+- Devez exĂ©cuter JavaScript ou interagir avec du contenu dynamique.diff --git a/docs/locales/fr/fetching/stealthy.md b/docs/locales/fr/fetching/stealthy.mdnew file mode 100644index 0000000..84a718f--- /dev/null+++ b/docs/locales/fr/fetching/stealthy.md@@ -0,0 +1,536 @@+---+title: "Extrayez les donnĂ©es de sites JavaScript avec StealthyFetcher"+description: "Chargez des pages, attendez les donnĂ©es, rĂ©utilisez lâĂ©tat de connexion et lisez les rĂ©ponses dâAPI en arriĂšre-plan avec les sessions de navigateur Scrapling. Configurez les proxies et la rĂ©solution des dĂ©fis."+---++# RĂ©cupĂ©rer des pages avec StealthyFetcher {#browser-fetching-with-stealthyfetcher}++`StealthyFetcher` charge les pages JavaScript et automatise Chromium ou Google Chrome avec des fonctions contre la dĂ©tection de bots. Il utilise lâ[API de Playwright](https://playwright.dev/python/docs/intro) avec des correctifs pour masquer lâautomatisation.++Pour automatiser une page, vous aurez besoin de connaĂźtre un peu lâ[API Page de Playwright](https://playwright.dev/python/docs/api/class-page), comme nous le verrons plus loin.++!!! success "Avant de commencer"++ 1. Lisez [Les bases des fetchers](../fetching/choosing.md) pour comprendre lâ[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.+ 2. Lisez [Rechercher des Ă©lĂ©ments](../parsing/selection.md) pour savoir comment trouver et extraire des Ă©lĂ©ments de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).+ 3. Lisez [Classes principales](../parsing/main_classes.md) pour connaĂźtre les propriĂ©tĂ©s et mĂ©thodes de [Selector](../parsing/main_classes.md#selector) dont hĂ©rite [Response](../fetching/choosing.md#response-object).++## Utilisation de base {#basic-usage}+La principale façon dâimporter ce fetcher est la mĂȘme que pour les autres :++```python+from scrapling.fetchers import StealthyFetcher+```+Consultez la configuration du parser [ici](choosing.md#parser-configuration-in-all-fetchers).++Nous allons prĂ©senter les principaux arguments avec des exemples. Pour consulter directement le tableau complet, [allez Ă cette section](#full-list-of-arguments).++!!! abstract "Note"++ La version asynchrone de `fetch` se nomme `async_fetch`.+++Ce fetcher propose trois grandes options dâexĂ©cution, que vous pouvez combiner selon vos besoins.++Les voici :++### 1. Chromium inclus {#1-bundled-chromium}+```python+StealthyFetcher.fetch('https://example.com')+```+Ouvre le navigateur Chromium inclus, applique les rĂ©glages de discrĂ©tion par dĂ©faut et charge la page.++### 2. Google Chrome installĂ© {#2-real-chrome}+```python+StealthyFetcher.fetch('https://example.com', real_chrome=True)+```+Utilisez cette option si Google Chrome est installĂ©. Elle fonctionne comme la prĂ©cĂ©dente, mais ouvre votre copie de Google Chrome Ă la place de Chromium. Cela rend vos requĂȘtes plus rĂ©alistes et moins faciles Ă dĂ©tecter.++Si vous nâavez pas Google Chrome, vous pouvez lâinstaller pour la bibliothĂšque avec cette commande dans le terminal :+```commandline+playwright install chrome+```++### 3. Connexion CDP {#3-cdp-connection}+```python+StealthyFetcher.fetch('https://example.com', cdp_url='ws://localhost:9222')+```+Au lieu de lancer un navigateur local, vous pouvez vous connecter Ă un navigateur distant via le [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/).++LâURL peut ĂȘtre une adresse WebSocket (`ws://`/`wss://`), comme celles fournies par les services de navigateurs, ou lâadresse HTTP dâun navigateur, par exemple `http://localhost:9222`.+++## Que fait-il ? {#what-does-it-do}++StealthyFetcher propose ces fonctions contre la dĂ©tection de bots :++1. RĂ©sout automatiquement tous les types de Cloudflare Turnstile et Interstitial avec `solve_cloudflare=True`.+2. Ăvite les fuites liĂ©es Ă lâenvironnement dâexĂ©cution CDP et Ă WebRTC.+3. Isole lâexĂ©cution de JavaScript, supprime de nombreuses traces de Playwright et Ă©vite la dĂ©tection de certains comportements typiques des bots.+4. Ajoute du bruit au canvas pour empĂȘcher son utilisation comme empreinte.+5. Corrige des mĂ©thodes connues de dĂ©tection du mode sans interface et propose une option contre la dĂ©tection par diffĂ©rence de fuseau horaire.+6. Inclut dâautres options pour contourner les protections.++## Liste complĂšte des arguments {#full-list-of-arguments}+Ce fetcher et ses classes de session proposent de nombreuses options. Avant les [exemples](#examples), voici la liste complĂšte :+++| Argument | Description | Facultatif |+|:---------------------:|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|+| url | URL cible. | â |+| headless | Utilisez `True` pour exĂ©cuter le navigateur sans interface visible (**par dĂ©faut**), ou `False` pour lâafficher. | âïž |+| disable_resources | Ignore les ressources inutiles pour accĂ©lĂ©rer le chargement. Bloque les types `font`, `image`, `media`, `beacon`, `object`, `imageset`, `texttrack`, `websocket`, `csp_report` et `stylesheet`. | âïž |+| cookies | Cookies de la prochaine requĂȘte. | âïž |+| useragent | ChaĂźne de user agent Ă utiliser. **Sans valeur personnalisĂ©e, le fetcher en gĂ©nĂšre une rĂ©elle pour le mĂȘme navigateur et la mĂȘme version.** | âïž |+| network_idle | Attend que la page passe au moins 500 ms sans connexion rĂ©seau. | âïž |+| load_dom | Attend lâĂ©tat `domcontentloaded` pour le chargement et lâexĂ©cution de JavaScript. ActivĂ© par dĂ©faut. | âïž |+| pierce_shadow | Inclut le contenu du Shadow DOM ouvert dans le HTML de la rĂ©ponse. Vaut `False` par dĂ©faut. Peut ĂȘtre dĂ©fini pour la session ou modifiĂ© par requĂȘte. | âïž |+| timeout | DĂ©lai maximal en millisecondes pour les opĂ©rations et les attentes de la page. Par dĂ©faut : 30 000 ms, soit 30 secondes. | âïž |+| wait | Millisecondes dâattente aprĂšs toutes les opĂ©rations, avant de fermer la page et de renvoyer `Response`. | âïž |+| page_action | Fonction dâautomatisation qui reçoit `page` et sâexĂ©cute aprĂšs la navigation. | âïž |+| page_setup | Fonction qui reçoit `page` et sâexĂ©cute avant la navigation. Sert Ă enregistrer des Ă©vĂ©nements ou des routes avant le chargement. | âïž |+| wait_selector | Attend quâun sĂ©lecteur CSS atteigne un Ă©tat prĂ©cis. | âïž |+| init_script | Chemin absolu dâun fichier JavaScript exĂ©cutĂ© Ă la crĂ©ation de chaque page de la session. | âïž |+| wait_selector_state | Ătat que doit atteindre le sĂ©lecteur fourni Ă `wait_selector`. _Par dĂ©faut : `attached`._ | âïž |+| google_search | DĂ©finit un referer Google. ActivĂ© par dĂ©faut. | âïž |+| extra_headers | Dictionnaire dâen-tĂȘtes supplĂ©mentaires. _Le referer dĂ©fini par `google_search` a prioritĂ© sur celui indiquĂ© ici._ | âïž |+| proxy | Proxy des requĂȘtes. Accepte une chaĂźne ou un dictionnaire avec les clĂ©s 'server', 'username' et 'password'. | âïž |+| real_chrome | Activez cette option pour ouvrir et utiliser le Google Chrome installĂ© sur votre appareil. | âïž |+| locale | ParamĂštres rĂ©gionaux, comme `en-GB` ou `de-DE`. Affectent `navigator.language`, lâen-tĂȘte `Accept-Language` et les formats des nombres et des dates. Utilisent les valeurs du systĂšme par dĂ©faut. | âïž |+| timezone_id | Fuseau horaire du navigateur. Celui du systĂšme par dĂ©faut. | âïž |+| cdp_url | URL CDP Ă laquelle se connecter pour contrĂŽler un navigateur existant au lieu dâen ouvrir un. | âïž |+| user_data_dir | Dossier de donnĂ©es du navigateur, comme les cookies et le stockage local. Un dossier temporaire est créé par dĂ©faut. **Fonctionne uniquement avec les sessions.** | âïž |+| extra_flags | Liste dâoptions supplĂ©mentaires passĂ©es au lancement du navigateur. | âïž |+| solve_cloudflare | RĂ©sout les diffĂ©rents types de dĂ©fis Turnstile et Interstitial de Cloudflare avant de renvoyer la rĂ©ponse. Vaut `False` par dĂ©faut. | âïž |+| block_webrtc | Force WebRTC Ă respecter les rĂ©glages du proxy pour Ă©viter de rĂ©vĂ©ler lâIP locale. | âïž |+| hide_canvas | Ajoute du bruit alĂ©atoire au canvas pour empĂȘcher son utilisation comme empreinte. | âïž |+| allow_webgl | ActivĂ© par dĂ©faut. Le dĂ©sactiver supprime toute prise en charge de WebGL et WebGL 2.0. Ce nâest pas conseillé : de nombreux WAF vĂ©rifient si WebGL est disponible. | âïž |+| additional_args | RĂ©glages supplĂ©mentaires pour le contexte Playwright. Ils ont prioritĂ© sur ceux de Scrapling. | âïž |+| selector_config | Dictionnaire de rĂ©glages du parser pour crĂ©er lâobjet `Selector`/`Response` final. | âïž |+| blocked_domains | Ensemble de domaines Ă bloquer, y compris leurs sous-domaines. Par exemple, `"example.com"` bloque aussi `"sub.example.com"`. | âïž |+| block_ads | Bloque les requĂȘtes vers environ 3 500 domaines connus de publicitĂ© et de suivi. Peut ĂȘtre combinĂ© avec `blocked_domains`. | âïž |+| dns_over_https | Envoie les requĂȘtes DNS via le DNS-over-HTTPS de Cloudflare pour Ă©viter les fuites lors de lâutilisation de proxies. | âïž |+| proxy_rotator | Objet `ProxyRotator` pour changer automatiquement de proxy. Ne peut pas ĂȘtre combinĂ© avec `proxy`. | âïž |+| retries | Nombre de tentatives pour les requĂȘtes Ă©chouĂ©es. 3 par dĂ©faut. | âïž |+| retry_delay | Secondes dâattente entre les tentatives. 1 par dĂ©faut. | âïž |+| record_requests | Conserve les requĂȘtes terminĂ©es et les rĂ©ponses enregistrĂ©es dans `session.network`. RĂ©servĂ© aux sessions. Vaut `False` par dĂ©faut. | âïž |+| max_recorded_requests | Nombre maximal de requĂȘtes conservĂ©es par session. 1 000 par dĂ©faut. Le contenu enregistrĂ© a aussi des limites de taille fixes. | âïž |+| executable_path | Chemin absolu dâun exĂ©cutable de navigateur personnalisĂ© Ă utiliser Ă la place du Chromium inclus. Utile pour les installations ou versions particuliĂšres. | âïž |++Dans les classes de session, vous pouvez dĂ©finir ces arguments pour toute la session. Vous pouvez aussi modifier par requĂȘte les rĂ©glages propres Ă lâonglet : `google_search`, `timeout`, `wait`, `page_action`, `page_setup`, `extra_headers`, `disable_resources`, `wait_selector`, `wait_selector_state`, `network_idle`, `load_dom`, `pierce_shadow`, `solve_cloudflare`, `blocked_domains`, `proxy` et `selector_config`.++!!! note "Notes"++ 1. Dans mes tests, `disable_resources` a accĂ©lĂ©rĂ© les requĂȘtes dâenviron 25 % sur certains sites. Il peut aussi rĂ©duire le trafic du proxy. Utilisez-le avec prudence : certains sites pourraient ne jamais finir de charger.+ 2. `google_search` est activĂ© par dĂ©faut et dĂ©finit le referer sur `https://www.google.com/`. Si vous utilisez aussi `extra_headers`, il a prioritĂ© sur le referer indiquĂ© dans ce dictionnaire.+ 3. Si vous ne dĂ©finissez pas de user agent et utilisez le mode sans interface, un user agent rĂ©el est gĂ©nĂ©rĂ© pour la mĂȘme version du navigateur. Sans user agent personnalisĂ© et avec un navigateur visible, celui du navigateur est utilisĂ©, comme dans les versions actuelles des navigateurs ordinaires.+ 4. `init_script` est enregistrĂ© dans le contexte du navigateur et exĂ©cutĂ© Ă la crĂ©ation des pages. Le mode discret utilise par dĂ©faut lâenvironnement isolĂ© de Patchright. Si `page_action` doit lire des variables que le script place dans `window`, appelez `page.evaluate(..., isolated_context=False)` dans lâaction.++## Gestion des sessions {#session-management}++Pour garder le navigateur ouvert et envoyer plusieurs requĂȘtes avec les mĂȘmes rĂ©glages, utilisez `StealthySession`/`AsyncStealthySession`. Ces classes acceptent tous les arguments de `fetch` pour configurer toute la session.++```python+from scrapling.fetchers import StealthySession+++with StealthySession(+ headless=True,+ disable_resources=True,+ real_chrome=True+) as session:++ page1 = session.fetch('https://example1.com')+ page2 = session.fetch('https://example2.com')+ page3 = session.fetch('https://dynamic-site.com')+++```++### Utiliser les sessions asynchrones {#async-session-usage}++```python+import asyncio+from scrapling.fetchers import AsyncStealthySession++async def scrape_multiple_sites():+ async with AsyncStealthySession(+ network_idle=True,+ timeout=30000,+ max_pages=3+ ) as session:++ pages = await asyncio.gather(+ session.fetch('https://spa-app1.com'),+ session.fetch('https://spa-app2.com'),+ session.fetch('https://dynamic-content.com')+ )+ return pages+```++Lâargument `max_pages` dĂ©finit le nombre maximal dâonglets ouverts en mĂȘme temps. La session garde un **ensemble dâonglets rĂ©utilisables**. Chaque onglet reste ouvert Ă la fin de sa requĂȘte. Pour chaque nouvelle requĂȘte, la bibliothĂšque procĂšde ainsi :++1. RĂ©utilise un onglet libre sâil y en a un. Elle applique les rĂ©glages de la requĂȘte (`timeout`, `extra_headers`, `disable_resources`, `blocked_domains`, etc.) pour ne pas conserver ceux de la prĂ©cĂ©dente.+2. Sâil nây a pas dâonglet libre, elle en ouvre un autre tant que `max_pages` nâest pas atteint.+3. Si la limite est atteinte, elle vĂ©rifie plusieurs fois par seconde si un onglet se libĂšre, pendant 60 secondes. Elle lĂšve ensuite `TimeoutError`. Cela peut arriver si le site ne rĂ©pond plus.++Les onglets qui rencontrent une erreur sont fermĂ©s et remplacĂ©s. Vous pouvez aussi tous les fermer avec `session.close_pages()`. La prochaine requĂȘte en ouvrira un nouveau.++Cela permet de rĂ©cupĂ©rer plusieurs URL en mĂȘme temps dans le mĂȘme navigateur, en Ă©conomisant des ressources et en gagnant beaucoup de temps :)++Comme lâonglet reste ouvert, la page prĂ©cĂ©dente sây trouve toujours. Le `page_setup` de la prochaine requĂȘte sâexĂ©cute avant de la quitter. Cela permet dâenchaĂźner des actions entre les requĂȘtes.++Les versions 0.3.2 Ă 0.4.14 fermaient chaque onglet Ă la fin de la requĂȘte, car leur rĂ©utilisation laissait passer des rĂ©glages dâune requĂȘte Ă lâautre. Depuis la 0.4.15, les rĂ©glages sont rĂ©initialisĂ©s Ă chaque rĂ©utilisation et les onglets restent ouverts.++### Enregistrer et charger lâĂ©tat de session {#save-and-load-session-state}++Utilisez `save_state(path)` pour enregistrer les cookies, le stockage local et IndexedDB dans un fichier JSON. Utilisez `load_state(path)` pour le restaurer dans une autre session ou remplacer lâĂ©tat de la session actuelle. Les deux mĂ©thodes acceptent une chaĂźne ou un `pathlib.Path` et renvoient `None`. Le format est compatible avec les fichiers dâĂ©tat de Playwright.++```python+from scrapling.fetchers import StealthySession++with StealthySession() as session:+ session.fetch('https://example.com')+ session.save_state('state.json')++with StealthySession() as session:+ session.load_state('state.json')+ page = session.fetch('https://example.com')+```++Enregistrez lâĂ©tat aprĂšs la connexion au site ou aprĂšs vos actions dans le navigateur. Appelez les deux mĂ©thodes dans une session dĂ©marrĂ©e, une fois les requĂȘtes en cours terminĂ©es. Le chargement remplace les cookies, le stockage local et IndexedDB existants. RĂ©cupĂ©rez ou rechargez la page pour utiliser la connexion restaurĂ©e : charger lâĂ©tat ne change pas les pages dĂ©jĂ ouvertes.++Avec `AsyncStealthySession`, utilisez `await` :++```python+from scrapling.fetchers import AsyncStealthySession++async def restore_session():+ async with AsyncStealthySession() as session:+ await session.load_state('state.json')+ page = await session.fetch('https://example.com')+ await session.save_state('state.json')+ return page+```++Ces mĂ©thodes enregistrent et restaurent seulement le contexte partagĂ© du navigateur. Elles ne touchent pas les contextes temporaires de proxy par requĂȘte. Les sessions avec `proxy_rotator` nâont pas de contexte partagé : ces mĂ©thodes lĂšvent donc `RuntimeError`. Un `proxy` fixe pour la session fonctionne normalement.++Le fichier ne contient ni `sessionStorage`, ni les onglets ouverts, ni les rĂ©glages du navigateur. Lâenregistrement remplace le fichier existant et exige que son dossier parent existe. Les erreurs de fichier ou de JSON sont transmises au code appelant.++### Avantages des sessions {#session-benefits}++- **Navigateur rĂ©utilisĂ©** : les requĂȘtes suivantes sont bien plus rapides grĂące au mĂȘme navigateur.+- **Cookies persistants** : gestion automatique des cookies et de lâĂ©tat, comme dans tout navigateur.+- **Empreinte stable** : la mĂȘme empreinte de navigateur pour toutes les requĂȘtes.+- **Moins de mĂ©moire utilisĂ©e** : consomme moins de ressources que le lancement dâun navigateur pour chaque page.+++## Exemples {#examples}+Les exemples permettent de mieux comprendre. En voici quelques-uns.++### ContrĂŽle des ressources {#resource-control}++```python++page = StealthyFetcher.fetch('https://example.com', disable_resources=True)+```++### Shadow DOM {#shadow-dom}++Certaines pages placent du contenu dans des racines de Shadow DOM ouvertes. Ce contenu nâapparaĂźt pas dans le HTML normal de la page. Activez `pierce_shadow` pour lâinclure dans la rĂ©ponse, puis utilisez CSS ou XPath comme dâhabitude :++```python+from scrapling.fetchers import StealthyFetcher++page = StealthyFetcher.fetch('https://example.com', pierce_shadow=True)+titles = page.css('product-card .title::text').getall()+```++La valeur par dĂ©faut est `False`. Vous pouvez aussi lâactiver pour une session et la dĂ©sactiver pour une requĂȘte prĂ©cise :++```python+from scrapling.fetchers import StealthySession++with StealthySession(pierce_shadow=True) as session:+ page = session.fetch('https://example.com')+ plain_page = session.fetch('https://example.com', pierce_shadow=False)+```++La mĂȘme option fonctionne avec `async_fetch` et les sessions asynchrones.++Seules les racines ouvertes sont incluses. Les racines fermĂ©es et les documents dans les iframes ne sont pas parcourus. Utilisez `wait_selector` si un composant se charge aprĂšs la page.++Chaque racine ouverte devient un conteneur `<shadow-root>` dans la rĂ©ponse. Les slots gardent leurs balises et attributs, et contiennent les nĆuds qui leur sont attribuĂ©s, ou leur contenu de repli si aucun nĆud ne leur est attribuĂ©. Les enfants du DOM normal sans slot attribuĂ© sont omis. La page dans le navigateur ne change pas.++```html+<product-card>+ <shadow-root>+ <div class="title">Product name</div>+ <slot name="price"><span class="price">20</span></slot>+ </shadow-root>+</product-card>+```++Les sĂ©lecteurs de descendants traversent ces Ă©lĂ©ments. Les sĂ©lecteurs dâenfants directs doivent inclure les conteneurs et les slots :++```python+titles = page.css('product-card .title::text').getall()+titles = page.css('product-card > shadow-root > .title::text').getall()+prices = page.css('product-card > shadow-root > slot[name="price"] > .price::text').getall()+```++Les conteneurs et les slots apparaissent dans les chemins XPath, `.children`, `response.body` et les exports HTML. Lâextraction en Markdown ou en texte renvoie leur contenu sans afficher les balises. Les attributs qui masquent les slots restent disponibles pour nettoyer le contenu.++La copie conserve lâordre du contenu, mais ne calcule ni sa visibilitĂ© CSS ni sa disposition. Les sĂ©lecteurs contenant `<shadow-root>` sâappliquent Ă la rĂ©ponse de Scrapling, pas Ă la page dans le navigateur. Dâautres parsers HTML peuvent traiter diffĂ©remment les imbrications inhabituelles.++### Bloquer des domaines {#domain-blocking}++```python++page = StealthyFetcher.fetch('https://example.com', blocked_domains={"ads.example.com", "tracker.net"})+```++### ContrĂŽle du rĂ©seau {#network-control}++```python++page = StealthyFetcher.fetch('https://example.com', network_idle=True)+++page = StealthyFetcher.fetch('https://example.com', timeout=30000)+++page = StealthyFetcher.fetch('https://example.com', proxy='http://username:password@host:port')+```++### TĂ©lĂ©charger des fichiers {#downloading-files}++```python+page = StealthyFetcher.fetch('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')++with open(file='main_cover.png', mode='wb') as f:+ f.write(page.body)+```++Lâattribut `body` de `Response` renvoie toujours des `bytes`.++### Configuration avant la navigation {#pre-navigation-setup}+Pour enregistrer des Ă©vĂ©nements, des routes ou des scripts avant de charger la page, utilisez `page_setup`. Cette fonction reçoit `page` et sâexĂ©cute avant lâappel Ă `page.goto()`.++```python+from patchright.sync_api import Page++def capture_websockets(page: Page):+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))++page = StealthyFetcher.fetch('https://example.com', page_setup=capture_websockets)+```+Version asynchrone :+```python+from patchright.async_api import Page++async def capture_websockets(page: Page):+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))++page = await StealthyFetcher.async_fetch('https://example.com', page_setup=capture_websockets)+```++Vous pouvez combiner cette option avec `page_action` : `page_setup` sâexĂ©cute avant la navigation, et `page_action` aprĂšs.++### Cloudflare et options de discrĂ©tion {#cloudflare-and-stealth-options}++```python++page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True)+++page = StealthyFetcher.fetch(+ 'https://protected-site.com',+ solve_cloudflare=True,+ block_webrtc=True,+ real_chrome=True,+ hide_canvas=True,+ google_search=True,+ proxy='http://username:password@host:port', # It can also be a dictionary with only the keys 'server', 'username', and 'password'.+)+```++`solve_cloudflare` active la dĂ©tection et la rĂ©solution automatique de tous les types de dĂ©fis Turnstile et Interstitial de Cloudflare :++- DĂ©fis JavaScript gĂ©rĂ©s.+- DĂ©fis interactifs, comme cliquer sur une case de vĂ©rification.+- DĂ©fis invisibles, avec vĂ©rification automatique en arriĂšre-plan.++Il rĂ©sout aussi les pages personnalisĂ©es avec un CAPTCHA intĂ©grĂ©.++!!! notes "**Notes importantes**"++ 1. Sur les sites ayant une implĂ©mentation particuliĂšre, vous devrez peut-ĂȘtre utiliser `wait_selector` pour attendre le vrai contenu aprĂšs le CAPTCHA. Certains sites sont des cas trĂšs spĂ©cifiques, mĂȘme si nous cherchons Ă fournir une solution gĂ©nĂ©rale.+ 2. PrĂ©voyez un timeout dâau moins 60 secondes pour laisser le temps de rĂ©soudre les dĂ©fis Cloudflare.+ 3. Cette fonction marche avec les proxies et les autres options de discrĂ©tion.++### Automatisation du navigateur {#browser-automation}+Câest ici que votre connaissance de lâ[API Page de Playwright](https://playwright.dev/python/docs/api/class-page) intervient. La fonction fournie reçoit lâobjet page de Playwright, exĂ©cute les actions, puis laisse le fetcher continuer.++Elle sâexĂ©cute juste aprĂšs lâattente de `network_idle`, si activĂ©e, et avant celle de `wait_selector`. Vous pouvez lâutiliser pour automatiser des actions ou modifier la page.++Cet exemple utilise les [Ă©vĂ©nements de souris](https://playwright.dev/python/docs/api/class-mouse) pour faire dĂ©filer la page avec la molette, puis dĂ©placer la souris.+```python+from patchright.sync_api import Page++def scroll_page(page: Page):+ page.mouse.wheel(10, 0)+ page.mouse.move(100, 400)+ page.mouse.up()++page = StealthyFetcher.fetch('https://example.com', page_action=scroll_page)+```+Si vous utilisez la rĂ©cupĂ©ration asynchrone, la fonction doit aussi ĂȘtre asynchrone.+```python+from patchright.async_api import Page++async def scroll_page(page: Page):+ await page.mouse.wheel(10, 0)+ await page.mouse.move(100, 400)+ await page.mouse.up()++page = await StealthyFetcher.async_fetch('https://example.com', page_action=scroll_page)+```++### Conditions dâattente {#wait-conditions}++```python++page = StealthyFetcher.fetch(+ 'https://quotes.toscrape.com/js-delayed/',+ wait_selector='.quote',+ wait_selector_state='visible'+)+```+Si activĂ©e, cette condition est la derniĂšre attente avant de renvoyer la rĂ©ponse. Passez un sĂ©lecteur CSS Ă `wait_selector` et un Ă©tat Ă `wait_selector_state`. Par dĂ©faut, lâĂ©tat attendu est `attached`, qui signifie que lâĂ©lĂ©ment est prĂ©sent dans le DOM.++Ensuite, si `load_dom` est activĂ©, comme par dĂ©faut, le fetcher attend de nouveau lâĂ©tat `domcontentloaded` pour vĂ©rifier le chargement et lâexĂ©cution de JavaScript. Si vous avez activĂ© `network_idle`, il attend aussi de nouveau `network_idle`.++Voici les Ă©tats disponibles ([source](https://playwright.dev/python/docs/api/class-page#page-wait-for-selector)) :++- `attached` : attend que lâĂ©lĂ©ment soit prĂ©sent dans le DOM.+- `detached` : attend que lâĂ©lĂ©ment ne soit plus prĂ©sent dans le DOM.+- `visible` : attend que lâĂ©lĂ©ment ait une zone de taille non nulle et nâutilise pas `visibility:hidden`. Un Ă©lĂ©ment sans contenu ou avec `display:none` a une zone vide et nâest pas considĂ©rĂ© comme visible.+- `hidden` : attend que lâĂ©lĂ©ment soit retirĂ© du DOM, ait une zone vide ou utilise `visibility:hidden`. Câest lâinverse de `'visible'`.++### Historique rĂ©seau {#network-history}++Activez `record_requests` dans une session de navigateur pour consulter les requĂȘtes terminĂ©es au fil des chargements, actions et onglets. Lâhistorique couvre les contextes de la session, y compris les contextes temporaires de proxy, et enregistre les rĂ©ponses sous forme dâobjets `Response` de Scrapling. Recherchez les appels dâAPI, les erreurs HTTP et les redirections sans renvoyer de requĂȘtes. Vous pouvez lire leurs en-tĂȘtes et leur contenu mĂȘme aprĂšs la fermeture de la session. Les requĂȘtes Ă©chouĂ©es ou inachevĂ©es sont omises. Les rĂ©ponses HTTP 4xx et 5xx terminĂ©es sont incluses.++```python+from scrapling.fetchers import StealthySession++with StealthySession(record_requests=True, max_recorded_requests=1000) as session:+ session.fetch('https://example.com', network_idle=True)++for response in session.network.search(resource_type='document', limit=None):+ print(response.meta['network_id'], response.url, response.status)+ if note := response.meta.get('body_note'):+ print(note)+ else:+ print(response.body)+ print(response.css('title::text').get())++session.network.clear()+```++La mĂȘme API fonctionne avec `AsyncStealthySession`. Lâenregistrement est dĂ©sactivĂ© par dĂ©faut. Ă la crĂ©ation de la session, dĂ©finissez `record_requests=True` et, si nĂ©cessaire, `max_recorded_requests`.++- `session.network.search(url_pattern=None, method=None, resource_type=None, status=None, after_id=0, limit=100, include_static=True)` renvoie les objets `Response` enregistrĂ©s dans lâordre de leur ID rĂ©seau. Avec `limit=None`, renvoie toutes les correspondances conservĂ©es. `url_pattern` est une expression rĂ©guliĂšre appliquĂ©e Ă la recherche ; une expression invalide produit une erreur Ă ce moment-lĂ . `after_id` sĂ©lectionne les rĂ©ponses dont lâID est supĂ©rieur. `include_static=False` inclut les requĂȘtes XHR/fetch et les erreurs HTTP. Utilisez `True` pour tous les types de ressources et les redirections enregistrĂ©es.+- `session.network.get(request_id)` renvoie un `Response` enregistrĂ©, ou `None` sâil nâest plus conservĂ©.+- `session.network.clear()` efface lâhistorique. Les ID continuent dâaugmenter et ne sont jamais rĂ©utilisĂ©s.++Chaque `Response` enregistrĂ© fournit directement `.url`, `.method`, `.status`, `.headers`, `.request_headers`, `.body` en octets, `.json()` et les mĂ©thodes CSS/XPath. Son `.meta` contient `network_id`, `resource_type` et `request_body`, qui vaut des octets ou `None`. Les en-tĂȘtes peuvent ĂȘtre partiels si leur lecture complĂšte Ă©choue. Ces lectures sont locales, mĂȘme dans les sessions asynchrones : nâutilisez pas await et nâappelez pas `.body()`. Si le contenu ne peut pas ĂȘtre analysĂ©, ses octets sont conservĂ©s, mais CSS et XPath utilisent un document vide.++Pour rechercher le trafic dâAPI par URL, utilisez `session.network.search(url_pattern=r'https://api\.example\.com/.*', limit=None)`. Ajoutez `resource_type='fetch'` ou `resource_type='xhr'` si vous voulez un seul type de requĂȘte.++Seul le contenu des rĂ©ponses ayant un `Content-Type` textuel pris en charge est enregistré : `text/*`, types `+json`/`+xml`, y compris SVG, JSON, XML, JavaScript, GraphQL et donnĂ©es de formulaire encodĂ©es comme URL. Les types binaires, inconnus ou sans `Content-Type` gardent leurs mĂ©tadonnĂ©es, mais pas les octets du contenu. Le navigateur charge toujours les ressources normalement.++Les octets enregistrĂ©s viennent de Playwright et peuvent diffĂ©rer des octets originaux du serveur. Sâils forment du UTF-8 valide, le texte est dĂ©codĂ© en UTF-8, comme dans Playwright. Sinon, lâencodage dĂ©clarĂ© est utilisĂ©. Les en-tĂȘtes restent inchangĂ©s.++Si le contenu est omis, trop volumineux ou illisible, il renvoie `b''` et indique la raison dans `response.meta.get('body_note')`. Pour un contenu non textuel, la note est `Non-text body; not saved.`. Les mĂ©tadonnĂ©es et les en-tĂȘtes disponibles sont conservĂ©s. Le texte enregistrĂ©, mĂȘme vide, nâa pas de note. Les rĂ©ponses HEAD et les statuts 204, 205 et 304 restent vides, sans note.++Les mĂ©thodes `search`, `get` et `clear` sont locales et synchrones, mĂȘme dans les sessions asynchrones. Une entrĂ©e apparaĂźt seulement aprĂšs la conversion et lâenregistrement de sa rĂ©ponse. Les Ă©vĂ©nements du navigateur sont traitĂ©s pendant que Playwright est actif. Les captures asynchrones nĂ©cessitent aussi une boucle dâĂ©vĂ©nements en cours dâexĂ©cution. Lire lâhistorique nâattend pas les captures en cours.++La fermeture dâune session nâattend pas non plus les captures. Celles qui sont encore en cours lors dâune navigation ou de la fermeture du contexte peuvent ĂȘtre omises. Les rĂ©ponses dĂ©jĂ enregistrĂ©es restent lisibles aprĂšs la fermeture.++Par dĂ©faut, lâhistorique conserve jusquâĂ 1 000 requĂȘtes. Chaque corps de rĂ©ponse est limitĂ© Ă 1 MiB, avec une limite totale de 20 MiB. Les anciennes entrĂ©es sont supprimĂ©es quand une limite est atteinte. Les limites de contenu sont fixes, pas des rĂ©glages de session. Elles couvrent les entrĂ©es conservĂ©es et les octets des rĂ©ponses, pas la mĂ©moire totale du navigateur, les captures simultanĂ©es, les lectures temporaires complĂštes, le HTML analysĂ© ou les corps de requĂȘte.++#### Migrer vers la v5 {#migrating-in-v5}++`capture_xhr` et `response.captured_xhr` ont Ă©tĂ© supprimĂ©s en v5. Utilisez une session de navigateur explicite avec `record_requests=True`, puis consultez `session.network.search(url_pattern=..., limit=None)`. Cela remplace aussi la capture dâAPI avec les fetchers Ă appel unique : conservez donc lâobjet de session. Les filtres sâappliquent Ă lâhistorique enregistrĂ© de toute la session, pas Ă la capture ni Ă une seule rĂ©cupĂ©ration de page. Seuls les corps de rĂ©ponse textuels pris en charge sont enregistrĂ©s. `search()` renvoie au plus 100 correspondances par dĂ©faut. `limit=None` renvoie toutes les correspondances conservĂ©es sans changer les limites de lâhistorique.++### En-tĂȘtes et paramĂštres rĂ©gionaux du navigateur {#browser-headers-and-locale}++```python+page = StealthyFetcher.fetch(+ 'https://example.com',+ google_search=True,+ useragent='Mozilla/5.0...',+ locale='en-US',+)+```++### Exemple gĂ©nĂ©ral {#general-example}+```python+from scrapling.fetchers import StealthyFetcher++def scrape_dynamic_content():++ page = StealthyFetcher.fetch(+ 'https://example.com/dynamic',+ network_idle=True,+ wait_selector='.content'+ )+++ content = page.css('.content')++ return {+ 'title': content.css('h1::text').get(),+ 'items': [+ item.text for item in content.css('.item')+ ]+ }+```++### Rotation des proxies {#proxy-rotation}++```python+from scrapling.fetchers import StealthySession, ProxyRotator+++rotator = ProxyRotator([+ "http://proxy1:8080",+ "http://proxy2:8080",+ "http://proxy3:8080",+])+++with StealthySession(proxy_rotator=rotator, headless=True) as session:+ page1 = session.fetch('https://example1.com')+ page2 = session.fetch('https://example2.com')+++ page3 = session.fetch('https://example3.com', proxy='http://specific-proxy:8080')+```++!!! warning "Attention"++ Par dĂ©faut, les fetchers de navigateur et leurs sessions utilisent un contexte persistant avec un ensemble dâonglets. Les navigateurs ne permettent pas de dĂ©finir un proxy par onglet. Avec `ProxyRotator`, le fetcher ouvre donc un contexte distinct pour chaque proxy, avec un onglet par contexte. Quand le travail de cet onglet est terminĂ©, lâonglet et son contexte sont fermĂ©s.++## Quand lâutiliser {#when-to-use}++Utilisez StealthyFetcher si vous :++- Devez contourner des protections contre les bots.+- Avez besoin dâune empreinte de navigateur fiable.+- Avez besoin dâune prise en charge complĂšte de JavaScript.+- Voulez des fonctions automatiques pour Ă©viter la dĂ©tection.+- Devez automatiser un navigateur.+- Travaillez avec des sites protĂ©gĂ©s par Cloudflare.diff --git a/docs/locales/fr/index.md b/docs/locales/fr/index.mdnew file mode 100644index 0000000..1e86390--- /dev/null+++ b/docs/locales/fr/index.md@@ -0,0 +1,243 @@+---+title: "Scrapling : framework de web scraping pour Python"+description: "Scrapling : extrayez simplement les donnĂ©es du web moderne."+---++<style>+.md-typeset h1 {+ display: none;+}+[data-md-color-scheme="default"] .only-dark { display: none; }+[data-md-color-scheme="slate"] .only-light { display: none; }+</style>++<br/>+<div align="center">+ <a href="index.html" alt="Couverture">+ <img alt="Scrapling" src="assets/cover_light.svg" class="only-light">+ <img alt="Scrapling" src="assets/cover_dark.svg" class="only-dark">+ </a>+</div>++<h2 align="center"><i>Extrayez simplement les donnĂ©es du web moderne</i></h2><br>++Scrapling est un framework de web scraping pour Python. Il rĂ©unit des requĂȘtes HTTP rapides, des navigateurs furtifs, lâanalyse de pages et lâexploration simultanĂ©e de sites dans une seule bibliothĂšque.++Extrayez les donnĂ©es de pages statiques, exĂ©cutez JavaScript, interagissez avec les sites et accĂ©dez aux API quâils utilisent. CrĂ©ez des crawlers avec des sessions rĂ©utilisables, la rotation des proxies, de nouvelles tentatives automatiques, la pause et la reprise, et des exports intĂ©grĂ©s.++Utilisez Scrapling depuis Python, le terminal ou votre agent IA grĂące au serveur MCP et Ă lâAgent Skill. Il couvre tout le processus, de lâextraction de quelques champs Ă lâenregistrement dâun site entier en fichiers Markdown propres.++## Ce que vous pouvez faire avec Scrapling {#what-you-can-do-with-scrapling}++- **[RĂ©cupĂ©rer des pages et interagir](fetching/choosing.md)** : RequĂȘtes HTTP rapides, navigateurs furtifs, exĂ©cution de JavaScript, gestion de Cloudflare Turnstile et Interstitial, sessions persistantes et capture des rĂ©ponses des API en arriĂšre-plan.+- **[Analyser et extraire](parsing/selection.md)** : Recherche par CSS, XPath, texte et expressions rĂ©guliĂšres, suivi des Ă©lĂ©ments aprĂšs un changement de page, recherche dâĂ©lĂ©ments similaires et sortie en Markdown propre.+- **[Explorer et exporter](spiders/getting-started.md)** : Spiders simultanĂ©s, rotation des proxies, nouvelles tentatives, AutoThrottle, pause et reprise, rĂ©sultats en streaming, modĂšles prĂȘts Ă lâemploi et exports en JSON, JSONL, CSV et XML.+- **[Extraire avec lâIA ou depuis le terminal](ai/mcp-server.md)** : Un serveur MCP pour que les agents IA naviguent et extraient des donnĂ©es, une Agent Skill, des commandes CLI et un shell interactif.++Commencez par une seule page :++```python+from scrapling.fetchers import Fetcher++page = Fetcher.get('https://quotes.toscrape.com/')+quotes = page.css('.quote .text::text').getall()+print(quotes)+```++Ou extrayez plus de donnĂ©es avec un spider :++```python+from scrapling.spiders import Spider, Response++class QuotesSpider(Spider):+ name = "quotes"+ start_urls = ["https://quotes.toscrape.com/"]++ async def parse(self, response: Response):+ for quote in response.css('.quote'):+ yield {+ "text": quote.css('.text::text').get(),+ "author": quote.css('.author::text').get(),+ }++result = QuotesSpider().start()+print(len(result.items))+result.items.to_json("quotes.json")+```++Cet exemple affiche `10` et enregistre les citations et leurs auteurs dans `quotes.json`.++## Sponsors principaux {#top-sponsors}++--8<-- "sponsors.html"++<i><sub>Vous souhaitez afficher votre publicitĂ© iciâŻ? Cliquez [ici](https://github.com/sponsors/D4Vinci), choisissez une offre et profitez de ses avantages.</sub></i>++## Fonctions principales {#key-features}++### Spiders : un framework complet dâexploration de sites {#spiders-a-full-crawling-framework}+- đ·ïž **API de Spider proche de Scrapy** : DĂ©finissez des spiders avec `start_urls`, des callbacks `parse` asynchrones et des objets `Request` et `Response`.+- ⥠**Exploration simultanĂ©e** : RĂ©glez le nombre de requĂȘtes simultanĂ©es, les limites par domaine et le dĂ©lai entre les tĂ©lĂ©chargements.+- đ **Plusieurs sessions** : Utilisez des requĂȘtes HTTP et des navigateurs furtifs sans interface graphique dans le mĂȘme spider. Dirigez les requĂȘtes vers diffĂ©rentes sessions grĂące Ă leur ID.+- đŸ **Pause et reprise** : Enregistrez les requĂȘtes en attente et les URL visitĂ©es avec `crawldir`. Appuyez sur Ctrl+C pour arrĂȘter proprement, puis relancez avec le mĂȘme dossier.+- đĄ **RĂ©sultats en streaming** : Recevez les Ă©lĂ©ments dĂšs leur extraction avec `async for item in spider.stream()`, avec des statistiques en temps rĂ©el. Utile pour les interfaces, les traitements de donnĂ©es et les explorations longues.+- đĄïž **DĂ©tection des requĂȘtes bloquĂ©es** : DĂ©tectez et relancez les requĂȘtes bloquĂ©es automatiquement. Vous pouvez adapter ce comportement.+- đŠ **AutoThrottle** : Le spider ajuste le dĂ©lai de chaque domaine selon la vitesse de rĂ©ponse du site. Si le site bloque ou limite les requĂȘtes, il double le dĂ©lai ou respecte la durĂ©e indiquĂ©e par `Retry-After`. Il accĂ©lĂšre Ă nouveau quand la limitation prend fin.+- đ€ **Respect de robots.txt** : Activez `robots_txt_obey` pour respecter les directives `Disallow`, `Crawl-delay` et `Request-rate`, avec un cache par domaine.+- đ§Ș **Mode dĂ©veloppement** : Enregistrez les rĂ©ponses sur disque lors de la premiĂšre exĂ©cution et rĂ©utilisez-les ensuite. Vous pouvez ainsi ajuster `parse()` sans envoyer de nouvelles requĂȘtes aux serveurs.+- đ§© **ModĂšles de spider prĂȘts Ă lâemploi** : Utilisez `CrawlSpider` pour suivre les liens selon des rĂšgles, `SitemapSpider` pour explorer Ă partir de sitemaps ou de robots.txt, `XMLFeedSpider` et `CSVFeedSpider` pour lire des flux XML, RSS et CSV, et `ShopifySpider` pour collecter les produits des boutiques Shopify publiques, avec un Ă©lĂ©ment par variante.+- đ **Extraction de liens** : `LinkExtractor` permet dâaccepter ou de refuser des liens selon des motifs, de filtrer les domaines et les extensions, de limiter la recherche avec CSS ou XPath et de normaliser les URL. Utilisez-le avec les modĂšles ou seul.+- đŠ **Export intĂ©grĂ©** : Exportez les rĂ©sultats avec des hooks et votre propre traitement de donnĂ©es, ou utilisez les formats JSON, JSONL, CSV et XML intĂ©grĂ©s : `result.items.to_json()`, `to_jsonl()`, `to_csv()` et `to_xml()`.++### RĂ©cupĂ©ration de pages avec des sessions {#advanced-websites-fetching-with-session-support}+- **RequĂȘtes HTTP** : Envoyez des requĂȘtes HTTP rapides et furtives avec `Fetcher`. Vous pouvez imiter lâempreinte TLS et les en-tĂȘtes dâun navigateur, et utiliser HTTP/3.+- **Chargement dynamique** : RĂ©cupĂ©rez les sites dynamiques avec une automatisation complĂšte du navigateur grĂące Ă `StealthyFetcher`, compatible avec le Chromium de Playwright et Google Chrome.+- **Contournement des systĂšmes antibot** : `StealthyFetcher` masque lâautomatisation et imite les empreintes du navigateur. Il peut franchir automatiquement les diffĂ©rents types de Cloudflare Turnstile et Interstitial.+- **Gestion des sessions** : `FetcherSession` et `StealthySession` conservent les cookies et lâĂ©tat entre les requĂȘtes.+- **Rotation des proxies** : `ProxyRotator` permet une rotation cyclique ou personnalisĂ©e dans tous les types de sessions. Vous pouvez aussi choisir un proxy pour une requĂȘte prĂ©cise.+- **Blocage des domaines et des publicitĂ©s** : Bloquez les requĂȘtes vers certains domaines et leurs sous-domaines, ou activez le blocage des publicitĂ©s des fetchers de navigateur. Il couvre environ 3âŻ500 domaines connus de publicitĂ© et de suivi.+- **PrĂ©vention des fuites DNS** : Activez DNS-over-HTTPS pour envoyer les requĂȘtes DNS par le service DoH de Cloudflare et Ă©viter les fuites lorsque vous utilisez des proxies.+- **Navigateurs distants** : Connectez-vous par CDP Ă un navigateur dĂ©jĂ ouvert avec `cdp_url`, sur votre ordinateur, un autre serveur ou un service de navigateurs. Vous pouvez aussi utiliser votre propre version de Chromium avec tout fetcher de navigateur grĂące Ă `executable_path`.+- **Capture des API en arriĂšre-plan** : Activez `record_requests=True` dans une session de navigateur et cherchez les rĂ©ponses enregistrĂ©es avec `session.network.search(limit=None)`. Lisez les donnĂ©es des API et les erreurs HTTP de plusieurs chargements sans rĂ©pĂ©ter les requĂȘtes. Lâhistorique a une taille limitĂ©e et conserve le contenu des rĂ©ponses textuelles.+- **Mode asynchrone** : Tous les fetchers peuvent fonctionner en mode asynchrone, avec des classes de session propres Ă ce mode.++### Analyse de pages et extraction de donnĂ©es {#parsing-and-data-extraction}+- đ **Suivi des Ă©lĂ©ments** : Retrouvez les Ă©lĂ©ments aprĂšs un changement du site grĂące Ă des algorithmes de similaritĂ©.+- đŻ **SĂ©lection souple** : Utilisez CSS, XPath, les filtres, le texte, les expressions rĂ©guliĂšres et plus encore.+- đ **ĂlĂ©ments similaires** : Trouvez automatiquement des Ă©lĂ©ments proches de ceux que vous avez dĂ©jĂ trouvĂ©s.++### Fonctions pour lâIA {#ai-features}+- đ€ **Serveur MCP** : Permet aux assistants et agents IA, comme Claude et Cursor, dâextraire des donnĂ©es avec Scrapling par des requĂȘtes HTTP, des actions du navigateur, des captures dâĂ©cran, un Ă©tat de connexion enregistrĂ© et des rĂ©ponses dâAPI en arriĂšre-plan. Il utilise notre navigateur furtif et des outils qui aident les modĂšles adaptĂ©s Ă rĂ©soudre les CAPTCHA, en plus du solveur Cloudflare. Il rĂ©duit le contenu envoyĂ© au modĂšle, bloque les publicitĂ©s et protĂšge contre les injections de prompts. Il permet aussi dâutiliser des navigateurs distants par CDP et des connexions HTTP avec des options dâauthentification. ([VidĂ©o de dĂ©monstration](https://www.youtube.com/watch?v=qyFk3ZNwOxE))+- đ§ **Agent Skill** : Une [Agent Skill](ai/agent-skill.md) prĂȘte Ă installer qui enseigne la bibliothĂšque aux agents de programmation pour quâils Ă©crivent du code conforme Ă lâAPI actuelle.+- đ **Markdown prĂȘt pour le RAG** : Convertissez une page en Markdown propre et adaptĂ© aux modĂšles de langage avec une ligne (`page.markdown()`), ou enregistrez un site entier en fichiers Markdown avec le modĂšle `ContentSpider`. Le processus ne demande aucun modĂšle de langage. ([Documentation](ai/building-rag-systems.md))++### Performances et usage rĂ©el {#high-performance-battle-tested-architecture}+- đ **Grande vitesse** : Des performances optimisĂ©es qui dĂ©passent la plupart des bibliothĂšques de web scraping pour Python.+- đ **Faible usage de la mĂ©moire** : Des structures de donnĂ©es optimisĂ©es et un chargement Ă la demande.+- ⥠**Conversion rapide en JSON** : 10 fois plus rapide que la bibliothĂšque standard.+- đïž **TestĂ© en pratique** : Les tests couvrent 92âŻ% de Scrapling et tout le code a des annotations de type. Des centaines de personnes lâont utilisĂ© chaque jour pour extraire des donnĂ©es pendant lâannĂ©e passĂ©e.++### Outils pour dĂ©velopper et extraire des donnĂ©es {#developerweb-scraper-friendly-experience}+- đŻ **Shell interactif** : Un shell IPython en option, intĂ©grĂ© Ă Scrapling, avec des raccourcis et des outils pour crĂ©er des scripts plus vite. Convertissez les requĂȘtes curl en requĂȘtes Scrapling et consultez les rĂ©sultats dans votre navigateur.+- đ **Usage depuis le terminal** : Extrayez les donnĂ©es dâune URL sans Ă©crire de code.+- đ ïž **Navigation dans le DOM** : AccĂ©dez aux Ă©lĂ©ments parents, frĂšres et enfants.+- đ§Ź **Traitement du texte** : Expressions rĂ©guliĂšres, nettoyage du texte et opĂ©rations optimisĂ©es sur les chaĂźnes.+- đ **CrĂ©ation de sĂ©lecteurs** : GĂ©nĂ©rez des sĂ©lecteurs CSS et XPath fiables pour tout Ă©lĂ©ment.+- đ **API familiĂšre** : Proche de Scrapy et BeautifulSoup, avec les mĂȘmes pseudo-Ă©lĂ©ments que Scrapy et Parsel.+- đ€ **IntĂ©gration directe avec Scrapy** : Ajoutez le dĂ©corateur `scrapling_response` Ă un callback pour analyser les rĂ©ponses que vous rĂ©cupĂ©rez dĂ©jĂ avec le parser de Scrapling, sans réécrire votre programme.+- đ **Annotations de type complĂštes** : Elles aident lâĂ©diteur Ă vĂ©rifier et Ă complĂ©ter le code. Tout le code est vĂ©rifiĂ© automatiquement par **PyRight** et **MyPy** Ă chaque changement.+- đ **Image Docker prĂȘte Ă lâemploi** : Une image Docker avec tous les navigateurs est créée et publiĂ©e automatiquement Ă chaque version.+++## Historique des Ă©toiles {#star-history}+Le nombre dâĂ©toiles de Scrapling sur GitHub augmente depuis son lancement, comme le montre le graphique.++<div id="chartContainer">+ <a href="https://github.com/D4Vinci/Scrapling">+ <img id="chartImage" alt="Historique des Ă©toiles" loading="lazy" src="https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date" height="400"/>+ </a>+</div>++<script>+const observer = new MutationObserver((mutations) => {+ mutations.forEach((mutation) => {+ if (mutation.attributeName === 'data-md-color-media') {+ const colorMedia = document.body.getAttribute('data-md-color-media');+ const isDarkScheme = document.body.getAttribute('data-md-color-scheme') === 'slate';+ const chartImg = document.querySelector('#chartImage');+ const baseUrl = 'https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date';++ if (colorMedia === '(prefers-color-scheme)' ? isDarkScheme : colorMedia.includes('dark')) {+ chartImg.src = `${baseUrl}&theme=dark`;+ } else {+ chartImg.src = baseUrl;+ }+ }+ });+});++observer.observe(document.body, {+ attributes: true,+ attributeFilter: ['data-md-color-media', 'data-md-color-scheme']+});+</script>+++## Installation {#installation}+Scrapling demande Python 3.10 ou une version plus rĂ©cente :++```bash+pip install scrapling+```++!!! warning "Attention"++ Cette commande installe seulement le parser et ses dĂ©pendances, sans fetchers ni outils en ligne de commande. Avec cette seule installation, importer depuis `scrapling.fetchers` ou `scrapling.spiders`, comme dans les exemples prĂ©cĂ©dents, provoque `ModuleNotFoundError`. Pour utiliser les fetchers ou les spiders, installez dâabord les dĂ©pendances des fetchers comme indiquĂ© ci-dessous.++### DĂ©pendances facultatives {#optional-dependencies}++1. Pour utiliser les fetchers, leurs classes ou les fonctions supplĂ©mentaires suivantes, installez les dĂ©pendances des fetchers et des navigateurs :+ ```bash+ pip install "scrapling[fetchers]"++ scrapling install # normal install+ scrapling install --force # force reinstall+ ```++ Cette commande tĂ©lĂ©charge tous les navigateurs, leurs dĂ©pendances systĂšme et les outils de modification des empreintes du navigateur.++ Vous pouvez aussi les installer depuis Python, au lieu de lancer une commande :+ ```python+ from scrapling.cli import install++ install([], standalone_mode=False) # normal install+ install(["--force"], standalone_mode=False) # force reinstall+ ```++2. Fonctions supplĂ©mentaires :+++ - Installer le serveur MCP :+ ```bash+ pip install "scrapling[ai]"+ ```+ - Installer les dĂ©pendances pour [crĂ©er des systĂšmes RAG](ai/building-rag-systems.md) :+ ```bash+ pip install "scrapling[rag]"+ ```+ - Installer le shell interactif et la commande `extract` :+ ```bash+ pip install "scrapling[shell]"+ ```+ - Tout installer :+ ```bash+ pip install "scrapling[all]"+ ```+ Lancez `scrapling install` pour utiliser les fetchers de navigateur. Les requĂȘtes HTTP ne demandent pas de navigateur.++### Docker {#docker}+Vous pouvez aussi tĂ©lĂ©charger depuis DockerHub une image Docker avec tous les extras et navigateurs :+```bash+docker pull pyd4vinci/scrapling+```+Ou la tĂ©lĂ©charger depuis le registre GitHub :+```bash+docker pull ghcr.io/d4vinci/scrapling:latest+```+Lâimage est créée Ă partir de la branche principale du dĂ©pĂŽt et publiĂ©e automatiquement par GitHub Actions.++## Organisation de la documentation {#how-the-documentation-is-organized}+La documentation de Scrapling est vaste. Nous suivons donc le [modĂšle de documentation DiĂĄtaxis](https://diataxis.fr/).++## Soutien {#support}++Si vous aimez Scrapling et souhaitez soutenir son dĂ©veloppement :++- â Ajoutez une Ă©toile au [dĂ©pĂŽt GitHub](https://github.com/D4Vinci/Scrapling).+- đ Suivez-nous sur [Twitter](https://x.com/Scrapling_dev) et rejoignez le [serveur Discord](https://discord.gg/EMgGbDceNQ).+- đ Vous pouvez [sponsoriser le projet ou mâoffrir un cafĂ©](donate.md). :wink:+- đ Signalez les bugs et proposez des fonctions sur [GitHub Issues](https://github.com/D4Vinci/Scrapling/issues).++## Licence {#license}++Ce projet utilise la licence BSD-3. Consultez le fichier [LICENSE](https://github.com/D4Vinci/Scrapling/blob/main/LICENSE) pour en savoir plus.diff --git a/docs/locales/fr/integrations/scrapy.md b/docs/locales/fr/integrations/scrapy.mdnew file mode 100644index 0000000..c763372--- /dev/null+++ b/docs/locales/fr/integrations/scrapy.md@@ -0,0 +1,64 @@+---+title: "Utiliser lâanalyse de Scrapling dans un spider Scrapy"+description: "Convertissez les rĂ©ponses Scrapy en Scrapling ou ajoutez un dĂ©corateur Ă un callback. Gardez votre robot Scrapy et utilisez les sĂ©lecteurs et lâanalyse adaptative de Scrapling."+---++# IntĂ©grer Scrapling Ă Scrapy {#integrating-scrapling-into-scrapy}++Si vous avez dĂ©jĂ un projet Scrapy, vous nâavez pas besoin de le réécrire pour utiliser lâAPI dâanalyse de Scrapling. LâintĂ©gration convertit les rĂ©ponses Scrapy en objets [Response](../fetching/choosing.md#response-object) de Scrapling directement dans les callbacks du spider. Scrapy continue ainsi de gĂ©rer lâexploration, tandis que Scrapling analyse le contenu.++!!! note "Installation"++ Cette intĂ©gration fonctionne avec lâinstallation standard de Scrapling (`pip install scrapling`), sans extras. Elle demande seulement que Scrapy soit installĂ©, ce qui est dĂ©jĂ le cas dans un projet Scrapy.++## Utilisation {#usage}++Ajoutez le dĂ©corateur `scrapling_response` Ă un callback du spider. Lâargument `response` quâil reçoit devient un `Response` de Scrapling :++```python+import scrapy+from scrapling.integrations.scrapy import scrapling_response+++class QuotesSpider(scrapy.Spider):+ name = "quotes"+ start_urls = ["https://quotes.toscrape.com"]++ @scrapling_response+ def parse(self, response): # `response` is now a Scrapling Response+ first_quote = response.find_by_text("The world as we have created it", partial=True)+ for quote in [first_quote, *first_quote.find_similar()]:+ card = quote.parent+ yield {+ "text": quote.get_all_text(strip=True),+ "author": card.find("small", class_="author").text,+ "tags": [tag.text for tag in card.find_all("a", class_="tag")],+ }+ next_page = response.css("li.next a::attr(href)").get()+ if next_page:+ yield scrapy.Request(response.urljoin(next_page), callback=self.parse)+```++Le dĂ©corateur fonctionne avec tous les types de callback pris en charge par Scrapy : fonctions classiques, gĂ©nĂ©rateurs, coroutines et gĂ©nĂ©rateurs asynchrones. Il conserve le type, le nom et la docstring du callback. Lâinspection des callbacks et les contrats de Scrapy continuent donc de fonctionner.++Vous pouvez aussi passer une configuration de [Selector](../parsing/main_classes.md#selector) au dĂ©corateur. Elle sera transmise au `Response` créé :++```python+ @scrapling_response(adaptive=True, keep_comments=True)+ def parse_product(self, response):+ ...+```++Si vous avez une rĂ©ponse Scrapy en dehors dâun callback, par exemple dans un middleware ou un pipeline, utilisez directement le convertisseur :++```python+from scrapling.integrations.scrapy import convert_response++scrapling_response = convert_response(scrapy_response, keep_comments=False)+```++## Notes {#notes}++- Utilisez yield avec `scrapy.Request(response.urljoin(href))` pour visiter les pages suivantes, comme dans lâexemple ci-dessus. La mĂ©thode `Response.follow()` de Scrapling crĂ©e des requĂȘtes pour le [systĂšme de spiders de Scrapling](../spiders/getting-started.md), que Scrapy ne comprend pas.+- Une copie superficielle du dictionnaire `meta` de la rĂ©ponse est créée. Les objets enregistrĂ©s par dâautres middlewares restent donc accessibles. Par exemple, avec `scrapy-playwright`, la page reste dans `response.meta["playwright_page"]`.+- Les cookies sont lus dans les en-tĂȘtes `Set-Cookie` bruts et ajoutĂ©s au dictionnaire `cookies` de la rĂ©ponse.diff --git a/docs/locales/fr/overview.md b/docs/locales/fr/overview.mdnew file mode 100644index 0000000..1d49e1e--- /dev/null+++ b/docs/locales/fr/overview.md@@ -0,0 +1,341 @@+---+title: "Guide de Scrapling : analyse de pages, HTTP et navigateurs furtifs"+description: "DĂ©couvrez Scrapling avec des exemples de CSS, XPath, recherche de texte, requĂȘtes HTTP et navigateurs furtifs."+---++# Premiers pas avec Scrapling {#get-started-with-scrapling}++## Choisissez par oĂč commencer {#pick-your-path}++Vous ne savez pas par oĂč commencerâŻ? Choisissez ce que vous voulez faire :++| Je veux⊠| Commencez ici |+|:---|:---|+| **Analyser du HTML** que jâai dĂ©jĂ | [SĂ©lection dâĂ©lĂ©ments](parsing/selection.md) : CSS, XPath et recherche par texte |+| **Extraire une page rapidement** et tester une idĂ©e | Choisissez un [fetcher](fetching/choosing.md) et essayez-le, ou ouvrez le [shell interactif](cli/interactive-shell.md) |+| **CrĂ©er un crawler** capable de traiter plus de pages | [Spiders](spiders/getting-started.md) : exploration simultanĂ©e avec plusieurs sessions, pause et reprise |+| **Extraire des donnĂ©es sans Ă©crire de code** | Utilisez les [commandes dâextraction](cli/extract-commands.md) ou connectez le [serveur MCP](ai/mcp-server.md) Ă votre outil dâIA |+| **Migrer** depuis une autre bibliothĂšque | [Depuis BeautifulSoup](tutorials/migrating_from_beautifulsoup.md) ou [comparaison avec Scrapy](spiders/architecture.md#comparison-with-scrapy) |++---++Nous allons dâabord analyser des pages. Ensuite, nous rĂ©cupĂ©rerons des pages avec des navigateurs, enverrons des requĂȘtes et analyserons les rĂ©ponses.++Nous utiliserons ce document HTML gĂ©nĂ©rĂ© par ChatGPT dans les exemples de cette page :+```python+html_doc = """<html>+ <head>+ <title>Complex Web Page</title>+ <style>+ .hidden { display: none; }+ </style>+ </head>+ <body>+ <header>+ <nav>+ <ul>+ <li> <a href="#home">Home</a> </li>+ <li> <a href="#about">About</a> </li>+ <li> <a href="#contact">Contact</a> </li>+ </ul>+ </nav>+ </header>+ <main>+ <section id="products" schema='{"jsonable": "data"}'>+ <h2>Products</h2>+ <div class="product-list">+ <article class="product" data-id="1">+ <h3>Product 1</h3>+ <p class="description">This is product 1</p>+ <span class="price">$10.99</span>+ <div class="hidden stock">In stock: 5</div>+ </article>++ <article class="product" data-id="2">+ <h3>Product 2</h3>+ <p class="description">This is product 2</p>+ <span class="price">$20.99</span>+ <div class="hidden stock">In stock: 3</div>+ </article>++ <article class="product" data-id="3">+ <h3>Product 3</h3>+ <p class="description">This is product 3</p>+ <span class="price">$15.99</span>+ <div class="hidden stock">Out of stock</div>+ </article>+ </div>+ </section>++ <section id="reviews">+ <h2>Customer Reviews</h2>+ <div class="review-list">+ <div class="review" data-rating="5">+ <p class="review-text">Great product!</p>+ <span class="reviewer">John Doe</span>+ </div>+ <div class="review" data-rating="4">+ <p class="review-text">Good value for money.</p>+ <span class="reviewer">Jane Smith</span>+ </div>+ </div>+ </section>+ </main>+ <script id="page-data" type="application/json">+ {+ "lastUpdated": "2024-09-22T10:30:00Z",+ "totalProducts": 3+ }+ </script>+ </body>+</html>"""+```+Commencez par charger le HTML prĂ©cĂ©dent :+```python+import re+from scrapling.parser import Selector+page = Selector(html_doc)+page # <data='<html><head><title>Complex Web Page</tit...'>+```+RĂ©cupĂ©rez tout le texte de la page, y compris celui des Ă©lĂ©ments imbriquĂ©s :+```python+page.get_all_text(ignore_tags=('script', 'style'))+# 'Complex Web Page\nHome\nAbout\nContact\nProducts\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock\nCustomer Reviews\nGreat product!\nJohn Doe\nGood value for money.\nJane Smith'+```++## Rechercher des Ă©lĂ©ments {#finding-elements}+Vous pouvez combiner plusieurs mĂ©thodes pour trouver les Ă©lĂ©ments dont vous avez besoin.++Trouvez le premier Ă©lĂ©ment HTML `section` :+```python+section_element = page.find('section')+# <data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>+```+Trouvez tous les Ă©lĂ©ments `section` :+```python+section_elements = page.find_all('section')+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>, <data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]+```+Trouvez tous les Ă©lĂ©ments `section` dont lâattribut `id` vaut `products` :+```python+section_elements = page.find_all('section', {'id':"products"})+# Same as+section_elements = page.find_all('section', id="products")+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>]+```+Trouvez tous les Ă©lĂ©ments `section` dont lâattribut `id` contient `product` :+```python+section_elements = page.find_all('section', {'id*':"product"})+```+Trouvez les Ă©lĂ©ments `h3` dont le texte correspond Ă lâexpression rĂ©guliĂšre `Product \d` :+```python+page.find_all('h3', re.compile(r'Product \d'))+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]+```+Trouvez les Ă©lĂ©ments `h3` et `h2` dont le texte correspond Ă lâexpression rĂ©guliĂšre `Product` :+```python+page.find_all(['h3', 'h2'], re.compile(r'Product'))+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>, <data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]+```+Trouvez les Ă©lĂ©ments dont le texte est exactement `Products`. Les espaces ne sont pas pris en compte :+```python+page.find_by_text('Products', first_match=False)+# [<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]+```+Ou trouvez les Ă©lĂ©ments dont le texte correspond Ă lâexpression rĂ©guliĂšre `Product \d` :+```python+page.find_by_regex(r'Product \d', first_match=False)+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]+```+Trouvez des Ă©lĂ©ments similaires Ă celui que vous avez choisi :+```python+target_element = page.find_by_regex(r'Product \d', first_match=True)+# <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>+target_element.find_similar()+# [<data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]+```+Trouvez le premier Ă©lĂ©ment qui correspond Ă un sĂ©lecteur CSS :+```python+page.css('.product-list [data-id="1"]')[0]+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>+```+Trouvez tous les Ă©lĂ©ments qui correspondent Ă un sĂ©lecteur CSS :+```python+page.css('.product-list article')+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]+```+Trouvez le premier Ă©lĂ©ment qui correspond Ă un sĂ©lecteur XPath :+```python+page.xpath("//*[@id='products']/div/article")[0]+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>+```+Trouvez tous les Ă©lĂ©ments qui correspondent Ă un sĂ©lecteur XPath :+```python+page.xpath("//*[@id='products']/div/article")+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]+```++Ce sont les usages de base. Nous verrons dâautres options de ces mĂ©thodes de sĂ©lection plus loin.+## Lire les donnĂ©es des Ă©lĂ©ments {#accessing-elements-data}+Vous pouvez lire les donnĂ©es ainsi :+```pycon+>>> section_element.tag+'section'+>>> print(section_element.attrib)+{'id': 'products', 'schema': '{"jsonable": "data"}'}+>>> section_element.attrib['schema'].json() # If an attribute value can be converted to json, then use `.json()` to convert it+{'jsonable': 'data'}+>>> section_element.text # Direct text content+''+>>> section_element.get_all_text() # All text content recursively+'Products\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'+>>> section_element.html_content # The HTML content of the element+'<section id="products" schema=\'{"jsonable": "data"}\'><h2>Products</h2>\n <div class="product-list">\n <article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article><article class="product" data-id="2"><h3>Product 2</h3>\n <p class="description">This is product 2</p>\n <span class="price">$20.99</span>\n <div class="hidden stock">In stock: 3</div>\n </article><article class="product" data-id="3"><h3>Product 3</h3>\n <p class="description">This is product 3</p>\n <span class="price">$15.99</span>\n <div class="hidden stock">Out of stock</div>\n </article></div>\n </section>'+>>> print(section_element.prettify()) # The prettified version+'''+<section id="products" schema='{"jsonable": "data"}'><h2>Products</h2>+ <div class="product-list">+ <article class="product" data-id="1"><h3>Product 1</h3>+ <p class="description">This is product 1</p>+ <span class="price">$10.99</span>+ <div class="hidden stock">In stock: 5</div>+ </article><article class="product" data-id="2"><h3>Product 2</h3>+ <p class="description">This is product 2</p>+ <span class="price">$20.99</span>+ <div class="hidden stock">In stock: 3</div>+ </article><article class="product" data-id="3"><h3>Product 3</h3>+ <p class="description">This is product 3</p>+ <span class="price">$15.99</span>+ <div class="hidden stock">Out of stock</div>+ </article>+ </div>+</section>+'''+>>> section_element.path # All the ancestors in the DOM tree of this element+[<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>,+ <data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>,+ <data='<html><head><title>Complex Web Page</tit...'>]+>>> section_element.generate_css_selector+'#products'+>>> section_element.generate_full_css_selector+'body > main > #products'+>>> section_element.generate_xpath_selector+"//*[@id='products']"+>>> section_element.generate_full_xpath_selector+"//body/main/*[@id='products']"+```++## Navigation {#navigation}+Utilisez les Ă©lĂ©ments trouvĂ©s prĂ©cĂ©demment :++```pycon+>>> section_element.parent+<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>+>>> section_element.parent.tag+'main'+>>> section_element.parent.parent.tag+'body'+>>> section_element.children+[<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>,+ <data='<div class="product-list"> <article clas...' parent='<section id="products" schema='{"jsonabl...'>]+>>> section_element.siblings+[<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]+>>> section_element.next # gets the next element, the same logic applies to `quote.previous`.+<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>+>>> section_element.children.css('h2::text').getall()+['Products']+>>> page.css('[data-id="1"]')[0].has_class('product')+True+```+Pour aller au-delĂ du parent dâun Ă©lĂ©ment, vous pouvez parcourir tous ses ancĂȘtres :+```python+for ancestor in section_element.iterancestors():+ print(ancestor.tag)+```+Vous pouvez aussi chercher un ancĂȘtre qui remplit une condition. Passez une fonction qui reçoit un objet `Selector` et renvoie `True` sâil remplit la condition, ou `False` sinon :+```pycon+>>> section_element.find_ancestor(lambda ancestor: ancestor.css('nav'))+<data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>+```++## RĂ©cupĂ©rer des pages web {#fetching-websites}+Au lieu de fournir du HTML Ă Scrapling, vous pouvez rĂ©cupĂ©rer la rĂ©ponse dâun site par des requĂȘtes HTTP ou un navigateur.++Choisissez le fetcher adaptĂ© Ă votre cas.++### RequĂȘtes HTTP {#http-requests}+Pour envoyer des requĂȘtes HTTP, importez et utilisez la classe `Fetcher` :+```python+from scrapling.fetchers import Fetcher+page = Fetcher.get('https://scrapling.requestcatcher.com/get', impersonate="chrome")+```+Ces exemples montrent comment utiliser les diffĂ©rentes mĂ©thodes HTTP :+```python+from scrapling.fetchers import Fetcher+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')+page = Fetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})+page = Fetcher.delete('https://scrapling.requestcatcher.com/delete')+```+Pour envoyer des requĂȘtes asynchrones, changez lâimportation :+```python+from scrapling.fetchers import AsyncFetcher+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')+page = await AsyncFetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})+page = await AsyncFetcher.delete('https://scrapling.requestcatcher.com/delete')+```++!!! note "Notes"++ 1. `stealthy_headers` gĂ©nĂšre des en-tĂȘtes de navigateur rĂ©els, dont un en-tĂȘte de provenance Google. Cette option est activĂ©e par dĂ©faut.+ 2. `impersonate` permet dâimiter lâempreinte TLS dâune version prĂ©cise de navigateur.+ 3. `http3` active HTTP/3 pour rapprocher les requĂȘtes de celles dâun vrai navigateur.++Consultez les autres options dans le [guide des requĂȘtes HTTP](fetching/static.md).++### Chargement dynamique {#dynamic-loading}+Vous pouvez aussi travailler avec des sites qui chargent leur contenu par JavaScript.++`StealthyFetcher` propose de nombreuses options pour rĂ©cupĂ©rer et charger des pages avec des navigateurs basĂ©s sur Chromium.+```python+from scrapling.fetchers import StealthyFetcher+page = StealthyFetcher.fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')+print(len(page.css(".quote"))) # -> 10++# The async version of fetch+page = await StealthyFetcher.async_fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')+print(len(page.css(".quote"))) # -> 10+```+Il utilise [Playwright](https://playwright.dev/python/) avec des changements pour masquer lâautomatisation. Utilisez le Chromium inclus, votre Google Chrome installĂ© avec `real_chrome=True` ou un navigateur dĂ©jĂ ouvert via `cdp_url`.++### Fonctions contre la dĂ©tection des bots {#anti-bot-features}++Voici quelques-unes de ses fonctions :++1. Franchit automatiquement les diffĂ©rents types de Cloudflare Turnstile et Interstitial avec `solve_cloudflare=True`.+2. Ăvite les fuites de CDP runtime et WebRTC.+3. Isole lâexĂ©cution de JavaScript, supprime de nombreuses traces de Playwright et Ă©vite la dĂ©tection de certains comportements connus des bots.+4. Ajoute du bruit au canvas pour empĂȘcher son usage comme empreinte du navigateur.+5. Corrige les mĂ©thodes connues de dĂ©tection des navigateurs sans interface graphique et permet dâĂ©viter la dĂ©tection par les diffĂ©rences de fuseau horaire.+6. Inclut dâautres options pour Ă©viter la dĂ©tection.++```python+from scrapling.fetchers import StealthyFetcher+page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection') # Running headless by default+page.status == 200 # -> True++page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True) # Solve Cloudflare captcha automatically if presented+page.status == 200 # -> True++page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection', block_webrtc=True, hide_canvas=True, dns_over_https=True) # and the rest of arguments...+# The async version of fetch+page = await StealthyFetcher.async_fetch('https://www.browserscan.net/bot-detection')+page.status == 200 # -> True+```++Consultez le [guide de navigation](fetching/stealthy.md) pour connaĂźtre les dĂ©tails et la liste complĂšte des paramĂštres.++---++Vous avez maintenant une vue dâensemble de Scrapling. Passez Ă la section suivante pour dĂ©couvrir dâautres fonctions.diff --git a/docs/locales/fr/parsing/adaptive.md b/docs/locales/fr/parsing/adaptive.mdnew file mode 100644index 0000000..3c7ef99--- /dev/null+++ b/docs/locales/fr/parsing/adaptive.md@@ -0,0 +1,232 @@+---+title: "Suivez et retrouvez des Ă©lĂ©ments HTML avec lâanalyse adaptative"+description: "Enregistrez les propriĂ©tĂ©s dâun Ă©lĂ©ment et retrouvez-le aprĂšs une modification du HTML. Apprenez Ă activer lâanalyse adaptative et Ă utiliser save, retrieve et relocate."+---++# Scraping adaptatif {#adaptive-scraping}++!!! success "Avant de commencer"++ 1. Lisez la page [Rechercher des Ă©lĂ©ments](../parsing/selection.md) pour savoir comment trouver et extraire des Ă©lĂ©ments dâun objet [Selector](../parsing/main_classes.md#selector).+ 2. Lisez la page [Classes principales](../parsing/main_classes.md) pour connaĂźtre la classe [Selector](../parsing/main_classes.md#selector).++Le scraping adaptatif, auparavant appelĂ© automatch, est lâune des fonctions les plus puissantes de Scrapling. Il permet Ă votre scraper de continuer Ă fonctionner quand un site change, en suivant les Ă©lĂ©ments et en les retrouvant.++Supposons que vous vouliez extraire des donnĂ©es dâune page avec cette structure :+```html+<div class="container">+ <section class="products">+ <article class="product" id="p1">+ <h3>Product 1</h3>+ <p class="description">Description 1</p>+ </article>+ <article class="product" id="p2">+ <h3>Product 2</h3>+ <p class="description">Description 2</p>+ </article>+ </section>+</div>+```+Vous voulez extraire le premier produit, celui dont lâID est `p1`. Vous utiliseriez sans doute ce sĂ©lecteur :+```python+page.css('#p1')+```+Si les responsables du site modifient la structure ainsi :+```html+<div class="new-container">+ <div class="product-wrapper">+ <section class="products">+ <article class="product new-class" data-id="p1">+ <div class="product-info">+ <h3>Product 1</h3>+ <p class="new-description">Description 1</p>+ </div>+ </article>+ <article class="product new-class" data-id="p2">+ <div class="product-info">+ <h3>Product 2</h3>+ <p class="new-description">Description 2</p>+ </div>+ </article>+ </section>+ </div>+</div>+```+Le sĂ©lecteur ne fonctionnera plus et vous devrez modifier votre code. Câest lĂ que la fonction `adaptive` de Scrapling intervient.++Vous pouvez activer `adaptive` la premiĂšre fois que vous sĂ©lectionnez un Ă©lĂ©ment. Si le sĂ©lecteur ne le trouve plus la fois suivante, Scrapling utilise les propriĂ©tĂ©s enregistrĂ©es pour chercher lâĂ©lĂ©ment le plus ressemblant dans la page. Et cela sans IA :)++```python+from scrapling import Selector, Fetcher+# Before the change+page = Selector(page_source, adaptive=True, url='example.com')+# or+Fetcher.adaptive = True+page = Fetcher.get('https://example.com')+# then+element = page.css('#p1', auto_save=True)+if not element: # One day website changes?+ element = page.css('#p1', adaptive=True) # Scrapling still finds it!+# the rest of your code...+```+Vous trouverez ci-dessous un exemple, puis les dĂ©tails dâutilisation. Cette fonction marche avec toutes les mĂ©thodes de sĂ©lection, pas seulement CSS et XPath.++## Un exemple rĂ©el {#real-world-scenario}+Prenons un vrai site et utilisons un fetcher pour obtenir son code. Pour tester une modification de structure, il faudrait enregistrer le code avant la mise Ă jour, puis attendre le changement. Il est presque impossible de savoir quand cela arrivera, sauf si je connais le propriĂ©taire. Mais ce serait alors un test prĂ©parĂ© Ă lâavance, haha.++Pour rĂ©soudre ce problĂšme, je vais utiliser [The Web Archive](https://archive.org/) et sa [Wayback Machine](https://web.archive.org/). Voici une copie du [site StackOverFlow en 2010](https://web.archive.org/web/20100102003420/http://stackoverflow.com/). Cela remonte Ă loin, non ?</br>Voyons si la fonction adaptative peut extraire le mĂȘme bouton dans la version de 2010 et dans la version actuelle avec un seul sĂ©lecteur :)++Pour extraire le bouton Questions dans lâancienne version, je peux utiliser `#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a`. Ce sĂ©lecteur est trĂšs prĂ©cis parce quâil a Ă©tĂ© gĂ©nĂ©rĂ© par Google Chrome.+++Testons le mĂȘme sĂ©lecteur dans les deux versions :+```python+from scrapling import Fetcher+selector = '#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a'+old_url = "https://web.archive.org/web/20100102003420/http://stackoverflow.com/"+new_url = "https://stackoverflow.com/"+Fetcher.configure(adaptive = True, adaptive_domain='stackoverflow.com')+page = Fetcher.get(old_url, timeout=30)+element1 = page.css(selector, auto_save=True)[0]+# Same selector but used in the updated website+page = Fetcher.get(new_url)+element2 = page.css(selector, adaptive=True)[0]++if element1.text == element2.text:+ print('Scrapling found the same element in the old and new designs!') # Spoiler alert: it does!+```+Un nouvel argument apparaĂźt ici : `adaptive_domain`. Pour Scrapling, `archive.org` et `stackoverflow.com` sont deux domaines distincts, donc leurs donnĂ©es `adaptive` sont sĂ©parĂ©es. Pour indiquer quâil sâagit du mĂȘme site, nous passons le mĂȘme domaine personnalisĂ© lors de lâenregistrement des donnĂ©es `adaptive` des deux versions.++Dans un cas rĂ©el, le code serait identique, mais utiliserait la mĂȘme URL pour les deux requĂȘtes. Vous nâauriez pas besoin de `adaptive_domain`. Câest lâexemple le plus proche dâun cas rĂ©el que je puisse montrer. JâespĂšre quâil est clair :)++Jâai utilisĂ© les classes `Selector` et `Fetcher` dans les deux exemples pour montrer que la logique adaptative est la mĂȘme.++!!! info "Information"++ `adaptive_domain` a surtout Ă©tĂ© ajoutĂ© pour gĂ©rer les sites qui changent dâURL en mĂȘme temps que de structure ou de prĂ©sentation. Cet argument permet de rĂ©utiliser les donnĂ©es adaptatives dĂ©jĂ enregistrĂ©es avec la nouvelle URL. Sans lui, Scrapling considĂšre quâil sâagit dâun autre site et nâutilise plus les anciennes donnĂ©es.++## Comment fonctionne le scraping adaptatif {#how-the-adaptive-scraping-feature-works}+Le scraping adaptatif se dĂ©roule en deux Ă©tapes :++1. **Enregistrer** : stocker les propriĂ©tĂ©s qui distinguent chaque Ă©lĂ©ment.+2. **Rechercher une correspondance** : retrouver ensuite les Ă©lĂ©ments aux propriĂ©tĂ©s similaires.++Supposons que vous ayez sĂ©lectionnĂ© un Ă©lĂ©ment avec nâimporte quelle mĂ©thode. Vous voulez que la bibliothĂšque le retrouve lors de la prochaine collecte, mĂȘme si la structure ou la prĂ©sentation du site change.++Sans entrer dans trop de dĂ©tails techniques, voici le fonctionnement :++ 1. Vous demandez Ă Scrapling dâenregistrer les propriĂ©tĂ©s de lâĂ©lĂ©ment avec lâune des mĂ©thodes prĂ©sentĂ©es plus bas.+ 2. Scrapling enregistre ces propriĂ©tĂ©s dans la base de donnĂ©es configurĂ©e, SQLite par dĂ©faut.+ 3. Les responsables du site peuvent modifier ou supprimer nâimporte quelle propriĂ©tĂ© de lâĂ©lĂ©ment. Aucune ne peut donc servir dâidentifiant unique dans la base de donnĂ©es. Pour rĂ©soudre ce problĂšme, le systĂšme de stockage utilise deux valeurs :+ 1. Le domaine du site actuel. Avec `Selector`, indiquez-le Ă la crĂ©ation de lâobjet. Avec un fetcher, il est obtenu automatiquement Ă partir de lâURL.+ 2. Un `identifier` pour retrouver les propriĂ©tĂ©s de lâĂ©lĂ©ment dans la base. Vous nâavez pas toujours Ă le dĂ©finir vous-mĂȘme, comme nous le verrons plus loin.++ Ensemble, ces valeurs permettent de rĂ©cupĂ©rer les propriĂ©tĂ©s enregistrĂ©es de lâĂ©lĂ©ment.++ 4. Quand la structure du site change, activez `adaptive` pour rechercher lâĂ©lĂ©ment. Scrapling rĂ©cupĂšre les propriĂ©tĂ©s enregistrĂ©es et les compare Ă celles de tous les Ă©lĂ©ments de la page. Il attribue Ă chaque Ă©lĂ©ment un score de ressemblance, en tenant compte des donnĂ©es prĂ©sentĂ©es ci-dessous.+ 5. Il renvoie lâĂ©lĂ©ment ou les Ă©lĂ©ments ayant le meilleur score.++### Les propriĂ©tĂ©s de lâĂ©lĂ©ment {#the-unique-properties}+Vous vous demandez peut-ĂȘtre quelles propriĂ©tĂ©s peuvent ĂȘtre utiles si toutes sont susceptibles de changer ou de disparaĂźtre.++Scrapling utilise ces donnĂ©es :++- Le nom de la balise, le texte, les attributs avec leurs noms et leurs valeurs, les noms de balises des Ă©lĂ©ments frĂšres et les noms de balises du chemin de lâĂ©lĂ©ment.+- Le nom de la balise du parent, ses attributs avec leurs noms et leurs valeurs, et son texte.++La comparaison nâexige pas des valeurs identiques. Elle mesure leur ressemblance. Elle tient mĂȘme compte de leur ordre, par exemple celui des noms de classes avant et aprĂšs la modification.++## Utiliser la fonction adaptative {#how-to-use-adaptive-feature}+Vous pouvez appliquer la fonction adaptative Ă tout Ă©lĂ©ment trouvĂ©. Elle est aussi disponible sous forme dâarguments dans les mĂ©thodes CSS et XPath, comme nous lâavons vu. Nous y reviendrons plus bas.++Activez dâabord `adaptive` en passant `adaptive=True` Ă la crĂ©ation dâun [Selector](main_classes.md#selector), ou activez-la dans le fetcher utilisĂ©, comme ci-dessous.++Exemples :+```python+from scrapling import Selector, Fetcher+page = Selector(html_doc, adaptive=True)+# OR+Fetcher.adaptive = True+page = Fetcher.get('https://example.com')+```+Si vous utilisez [Selector](main_classes.md#selector), passez lâURL du site avec lâargument `url`. Scrapling peut ainsi sĂ©parer les propriĂ©tĂ©s enregistrĂ©es par domaine.++Sans URL, la valeur `default` est utilisĂ©e dans ce champ lors de lâenregistrement. Cela ne pose problĂšme que si vous rĂ©utilisez ensuite le mĂȘme identifiant pour un autre site sans indiquer son URL. Chaque enregistrement remplace les donnĂ©es prĂ©cĂ©dentes, et `adaptive` utilise uniquement les derniĂšres propriĂ©tĂ©s enregistrĂ©es.++Les arguments `storage` et `storage_args` configurent la connexion Ă la base de donnĂ©es. Par dĂ©faut, la bibliothĂšque utilise sa propre classe SQLite. Vous nâavez besoin de ces arguments que pour crĂ©er votre propre systĂšme de stockage, dĂ©crit dans [une page de la section dĂ©veloppement](../development/adaptive_storage_system.md).++Une fois `adaptive` activĂ©e globalement, vous avez deux façons principales de lâutiliser.++### Avec la sĂ©lection CSS ou XPath {#the-cssxpath-selection-way}+Comme dans lâexemple prĂ©cĂ©dent, utilisez dâabord `auto_save` pour sĂ©lectionner un Ă©lĂ©ment prĂ©sent dans la page :+```python+element = page.css('#p1', auto_save=True)+```+Si le sĂ©lecteur ne le trouve plus, utilisez le mĂȘme sĂ©lecteur avec `adaptive` pour que la bibliothĂšque le recherche :+```python+element = page.css('#p1', adaptive=True)+```+PlutĂŽt simple, non ?++Plusieurs opĂ©rations se dĂ©roulent en coulisses. Vous vous souvenez de lâidentifiant qui permet de rĂ©cupĂ©rer lâĂ©lĂ©ment ? Les mĂ©thodes `css` et `xpath` utilisent automatiquement le sĂ©lecteur comme identifiant pour vous simplifier la tĂąche :)++Vous pouvez aussi passer `identifier` Ă ces mĂ©thodes pour dĂ©finir votre propre valeur. Cela peut ĂȘtre utile dans certains cas, y compris lors de lâenregistrement avec `auto_save`.++### Manuellement {#the-manual-way}+Vous pouvez enregistrer et rĂ©cupĂ©rer un Ă©lĂ©ment manuellement, puis le retrouver avec `adaptive`. Cela fonctionne avec les Ă©lĂ©ments obtenus par nâimporte quelle mĂ©thode de sĂ©lection.++Par exemple, supposons que vous trouviez un Ă©lĂ©ment par son texte :+```python+element = page.find_by_text('Tipping the Velvet', first_match=True)+```+Enregistrez ses propriĂ©tĂ©s avec `save`. Dans ce cas, vous devez choisir lâidentifiant. Jâai utilisĂ© `my_special_element` ici. Dans votre code, choisissez un nom qui dĂ©crit lâĂ©lĂ©ment, comme vous le faites pour vos variables :)+```python+page.save(element, 'my_special_element')+```+Plus tard, vous pouvez rĂ©cupĂ©rer les donnĂ©es et rechercher lâĂ©lĂ©ment dans la page avec `adaptive` :+```python+>>> element_dict = page.retrieve('my_special_element')+>>> page.relocate(element_dict, selector_type=True)+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]+>>> page.relocate(element_dict, selector_type=True).css('::text').getall()+['Tipping the Velvet']+```+Pour cela, utilisez `retrieve` et `relocate`.++Pour conserver le rĂ©sultat sous forme dâobjet `lxml.etree`, ne passez pas `selector_type` :+```python+>>> page.relocate(element_dict)+[<Element a at 0x105a2a7b0>]+```++## RĂ©soudre les problĂšmes {#troubleshooting}++### Aucune correspondance trouvĂ©e {#no-matches-found}+```python+# 1. Check if data was saved+element_data = page.retrieve('identifier')+if not element_data:+ print("No data saved for this identifier")++# 2. Try with different identifier+products = page.css('.product', adaptive=True, identifier='old_selector')++# 3. Save again with new identifier+products = page.css('.new-product', auto_save=True, identifier='new_identifier')+```++### Mauvais Ă©lĂ©ments trouvĂ©s {#wrong-elements-matched}+```python+# Use more specific selectors+products = page.css('.product-list .product', auto_save=True)++# Or save with more context+product = page.find_by_text('Product Name').parent+page.save(product, 'specific_product')+```++## ProblĂšmes connus {#known-issues}+Lors de lâenregistrement avec `adaptive`, seules les propriĂ©tĂ©s du premier Ă©lĂ©ment trouvĂ© sont conservĂ©es. Si votre sĂ©lecteur trouve plusieurs Ă©lĂ©ments Ă diffĂ©rents endroits de la page, `adaptive` ne retrouvera que le premier. Cela ne concerne pas les sĂ©lecteurs CSS combinĂ©s, par exemple ceux sĂ©parĂ©s par des virgules. Ils sont sĂ©parĂ©s et exĂ©cutĂ©s un par un.++## Pour terminer {#final-thoughts}+Expliquer cette fonction en dĂ©tail sans la compliquer a Ă©tĂ© un dĂ©fi. Si quelque chose reste flou, Ă©crivez dans la [section des discussions](https://github.com/D4Vinci/Scrapling/discussions) et je vous rĂ©pondrai dĂšs que possible. Vous pouvez aussi utiliser le serveur Discord ou me contacter en privé :)\ No newline at end of filediff --git a/docs/locales/fr/parsing/main_classes.md b/docs/locales/fr/parsing/main_classes.mdnew file mode 100644index 0000000..00e8735--- /dev/null+++ b/docs/locales/fr/parsing/main_classes.md@@ -0,0 +1,573 @@+---+title: "Selector et Selectors de Scrapling : donnĂ©es et navigation"+description: "DĂ©couvrez comment Selector et Selectors stockent le HTML, le texte et les attributs. Extrayez des valeurs, rĂ©solvez les URL et parcourez parents, enfants et frĂšres."+---++# Classes principales du parser {#parsing-main-classes}++!!! success "Avant de commencer"++ - Lisez [Rechercher des Ă©lĂ©ments](../parsing/selection.md) pour savoir comment trouver et extraire des Ă©lĂ©ments dâun objet [Selector](../parsing/main_classes.md#selector).++AprĂšs les mĂ©thodes de sĂ©lection et leurs fonctions, voyons la classe [Selector](#selector) et les autres objets. Cela vous aidera Ă mieux comprendre le parser.++La classe [Selector](#selector) est au cĆur du parser de Scrapling. Elle analyse le HTML et permet de sĂ©lectionner des Ă©lĂ©ments. Vous pouvez lâimporter de lâune de ces façons :+```python+from scrapling import Selector+from scrapling.parser import Selector+```+Utilisez-la ensuite directement, comme dans la [vue dâensemble](../overview.md) :+```python+page = Selector(+ '<html>...</html>',+ url='https://example.com'+)++# Then select elements as you like+elements = page.css('.product')+```+Quand vous fournissez du HTML ou rĂ©cupĂ©rez un site, vous travaillez principalement avec un [Selector](#selector). Les opĂ©rations de sĂ©lection ou de navigation qui renvoient des Ă©lĂ©ments de la page donnent un [Selector](#selector) ou un [Selectors](#selectors). Cela ne concerne pas les opĂ©rations qui renvoient du texte ou dâautres valeurs.++La page est un [Selector](#selector), et chaque Ă©lĂ©ment quâelle contient est aussi un [Selector](#selector). Le texte des Ă©lĂ©ments et des attributs utilise [TextHandler](#texthandler). Les attributs de chaque Ă©lĂ©ment sont stockĂ©s dans [AttributesHandler](#attributeshandler). Nous y reviendrons. Commençons par [Selector](#selector).++## Selector {#selector}+### Arguments {#arguments-explained}+Le plus important est `content`, qui reçoit le HTML Ă analyser sous forme de `str` ou de `bytes`.++`url` dĂ©finit lâURL de la page, utilisĂ©e pour rĂ©soudre les liens relatifs et sĂ©parer les donnĂ©es adaptatives enregistrĂ©es par domaine. Les arguments `adaptive`, `storage` et `storage_args` configurent la fonction [adaptative](adaptive.md). Ils nâont pas dâeffet si vous nâutilisez pas cette fonction.++Ces arguments contrĂŽlent le traitement du HTML :++- **encoding** : encodage utilisĂ© pour analyser le HTML. La valeur par dĂ©faut est `UTF-8`.+- **keep_comments** : indique si les commentaires HTML doivent ĂȘtre conservĂ©s. Cette option est dĂ©sactivĂ©e par dĂ©faut, car les commentaires peuvent poser problĂšme lors de lâextraction.++Nous laisserons `huge_tree` et `root` de cĂŽtĂ© pour ne pas compliquer cette page.+Ce sont des fonctions avancĂ©es dont vous nâavez pas besoin pour commencer. La section dĂ©veloppement couvre ces dĂ©tails si vous souhaitez approfondir.++La plupart des propriĂ©tĂ©s de la page et de ses Ă©lĂ©ments ne sont chargĂ©es que lorsque vous les utilisez, comme le contenu textuel. Ce chargement Ă la demande explique en partie la vitesse de Scrapling :)++### PropriĂ©tĂ©s {#properties}+Nous en avons dĂ©jĂ vu une partie dans la [vue dâensemble](../overview.md), mais nous allons les dĂ©tailler avec des exemples plus complets. Les propriĂ©tĂ©s pour parcourir la page sont regroupĂ©es dans la section [navigation](#traversal).++Pour les exemples, analysons cette page HTML :+```html+<html>+ <head>+ <title>Some page</title>+ </head>+ <body>+ <div class="product-list">+ <article class="product" data-id="1">+ <h3>Product 1</h3>+ <p class="description">This is product 1</p>+ <span class="price">$10.99</span>+ <div class="hidden stock">In stock: 5</div>+ </article>++ <article class="product" data-id="2">+ <h3>Product 2</h3>+ <p class="description">This is product 2</p>+ <span class="price">$20.99</span>+ <div class="hidden stock">In stock: 3</div>+ </article>++ <article class="product" data-id="3">+ <h3>Product 3</h3>+ <p class="description">This is product 3</p>+ <span class="price">$15.99</span>+ <div class="hidden stock">Out of stock</div>+ </article>+ </div>++ <script id="page-data" type="application/json">+ {+ "lastUpdated": "2024-09-22T10:30:00Z",+ "totalProducts": 3+ }+ </script>+ </body>+</html>+```+Chargez la page comme prĂ©cĂ©demment :+```python+from scrapling import Selector+page = Selector(html_doc)+```+Obtenez tout le texte de la page, y compris celui des Ă©lĂ©ments internes :+```python+>>> page.get_all_text()+'Some page\n\n \n\n \nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'+```+Obtenez le premier article, qui servira dâexemple :+```python+article = page.find('article')+```+De la mĂȘme façon, obtenez tout le texte de lâĂ©lĂ©ment et des Ă©lĂ©ments quâil contient :+```python+>>> article.get_all_text()+'Product 1\nThis is product 1\n$10.99\nIn stock: 5'+```+Si vous cherchez seulement son texte direct, le rĂ©sultat sera vide. Dans le HTML ci-dessus, cet Ă©lĂ©ment nâa pas de texte en dehors de ses enfants :+```python+>>> article.text+''+```+La mĂ©thode `get_all_text` accepte ces arguments facultatifs :++1. **separator** : sĂ©parateur utilisĂ© pour joindre les textes trouvĂ©s. La valeur par dĂ©faut est '\n'.+2. **strip** : supprime les espaces au dĂ©but et Ă la fin de chaque texte avant de les joindre. DĂ©sactivĂ© par dĂ©faut.+3. **ignore_tags** : tuple de noms de balises Ă ignorer, ainsi que tout leur contenu. La valeur par dĂ©faut est `('script', 'style',)`.+4. **valid_values** : collecte uniquement les textes ayant un contenu. Ignore les textes vides ou composĂ©s uniquement dâespaces. ActivĂ© par dĂ©faut.++Le texte renvoyĂ© est un [TextHandler](#texthandler), pas une chaĂźne ordinaire. Nous le verrons plus loin. Sâil contient du JSON valide, vous pouvez utiliser `.json()` :+```python+>>> script = page.find('script')+>>> script.json()+{'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}+```+Obtenez la balise de lâĂ©lĂ©ment :+```python+>>> article.tag+'article'+```+Sur la page directement, vous travaillez avec lâĂ©lĂ©ment racine `html` :+```python+>>> page.tag+'html'+```+La mĂȘme idĂ©e sâapplique Ă `page` et Ă `element`, nous nây reviendrons donc pas.++Obtenez les attributs de lâĂ©lĂ©ment :+```python+>>> print(article.attrib)+{'class': 'product', 'data-id': '1'}+```+AccĂ©dez Ă un attribut prĂ©cis de lâune de ces façons :+```python+article.attrib['class']+article.attrib.get('class')+article['class'] # new in v0.3+```+VĂ©rifiez si un attribut existe avec lâune de ces mĂ©thodes :+```python+'class' in article.attrib+'class' in article # new in v0.3+```+Obtenez le HTML de lâĂ©lĂ©ment :+```python+>>> article.html_content+'<article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article>'+```+Obtenez une version du HTML mise en forme pour ĂȘtre plus lisible :+```python+print(article.prettify())+```+```html+<article class="product" data-id="1"><h3>Product 1</h3>+ <p class="description">This is product 1</p>+ <span class="price">$10.99</span>+ <div class="hidden stock">In stock: 5</div>+</article>+```+Utilisez `.body` pour obtenir le contenu brut de la page. Depuis la v0.4, sur les objets `Response` des fetchers, `.body` renvoie toujours des `bytes`.+```python+>>> page.body+'<html>\n <head>\n <title>Some page</title>\n </head>\n ...'+```+Obtenez tous les ancĂȘtres de lâĂ©lĂ©ment dans lâarbre DOM :+```python+>>> article.path+[<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>,+ <data='<body> <div class="product-list"> <artic...' parent='<html><head><title>Some page</title></he...'>,+ <data='<html><head><title>Some page</title></he...'>]+```+GĂ©nĂ©rez un sĂ©lecteur CSS court si possible, sinon un sĂ©lecteur complet :+```python+>>> article.generate_css_selector+'body > div > article'+>>> article.generate_full_css_selector+'body > div > article'+```+La mĂȘme chose avec XPath :+```python+>>> article.generate_xpath_selector+"//body/div/article"+>>> article.generate_full_xpath_selector+"//body/div/article"+```++### Navigation {#traversal}+Ă partir des Ă©lĂ©ments prĂ©cĂ©dents, voyons les propriĂ©tĂ©s et mĂ©thodes pour parcourir la page.++Si vous ne connaissez pas lâarbre DOM ou les structures en arbre, cette section peut sembler dĂ©routante. Je vous conseille de lire une prĂ©sentation de ces notions.++Voici une explication rapide pour commencer.<br/>+LâĂ©lĂ©ment `html` est la racine de lâarbre de la page, car toute page commence par un Ă©lĂ©ment `html`.<br/>+Juste en dessous se trouvent des Ă©lĂ©ments comme `head` et `body`. Ce sont les enfants de `html`, et cet Ă©lĂ©ment `html` est leur parent. `head` et `body` sont frĂšres parce quâils partagent le mĂȘme parent.++AccĂ©dez au parent dâun Ă©lĂ©ment :+```python+>>> article.parent+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>+>>> article.parent.tag+'div'+```+Vous pouvez enchaĂźner cette propriĂ©tĂ©. Cela vaut aussi pour les propriĂ©tĂ©s et mĂ©thodes similaires prĂ©sentĂ©es ensuite.+```python+>>> article.parent.parent.tag+'body'+```+Obtenez les enfants dâun Ă©lĂ©ment :+```python+>>> article.children+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]+```+Obtenez tous les Ă©lĂ©ments situĂ©s en dessous, mĂȘme aux niveaux plus profonds. Cela fonctionne comme `children`, mais parcourt tous les niveaux :+```python+>>> article.below_elements+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]+```+Ici, le rĂ©sultat est le mĂȘme que pour `children`, car les enfants nâont pas eux-mĂȘmes dâenfants.++Cet exemple avec lâĂ©lĂ©ment de classe `product-list` montre mieux la diffĂ©rence entre `children` et `below_elements` :+```python+>>> products_list = page.css('.product-list')[0]+>>> products_list.children+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]++>>> products_list.below_elements+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>,+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,+...]+```+Obtenez les frĂšres dâun Ă©lĂ©ment :+```python+>>> article.siblings+[<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]+```+Obtenez lâĂ©lĂ©ment suivant :+```python+>>> article.next+<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>+```+La mĂȘme logique sâapplique Ă `previous` :+```python+>>> article.previous # It's the first child, so it doesn't have a previous element+>>> second_article = page.css('.product[data-id="2"]')[0]+>>> second_article.previous+<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>+```+VĂ©rifiez rapidement si un Ă©lĂ©ment possĂšde une classe prĂ©cise :+```python+>>> article.has_class('product')+True+```+Si vous devez remonter au-delĂ du parent, vous pouvez parcourir tous les ancĂȘtres de lâĂ©lĂ©ment :+```python+for ancestor in article.iterancestors():+ # do something with it...+```+Vous pouvez aussi rechercher un ancĂȘtre qui remplit une condition. Passez une fonction qui reçoit un [Selector](#selector) et renvoie `True` si la condition est remplie, ou `False` sinon :+```python+>>> article.find_ancestor(lambda ancestor: ancestor.has_class('product-list'))+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>++>>> article.find_ancestor(lambda ancestor: ancestor.css('.product-list')) # Same result, different approach+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>+```+## Selectors {#selectors}+`Selectors` est la version liste de [Selector](#selector). Elle hĂ©rite du type `List` de Python et conserve les propriĂ©tĂ©s et mĂ©thodes de `List`. Elle ajoute aussi des mĂ©thodes pour travailler avec les objets [Selector](#selector) quâelle contient.++Dans [Selector](#selector), les mĂ©thodes et propriĂ©tĂ©s qui renvoient plusieurs Ă©lĂ©ments les fournissent dans un objet [Selectors](#selectors).++Depuis la v0.4, toutes les mĂ©thodes de sĂ©lection renvoient des objets [Selector](#selector)/[Selectors](#selectors), mĂȘme pour le texte et les attributs. Les nĆuds de texte obtenus avec `::text`, `/text()`, `::attr()` ou `/@attr` sont enveloppĂ©s dans des objets [Selector](#selector). Leur `tag` vaut `"#text"` et leur propriĂ©tĂ© `text` renvoie la valeur textuelle. Les autres propriĂ©tĂ©s renvoient des valeurs vides ou par dĂ©faut sans erreur.++```python+page.css('a::text') # -> Selectors (of text node Selectors)+page.xpath('//a/text()') # -> Selectors+page.css('a::text').get() # -> TextHandler (the first text value)+page.css('a::text').getall() # -> TextHandlers (all text values)+page.css('a::attr(href)') # -> Selectors+page.xpath('//a/@href') # -> Selectors+page.css('.price_color') # -> Selectors+```++### MĂ©thodes dâextraction de donnĂ©es {#data-extraction-methods}+Depuis la v0.4, [Selector](#selector) et [Selectors](#selectors) proposent `get()`, `getall()` et leurs alias `extract_first` et `extract`, selon les conventions de Scrapy. Lâancienne mĂ©thode `get_all()` a Ă©tĂ© supprimĂ©e.++**Sur un objet [Selector](#selector) :**++- `get()` renvoie un `TextHandler` : la valeur du texte pour un nĆud de texte, ou le HTML externe complet sous forme de chaĂźne pour un Ă©lĂ©ment HTML.+- `getall()` renvoie une liste `TextHandlers` contenant cette seule chaĂźne.+- `extract_first` est un alias de `get()`, et `extract` est un alias de `getall()`.++```python+>>> page.css('h3')[0].get() # Outer HTML of the element+'<h3>Product 1</h3>'++>>> page.css('h3::text')[0].get() # Text value of the text node+'Product 1'+```++**Sur un objet [Selectors](#selectors) :**++- `get(default=None)` renvoie la chaĂźne du **premier** Ă©lĂ©ment, ou `default` si la liste est vide.+- `getall()` convertit **tous** les Ă©lĂ©ments en chaĂźnes et renvoie une liste `TextHandlers`.+- `extract_first` est un alias de `get()`, et `extract` est un alias de `getall()`.++```python+>>> page.css('.price::text').get() # First price text+'$10.99'++>>> page.css('.price::text').getall() # All price texts+['$10.99', '$20.99', '$15.99']++>>> page.css('.price::text').get('') # With default value+'$10.99'+```++Ces mĂ©thodes fonctionnent avec tous les types de sĂ©lection, comme CSS, XPath et `find`. Elles sont recommandĂ©es pour extraire le texte et les attributs dans un style compatible avec Scrapy.++Voyons maintenant ce que [Selectors](#selectors) propose en plus.+### PropriĂ©tĂ©s {#properties_1}+En plus des opĂ©rations habituelles sur les listes Python, comme les parcourir ou en prendre une tranche, vous pouvez effectuer les opĂ©rations suivantes :++ExĂ©cuter des sĂ©lecteurs CSS et XPath directement sur les objets [Selector](#selector) de la liste. Les types renvoyĂ©s sont les mĂȘmes que pour `css` et `xpath` de [Selector](#selector). Les arguments sont similaires, sauf que `adaptive` nâest pas disponible ici. Cela facilite lâenchaĂźnement des mĂ©thodes.+```pycon+>>> page.css('.product h3::text').getall()+['Product 1', 'Product 2', 'Product 3']+>>> page.css('.product').css('h3::text').getall()+['Product 1', 'Product 2', 'Product 3']+```+ExĂ©cuter `re` et `re_first` directement, avec les mĂȘmes arguments que dans [Selector](#selector). Nous les expliquerons dans la section [TextHandler](#texthandler).++Ici, `re_first` fonctionne diffĂ©remment : il exĂ©cute `re` sur chaque [Selector](#selector) et renvoie le premier ayant un rĂ©sultat. `re` renvoie un [TextHandlers](#texthandlers) qui rassemble tous les objets [TextHandler](#texthandler) dans un seul [TextHandlers](#texthandlers).+```pycon+>>> page.css('.price::text').re(r'[\d.]+')+['10.99', '20.99', '15.99']+>>> page.css('.product h3::text').re(r'Product (\d+)')+['1', '2', '3']+```+Avec `search`, vous pouvez rechercher parmi les objets [Selector](#selector) de la liste. Passez une fonction qui reçoit un [Selector](#selector) comme premier argument et renvoie True ou False. La mĂ©thode renvoie le premier [Selector](#selector) qui remplit la condition, ou `None` sâil nây en a aucun.++```pycon+>>> product = page.css('.product').search(lambda p: p.css('.price::text').get() == '$20.99')+>>> product.css('h3::text').get()+'Product 2'+```+Vous pouvez aussi utiliser `filter`. Il reçoit une fonction comme `search`, mais renvoie un `Selectors` contenant tous les objets [Selector](#selector) qui remplissent la condition.++```pycon+>>> products = page.css('.product').filter(lambda p: float(p.css('.price::text').re_first(r'[\d.]+')) > 15)+>>> products.css('h3::text').getall()+['Product 2', 'Product 3']+```+Vous pouvez accĂ©der au premier ou au dernier Ă©lĂ©ment sans risquer dâerreur dâindice :+```python+>>> page.css('.product').first # First Selector or None+<data='<article class="product" data-id="1"><h3...'>+>>> page.css('.product').last # Last Selector or None+<data='<article class="product" data-id="3"><h3...'>+>>> page.css('.nonexistent').first # Returns None instead of raising IndexError+```++Pour connaĂźtre le nombre dâobjets [Selector](#selector) dans un [Selectors](#selectors), faites ceci :+```python+page.css('.product').length+```+Cela Ă©quivaut Ă Â :+```python+len(page.css('.product'))+```+Oui, comme en JavaScript :)++## TextHandler {#texthandler}+Cette classe est importante : les mĂ©thodes et propriĂ©tĂ©s qui renvoient une chaĂźne utilisent `TextHandler`. Celles qui renvoient une liste de chaĂźnes utilisent [TextHandlers](#texthandlers).++TextHandler hĂ©rite de la chaĂźne standard de Python et accepte donc toutes ses opĂ©rations. Pourquoi lui donner un autre nom ?++Parce quâelle ajoute des mĂ©thodes et propriĂ©tĂ©s absentes des chaĂźnes ordinaires. Comme elle est utilisĂ©e pour le texte dans toute la bibliothĂšque, vous pouvez combiner ces fonctions pour Ă©crire du code plus court et plus clair. Vous pouvez aussi lâimporter et lâutiliser avec nâimporte quelle chaĂźne, comme nous le verrons [plus loin](../development/scrapling_custom_types.md).+### Utilisation {#usage}+Les opĂ©rations comme prendre une tranche, accĂ©der par indice ou appeler `split`, `replace` et `strip` renvoient un nouveau `TextHandler`. Vous pouvez donc les enchaĂźner. Si une opĂ©ration renvoie une chaĂźne ordinaire au lieu dâun `TextHandler`, ouvrez un ticket pour que nous lâadaptions aussi.++Commençons par `re` et `re_first`. Ce sont les mĂȘmes mĂ©thodes que dans [Selector](#selector), [Selectors](#selectors) et [TextHandlers](#texthandlers), avec les mĂȘmes arguments.++- `re` reçoit une expression rĂ©guliĂšre sous forme de chaĂźne ou dĂ©jĂ compilĂ©e comme premier argument. Il recherche toutes les correspondances et les renvoie dans un [TextHandlers](#texthandlers). `re_first` accepte les mĂȘmes arguments, mais ne renvoie que la premiĂšre correspondance sous forme de `TextHandler`.++ Les arguments suivants sont aussi disponibles :++ - **replace_entities** : remplace les rĂ©fĂ©rences dâentitĂ©s par les caractĂšres correspondants. ActivĂ© par dĂ©faut.+ - **clean_match** : ignore les caractĂšres dâespacement, y compris les espaces consĂ©cutifs, lors de la comparaison. DĂ©sactivĂ© par dĂ©faut.+ - **case_sensitive** : distingue les majuscules des minuscules. ActivĂ© par dĂ©faut. Si vous le dĂ©sactivez, lâexpression rĂ©guliĂšre est compilĂ©e sans cette distinction.++ Nous avons dĂ©jĂ vu ces exemples. Ils renvoient [TextHandlers](#texthandlers) parce quâils utilisent `re` :+ ```pycon+ >>> page.css('.price::text').re(r'[\d.]+')+ ['10.99', '20.99', '15.99']+ >>> page.css('.product h3::text').re(r'Product (\d+)')+ ['1', '2', '3']+ ```+ Pour montrer les autres arguments, nous utiliserons une chaĂźne diffĂ©rente dans chaque exemple :+ ```python+ >>> from scrapling import TextHandler+ >>> test_string = TextHandler('hi there') # Hence the two spaces+ >>> test_string.re('hi there')+ >>> test_string.re('hi there', clean_match=True) # Using `clean_match` will clean the string before matching the regex+ ['hi there']++ >>> test_string2 = TextHandler('Oh, Hi Mark')+ >>> test_string2.re_first('oh, hi Mark')+ >>> test_string2.re_first('oh, hi Mark', case_sensitive=False) # Hence disabling `case_sensitive`+ 'Oh, Hi Mark'++ # Mixing arguments+ >>> test_string.re('hi there', clean_match=True, case_sensitive=False)+ ['hi there']+ ```+ Utiliser `TextHandler` partout a un autre avantage : comme `html_content` renvoie un `TextHandler`, vous pouvez appliquer des expressions rĂ©guliĂšres directement au HTML :+ ```python+ >>> page.html_content.re('div class=".*">(.*)</div')+ ['In stock: 5', 'In stock: 3', 'Out of stock']+ ```++- `.json()` tente de convertir rapidement le contenu en objet JSON. Si ce nâest pas possible, il produit une erreur :+ ```python+ >>> page.css('#page-data::text').get()+ '\n {\n "lastUpdated": "2024-09-22T10:30:00Z",\n "totalProducts": 3\n }\n '+ >>> page.css('#page-data::text').get().json()+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}+ ```+ Si vous nâindiquez pas de nĆud de texte ou dâattribut lors de la sĂ©lection, le contenu textuel de lâĂ©lĂ©ment est utilisĂ© automatiquement :+ ```python+ >>> page.css('#page-data')[0].json()+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}+ ```+ La classe [Selector](#selector) ajoute un dĂ©tail. Supposons que nous travaillions sur cette page :+ ```html+ <html>+ <body>+ <div>+ <script id="page-data" type="application/json">+ {+ "lastUpdated": "2024-09-22T10:30:00Z",+ "totalProducts": 3+ }+ </script>+ </div>+ </body>+ </html>+ ```+ [Selector](#selector) possĂšde la mĂ©thode `get_all_text`, qui renvoie un `TextHandler`.<br/><br/>+ Si vous faites ceci :+ ```python+ >>> page.css('div::text').get().json()+ ```+ Vous obtenez une erreur, car le `div` nâa pas de texte direct Ă convertir en JSON. Il nâa mĂȘme aucun texte direct.<br/><br/>+ Dans ce cas, utilisez `get_all_text` :+ ```python+ >>> page.css('div')[0].get_all_text(ignore_tags=[]).json()+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}+ ```+ Jâai utilisĂ© `ignore_tags` parce que sa valeur par dĂ©faut est `('script', 'style',)`.<br/><br/>+ Un autre cas liĂ© se prĂ©sente avec un fetcher. Supposons que vous receviez cette rĂ©ponse JSON :+ ```python+ >>> page = Selector("""{"some_key": "some_value"}""")+ ```+ Comme [Selector](#selector) est conçu pour les pages HTML, il traite ce contenu comme du HTML incomplet et le corrige. Avec `html_content`, vous obtenez ceci :+ ```python+ >>> page.html_content+ '<html><body><p>{"some_key": "some_value"}</p></body></html>'+ ```+ Ici, vous pouvez utiliser `json` directement :+ ```python+ >>> page.json()+ {'some_key': 'some_value'}+ ```+ Vous vous demandez peut-ĂȘtre comment cela fonctionne puisque `html` nâa pas de texte direct.<br/>+ Pour les rĂ©ponses telles que JSON, [Selector](#selector) conserve une copie du contenu brut. Quand vous appelez `.json()`, il essaie dâabord de convertir cette copie. Si elle nâexiste pas, comme pour les Ă©lĂ©ments internes, il utilise le texte direct de lâĂ©lĂ©ment. Sâil nây en a pas non plus, il appelle `get_all_text`.<br/>++- `.clean()` supprime les caractĂšres dâespacement et les espaces consĂ©cutifs, puis renvoie un nouveau `TextHandler` :+```python+>>> TextHandler('\n wonderful idea, \reh?').clean()+'wonderful idea, eh?'+```+Vous pouvez aussi passer `remove_entities` pour que `clean` remplace les entitĂ©s HTML par les caractĂšres correspondants.++- `.sort()` trie les caractĂšres dâune chaĂźne, comme pour une liste :+```python+>>> TextHandler('acb').sort()+'abc'+```+Ou dans lâordre inverse :+```python+>>> TextHandler('acb').sort(reverse=True)+'cba'+```++Dâautres mĂ©thodes et propriĂ©tĂ©s seront ajoutĂ©es au fil du temps. Retenez que cette classe remplace les chaĂźnes ordinaires dans presque toute la bibliothĂšque.++## TextHandlers {#texthandlers}+Cette classe suit une idĂ©e similaire Ă [Selectors](#selectors) et [Selector](#selector). Elle hĂ©rite des opĂ©rations des listes ordinaires et ajoute `re` et `re_first`.++Ici, `re_first` exĂ©cute `re` sur chaque [TextHandler](#texthandler) et renvoie le premier rĂ©sultat, ou `None`. Le reste fonctionne comme nous lâavons vu. Dâautres mĂ©thodes seront ajoutĂ©es avec le temps.++## AttributesHandler {#attributeshandler}+Câest une version en lecture seule du dictionnaire `dict` de Python. Elle stocke les attributs de chaque Ă©lĂ©ment ou objet [Selector](#selector).+```python+>>> print(page.find('script').attrib)+{'id': 'page-data', 'type': 'application/json'}+>>> type(page.find('script').attrib).__name__+'AttributesHandler'+```+La lecture seule permet dâutiliser moins de ressources quâun dictionnaire ordinaire. Les mĂ©thodes et propriĂ©tĂ©s restent les mĂȘmes, sauf celles qui modifient les donnĂ©es.++Deux fonctions simples sont ajoutĂ©es :++- La mĂ©thode `search_values` :++ Dans un dictionnaire, vous pouvez utiliser `dict.get("key_name")` pour rechercher une clĂ©. Rechercher les valeurs demande plus de code. Cette mĂ©thode le fait pour vous : elle recherche dans les valeurs des attributs et renvoie un dictionnaire pour chaque correspondance.++ Un exemple simple :+ ```python+ >>> for i in page.find('script').attrib.search_values('page-data'):+ print(i)+ {'id': 'page-data'}+ ```+ Elle accepte aussi `partial` pour rechercher une partie de la valeur :+ ```python+ >>> for i in page.find('script').attrib.search_values('page', partial=True):+ print(i)+ {'id': 'page-data'}+ ```+ Un cas plus courant serait de la combiner avec `find_all` pour trouver les Ă©lĂ©ments ayant une valeur prĂ©cise dans leurs attributs :+ ```python+ >>> page.find_all(lambda element: list(element.attrib.search_values('product')))+ [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]+ ```+ Tous ces Ă©lĂ©ments ont 'product' comme valeur de `class`.++ Jâai utilisĂ© `list` parce que `search_values` renvoie un gĂ©nĂ©rateur. Sans conversion en liste, la condition vaudrait `True` pour tous les Ă©lĂ©ments.++- La propriĂ©tĂ© `json_string` :++ Elle convertit les attributs en chaĂźne JSON. Si la conversion est impossible, elle produit une erreur.++ ```python+ >>>page.find('script').attrib.json_string+ b'{"id":"page-data","type":"application/json"}'+ ```\ No newline at end of filediff --git a/docs/locales/fr/parsing/selection.md b/docs/locales/fr/parsing/selection.mdnew file mode 100644index 0000000..affdc53--- /dev/null+++ b/docs/locales/fr/parsing/selection.md@@ -0,0 +1,521 @@+---+title: "Extrayez des donnĂ©es HTML avec CSS, XPath, le texte et les regex"+description: "SĂ©lectionnez des Ă©lĂ©ments HTML avec CSS, XPath, le texte et les regex. Trouvez des Ă©lĂ©ments similaires et extrayez des donnĂ©es avec des exemples Scrapling."+---++# Rechercher des Ă©lĂ©ments {#querying-elements}+La classe `Selector` analyse du HTML. Ce choix vient du fait que la fonction adaptative ne fonctionne pas avec XML. Pour les flux XML, RSS ou Atom, utilisez [XMLFeedSpider](../spiders/generic-templates.md#xmlfeedspider), qui utilise un parser XML et vous fournit directement chaque nĆud du flux.++Scrapling propose cinq grandes façons de rechercher des Ă©lĂ©ments :++1. Les sĂ©lecteurs CSS3.+2. Les sĂ©lecteurs XPath.+3. Les filtres ou conditions.+4. Un texte prĂ©cis dans le contenu.+5. Une expression rĂ©guliĂšre qui correspond au contenu.++Il existe dâautres façons indirectes de trouver des Ă©lĂ©ments, mais nous allons dĂ©tailler les principales. Nous verrons aussi une fonction utile : trouver des Ă©lĂ©ments similaires Ă un Ă©lĂ©ment dĂ©jĂ connu. Vous pouvez aller directement Ă [cette section](#finding-similar-elements).++Si vous dĂ©butez en web scraping, avez peu dâexpĂ©rience avec les sĂ©lecteurs et voulez commencer rapidement, je vous conseille les mĂ©thodes `find`/`find_all` [ici](#filters-based-searching).++## SĂ©lecteurs CSS et XPath {#cssxpath-selectors}++### Que sont les sĂ©lecteurs CSS ? {#what-are-css-selectors}+[CSS](https://en.wikipedia.org/wiki/CSS) est un langage qui applique des styles aux documents HTML. Ses sĂ©lecteurs indiquent quels Ă©lĂ©ments reçoivent chaque style.++Scrapling prend en charge les sĂ©lecteurs CSS3 selon la [spĂ©cification du W3C](http://www.w3.org/TR/2011/REC-css3-selectors-20110929/). Il utilise `cssselect` pour cela. Consultez les [sĂ©lecteurs pris en charge par cssselect](https://cssselect.readthedocs.io/en/latest/#supported-selectors), y compris les pseudo-fonctions et pseudo-Ă©lĂ©ments.++Scrapling ajoute aussi quelques pseudo-Ă©lĂ©ments non standard :++* Pour sĂ©lectionner des nĆuds de texte, utilisez ``::text``.+* Pour sĂ©lectionner la valeur dâun attribut, utilisez ``::attr(name)``, oĂč name est le nom de lâattribut.++Si vous connaissez Scrapy ou Parsel, vous retrouverez la mĂȘme logique. Pas besoin dâapprendre une nouvelle façon dâutiliser les sĂ©lecteurs :)++Pour sĂ©lectionner avec CSS, utilisez `css`, qui renvoie `Selectors`. Utilisez `[0]` pour obtenir le premier Ă©lĂ©ment, ou `.get()` / `.getall()` pour extraire les valeurs des pseudo-sĂ©lecteurs de texte et dâattributs.++### Que sont les sĂ©lecteurs XPath ? {#what-are-xpath-selectors}+[XPath](https://en.wikipedia.org/wiki/XPath) est un langage de sĂ©lection de nĆuds dans les documents XML, qui fonctionne aussi avec HTML. Cet [aide-mĂ©moire](https://devhints.io/xpath) est utile pour apprendre [XPath](https://en.wikipedia.org/wiki/XPath). Scrapling propose XPath directement grĂące Ă [lxml](https://lxml.de/).++Comme pour CSS, les utilisateurs de Scrapy ou Parsel retrouveront la mĂȘme logique. Scrapling nâinclut toutefois pas la fonction XPath `has-class`. Il propose Ă la place la mĂ©thode `has_class` pour vĂ©rifier les classes des Ă©lĂ©ments trouvĂ©s.++Pour sĂ©lectionner avec XPath, utilisez `xpath`. Cette mĂ©thode suit la mĂȘme logique que la mĂ©thode CSS ci-dessus.++> Les mĂ©thodes `css` et `xpath` ont dâautres arguments liĂ©s Ă la fonction adaptative. Nous les expliquerons dans la page consacrĂ©e Ă cette fonction.++### Exemples de sĂ©lecteurs {#selectors-examples}+Voici quelques exemples Ă©quivalents avec CSS et XPath.++SĂ©lectionnez tous les Ă©lĂ©ments de classe `product` :+```python+products = page.css('.product')+products = page.xpath('//*[@class="product"]')+```+!!! info "Note"++ Le XPath ne sera pas prĂ©cis si lâĂ©lĂ©ment a une autre classe. **Il vaut mieux utiliser CSS pour sĂ©lectionner par classe.**++SĂ©lectionnez le premier Ă©lĂ©ment de classe `product` :+```python+product = page.css('.product')[0]+product = page.xpath('//*[@class="product"]')[0]+```+Obtenez le texte du premier Ă©lĂ©ment portant la balise `h1` :+```python+title = page.css('h1::text').get()+title = page.xpath('//h1//text()').get()+```+Cela revient Ă faire ceci :+```python+title = page.css('h1')[0].text+title = page.xpath('//h1')[0].text+```+Obtenez lâattribut `href` du premier Ă©lĂ©ment portant la balise `a` :+```python+link = page.css('a::attr(href)').get()+link = page.xpath('//a/@href').get()+```+SĂ©lectionnez le texte du premier `h1` qui contient `Phone` et se trouve dans un Ă©lĂ©ment de classe `product` :+```python+title = page.css('.product h1:contains("Phone")::text').get()+title = page.xpath('//*[@class="product"]//h1[contains(text(),"Phone")]/text()').get()+```+Vous pouvez imbriquer et enchaĂźner les sĂ©lecteurs tant quâils renvoient des rĂ©sultats :+```python+page.css('.product')[0].css('h1:contains("Phone")::text').get()+page.xpath('//*[@class="product"]')[0].xpath('.//h1[contains(text(),"Phone")]/text()').get()+page.xpath('//*[@class="product"]')[0].css('h1:contains("Phone")::text').get()+```+Utilisez `.//` pour que XPath recherche Ă partir de lâĂ©lĂ©ment actuel. Si le sĂ©lecteur commence par `//`, il recherche dans tout le document, mĂȘme aprĂšs la sĂ©lection dâun produit.++Autre exemple :++Tous les liens contenant 'image' dans leur attribut 'href' :+```python+links = page.css('a[href*="image"]')+links = page.xpath('//a[contains(@href, "image")]')+for index, link in enumerate(links):+ link_value = link.attrib['href'] # Cleaner than link.css('::attr(href)').get()+ link_text = link.text+ print(f'Link number {index} points to this url {link_value} with text content as "{link_text}"')+```++## SĂ©lection par contenu textuel {#text-content-selection}+Scrapling permet de rechercher dans le texte direct de chaque Ă©lĂ©ment de deux façons :++1. Avec `find_by_text`, recherchez les Ă©lĂ©ments dont le texte direct contient le texte donnĂ©. La mĂ©thode propose plusieurs options.+2. Avec `find_by_regex`, recherchez les Ă©lĂ©ments dont le texte direct correspond Ă une expression rĂ©guliĂšre. Cette mĂ©thode propose aussi plusieurs options.++Si vous maĂźtrisez les expressions rĂ©guliĂšres, vous pouvez faire avec `find_by_regex` ce que fait `find_by_text`. Nous proposons les deux mĂ©thodes pour faciliter leur utilisation par tous.++Le premier argument de `find_by_text` est le texte recherchĂ©. Celui de `find_by_regex` est lâexpression rĂ©guliĂšre. Les deux mĂ©thodes partagent ces arguments :++* **first_match** : si sa valeur est `True`, la valeur par dĂ©faut, renvoie uniquement le premier rĂ©sultat.+* **case_sensitive** : si sa valeur est `True`, distingue les majuscules des minuscules.+* **clean_match** : si sa valeur est `True`, remplace les caractĂšres dâespacement et les espaces consĂ©cutifs par une seule espace avant la comparaison.++Par dĂ©faut, `find_by_text` recherche une correspondance exacte. Le texte de lâĂ©lĂ©ment doit contenir UNIQUEMENT le texte donnĂ©. Pour changer ce comportement, utilisez cet argument supplĂ©mentaire :++* **partial** : si activĂ©, `find_by_text` renvoie les Ă©lĂ©ments contenant le texte donnĂ©, mĂȘme sâils contiennent aussi autre chose.++!!! abstract "Note"++ `find_by_regex` accepte une chaĂźne ordinaire ou une expression rĂ©guliĂšre compilĂ©e comme premier argument. Nous le verrons dans les exemples.++### Rechercher des Ă©lĂ©ments similaires {#finding-similar-elements}+Lâune des fonctions les plus utiles de Scrapling consiste Ă rechercher des Ă©lĂ©ments similaires Ă un Ă©lĂ©ment dĂ©jĂ trouvĂ©. Elle sâinspire dâAutoScraper, mais fonctionne ici avec les Ă©lĂ©ments obtenus par nâimporte quelle mĂ©thode. Elle sert souvent aprĂšs une recherche par texte, comme dans AutoScraper, dâoĂč sa prĂ©sentation dans cette section.++Comment fonctionne-t-elle ?++Supposons que vous trouviez un produit par son titre et souhaitiez extraire les autres produits du mĂȘme tableau ou conteneur. Appelez `.find_similar()` sur cet Ă©lĂ©ment. Scrapling effectue alors ces opĂ©rations :++1. Recherche tous les Ă©lĂ©ments situĂ©s Ă la mĂȘme profondeur dans lâarbre DOM.+2. Ăcarte ceux dont le nom de balise, le nom de balise du parent ou celui du grand-parent diffĂšre.+3. Les Ă©lĂ©ments restants sont trĂšs probablement ceux recherchĂ©s. Pour finir, Scrapling compare leurs attributs et Ă©carte ceux qui ne ressemblent pas assez Ă lâĂ©lĂ©ment de dĂ©part. Vous pouvez rĂ©gler le pourcentage de ressemblance, mais je conseille de garder la valeur par dĂ©faut tant quâelle trouve les Ă©lĂ©ments souhaitĂ©s.++Cela fait plusieurs Ă©tapes, mais elles aident Ă comprendre la mĂ©thode. Nous verrons des exemples dans la section suivante. Voici les arguments disponibles :++* **similarity_threshold** : rĂšgle la comparaison des attributs Ă lâĂ©tape 3. La valeur par dĂ©faut est 0,2 : les attributs doivent ĂȘtre au moins 20 % similaires. La valeur 0 dĂ©sactive cette vĂ©rification. Avant de la changer, regardez ce que font les autres arguments.+* **ignore_attributes** : noms des attributs ignorĂ©s dans la derniĂšre comparaison. La valeur par dĂ©faut est `('href', 'src',)`, car les URL peuvent beaucoup varier entre les Ă©lĂ©ments et ne sont pas une rĂ©fĂ©rence fiable.+* **match_text** : si sa valeur est `True`, le texte de lâĂ©lĂ©ment entre aussi dans la comparaison de lâĂ©tape 3. Ce nâest gĂ©nĂ©ralement pas nĂ©cessaire, mais cela dĂ©pend du cas.++Passons aux exemples.++### Exemples {#examples}+Voici des exemples de recherche par texte et par expression rĂ©guliĂšre.++Jâutiliserai la classe `Fetcher`, qui sera expliquĂ©e en dĂ©tail plus loin.+```python+from scrapling.fetchers import Fetcher+page = Fetcher.get('https://books.toscrape.com/index.html')+```+Trouvez le premier Ă©lĂ©ment dont le texte correspond exactement au texte donné :+```python+>>> page.find_by_text('Tipping the Velvet')+<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>+```+Combinez avec `page.urljoin` pour convertir le `href` relatif en URL complĂšte :+```python+>>> page.find_by_text('Tipping the Velvet').attrib['href']+'catalogue/tipping-the-velvet_999/index.html'+>>> page.urljoin(page.find_by_text('Tipping the Velvet').attrib['href'])+'https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html'+```+Obtenez toutes les correspondances sâil y en a plusieurs. Le rĂ©sultat est une liste :+```python+>>> page.find_by_text('Tipping the Velvet', first_match=False)+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]+```+Obtenez tous les Ă©lĂ©ments contenant le mot `the`, avec une correspondance partielle :+```python+>>> results = page.find_by_text('the', partial=True, first_match=False)+>>> [i.text for i in results]+['A Light in the ...',+ 'Tipping the Velvet',+ 'The Requiem Red',+ 'The Dirty Little Secrets ...',+ 'The Coming Woman: A ...',+ 'The Boys in the ...',+ 'The Black Maria',+ 'Mesaerion: The Best Science ...',+ "It's Only the Himalayas"]+```+La recherche ne distingue pas les majuscules des minuscules. Elle inclut donc `The` en plus de `the`. Limitons les rĂ©sultats Ă `the` :+```python+>>> results = page.find_by_text('the', partial=True, first_match=False, case_sensitive=True)+>>> [i.text for i in results]+['A Light in the ...',+ 'Tipping the Velvet',+ 'The Boys in the ...',+ "It's Only the Himalayas"]+```+Obtenez le premier Ă©lĂ©ment dont le texte correspond Ă cette expression rĂ©guliĂšre de prix :+```python+>>> page.find_by_regex(r'ÂŁ[\d\.]+')+<data='<p class="price_color">ÂŁ51.77</p>' parent='<div class="product_price"> <p class="pr...'>+>>> page.find_by_regex(r'ÂŁ[\d\.]+').text+'ÂŁ51.77'+```+Vous pouvez aussi passer une expression rĂ©guliĂšre compilĂ©e. Scrapling dĂ©tecte le type fourni et lâutilise :+```python+>>> import re+>>> regex = re.compile(r'ÂŁ[\d\.]+')+>>> page.find_by_regex(regex)+<data='<p class="price_color">ÂŁ51.77</p>' parent='<div class="product_price"> <p class="pr...'>+>>> page.find_by_regex(regex).text+'ÂŁ51.77'+```+Obtenez tous les Ă©lĂ©ments correspondant Ă lâexpression rĂ©guliĂšre :+```python+>>> page.find_by_regex(r'ÂŁ[\d\.]+', first_match=False)+[<data='<p class="price_color">ÂŁ51.77</p>' parent='<div class="product_price"> <p class="pr...'>,+ <data='<p class="price_color">ÂŁ53.74</p>' parent='<div class="product_price"> <p class="pr...'>,+ <data='<p class="price_color">ÂŁ50.10</p>' parent='<div class="product_price"> <p class="pr...'>,+ <data='<p class="price_color">ÂŁ47.82</p>' parent='<div class="product_price"> <p class="pr...'>,+ ...]+```+Et ainsi de suite...++Trouvez les Ă©lĂ©ments similaires Ă lâĂ©lĂ©ment actuel par leur position et leurs attributs. Dans ce cas, ignorez lâattribut 'title' lors de la comparaison :+```python+>>> element = page.find_by_text('Tipping the Velvet')+>>> element.find_similar(ignore_attributes=['title'])+[<data='<a href="catalogue/a-light-in-the-attic_...' parent='<h3><a href="catalogue/a-light-in-the-at...'>,+ <data='<a href="catalogue/soumission_998/index....' parent='<h3><a href="catalogue/soumission_998/in...'>,+ <data='<a href="catalogue/sharp-objects_997/ind...' parent='<h3><a href="catalogue/sharp-objects_997...'>,+...]+```+Il y a 19 Ă©lĂ©ments, pas 20, car lâĂ©lĂ©ment actuel nâest pas inclus dans les rĂ©sultats.+```python+>>> len(element.find_similar(ignore_attributes=['title']))+19+```+Obtenez lâattribut `href` de tous les Ă©lĂ©ments similaires :+```python+>>> [+ element.attrib['href']+ for element in element.find_similar(ignore_attributes=['title'])+]+['catalogue/a-light-in-the-attic_1000/index.html',+ 'catalogue/soumission_998/index.html',+ 'catalogue/sharp-objects_997/index.html',+ ...]+```+Voici un exemple un peu plus complet : extraire toutes les donnĂ©es des livres en partant de cet Ă©lĂ©ment.+```python+>>> first_product = element.parent.parent+>>> for product in [first_product, *first_product.find_similar()]:+ print({+ "name": product.css('h3 a::text').get(),+ "price": product.css('.price_color')[0].re_first(r'[\d\.]+'),+ "stock": product.css('.availability::text').getall()[-1].clean()+ })+{'name': 'Tipping the Velvet', 'price': '53.74', 'stock': 'In stock'}+{'name': 'A Light in the ...', 'price': '51.77', 'stock': 'In stock'}+{'name': 'Soumission', 'price': '50.10', 'stock': 'In stock'}+{'name': 'Sharp Objects', 'price': '47.82', 'stock': 'In stock'}+...+```+### Exemples avancĂ©s {#advanced-examples}+Voyons des cas plus complets dâutilisation de `find_similar`.++Extraire les produits dâune boutique :+```python+def extract_product_grid(page):+ # Find the first product card+ first_product = page.find_by_text('Add to Cart').find_ancestor(+ lambda e: e.has_class('product-card')+ )++ # Find similar product cards+ products = [first_product, *first_product.find_similar()]++ return [+ {+ 'name': p.css('h3::text').get(),+ 'price': p.css('.price::text').re_first(r'\d+\.\d{2}'),+ 'stock': 'In stock' in p.get_all_text(),+ 'rating': p.css('.rating')[0].attrib.get('data-rating')+ }+ for p in products+ ]+```+Extraire les lignes dâun tableau :+```python+def extract_table_data(page):+ # Find the first data row+ first_row = page.css('table tbody tr')[0]++ # Find similar rows+ rows = [first_row, *first_row.find_similar()]++ return [+ {+ 'column1': row.css('td:nth-child(1)::text').get(),+ 'column2': row.css('td:nth-child(2)::text').get(),+ 'column3': row.css('td:nth-child(3)::text').get()+ }+ for row in rows+ ]+```+Extraire les champs dâun formulaire :+```python+def extract_form_fields(page):+ # Find first form field container+ first_field = page.css('input')[0].find_ancestor(+ lambda e: e.has_class('form-field')+ )++ # Find similar field containers+ fields = [first_field, *first_field.find_similar()]++ return [+ {+ 'label': f.css('label::text').get(),+ 'type': f.css('input')[0].attrib.get('type'),+ 'required': 'required' in f.css('input')[0].attrib+ }+ for f in fields+ ]+```+Extraire les avis dâun site :+```python+def extract_reviews(page):+ # Find first review+ first_review = page.find_by_text('Great product!')+ review_container = first_review.find_ancestor(+ lambda e: e.has_class('review')+ )++ # Find similar reviews+ all_reviews = [review_container, *review_container.find_similar()]++ return [+ {+ 'text': r.css('.review-text::text').get(),+ 'rating': r.attrib.get('data-rating'),+ 'author': r.css('.reviewer::text').get()+ }+ for r in all_reviews+ ]+```+## Recherche par filtres {#filters-based-searching}+Cette mĂ©thode est lâune des meilleures façons de rechercher des Ă©lĂ©ments dans Scrapling. Elle est puissante et gĂ©nĂ©ralement plus facile Ă apprendre que les sĂ©lecteurs pour les dĂ©butants en web scraping.++InspirĂ©es de `find_all` de BeautifulSoup, les mĂ©thodes `find_all` et `find` acceptent plusieurs filtres et recherchent les Ă©lĂ©ments qui remplissent toutes les conditions.++Chaque type dâargument est interprĂ©tĂ© ainsi :++* Une chaĂźne est un nom de balise.+* Un itĂ©rable, comme List, Tuple ou Set, contient des noms de balises.+* Un dictionnaire associe des noms dâattributs HTML Ă leurs valeurs.+* Une expression rĂ©guliĂšre filtre le contenu, comme `find_by_regex`.+* Une fonction filtre les Ă©lĂ©ments.+* Un argument nommĂ© reprĂ©sente un attribut HTML et sa valeur.++La mĂ©thode rassemble tous les arguments et applique les filtres Ă la suite. Chaque filtre reçoit les rĂ©sultats du prĂ©cĂ©dent.++Les filtres sâappliquent aux Ă©lĂ©ments de la page ou de lâĂ©lĂ©ment actuel dans cet ordre :++1. Recherche les Ă©lĂ©ments portant les noms de balises indiquĂ©s.+2. Recherche ceux qui correspondent Ă tous les attributs indiquĂ©s. Si un filtre a dĂ©jĂ Ă©tĂ© appliquĂ©, seuls ses rĂ©sultats sont examinĂ©s.+3. Recherche ceux qui correspondent Ă toutes les expressions rĂ©guliĂšres. Si des filtres ont dĂ©jĂ Ă©tĂ© appliquĂ©s, seuls leurs rĂ©sultats sont examinĂ©s.+4. Recherche ceux qui remplissent toutes les conditions des fonctions. Si des filtres ont dĂ©jĂ Ă©tĂ© appliquĂ©s, seuls leurs rĂ©sultats sont examinĂ©s.++!!! note "Notes"++ 1. Le processus commence par le premier filtre disponible dans lâordre ci-dessus. Sans noms de balises, mais avec des attributs, il commence Ă lâĂ©tape 2.+ 2. Lâordre dans lequel vous passez les arguments ne compte pas. Seul lâordre expliquĂ© ci-dessus est utilisĂ©.++Les exemples permettent dây voir plus clair :)++### Exemples {#examples_1}+```python+from scrapling.fetchers import Fetcher+page = Fetcher.get('https://quotes.toscrape.com/')+```+Trouvez tous les Ă©lĂ©ments portant la balise `div` :+```python+>>> page.find_all('div')+[<data='<div class="container"> <div class="row...' parent='<body> <div class="container"> <div clas...'>,+ <data='<div class="row header-box"> <div class=...' parent='<div class="container"> <div class="row...'>,+...]+```+Trouvez tous les div dont la classe est `quote` :+```python+>>> page.find_all('div', class_='quote')+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+...]+```+La mĂȘme chose que prĂ©cĂ©demment :+```python+>>> page.find_all('div', {'class': 'quote'})+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+...]+```+Trouvez tous les Ă©lĂ©ments dont la classe est `quote` :+```python+>>> page.find_all({'class': 'quote'})+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+...]+```+Trouvez tous les div dont la classe est `quote` et qui contiennent un Ă©lĂ©ment `.text` avec le mot 'world' :+```python+>>> page.find_all('div', {'class': 'quote'}, lambda e: "world" in e.css('.text::text').get())+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>]+```+Trouvez tous les Ă©lĂ©ments qui ont des enfants :+```python+>>> page.find_all(lambda element: len(element.children) > 0)+[<data='<html lang="en"><head><meta charset="UTF...'>,+ <data='<head><meta charset="UTF-8"><title>Quote...' parent='<html lang="en"><head><meta charset="UTF...'>,+ <data='<body> <div class="container"> <div clas...' parent='<html lang="en"><head><meta charset="UTF...'>,+...]+```+Trouvez tous les Ă©lĂ©ments dont le texte contient le mot 'world' :+```python+>>> page.find_all(lambda element: "world" in element.text)+[<data='<span class="text" itemprop="text">âThe...' parent='<div class="quote" itemscope itemtype="h...'>,+ <data='<a class="tag" href="/tag/world/page/1/"...' parent='<div class="tags"> Tags: <meta class="ke...'>]+```+Trouvez tous les span correspondant Ă lâexpression rĂ©guliĂšre :+```python+>>> page.find_all('span', re.compile(r'world'))+[<data='<span class="text" itemprop="text">âThe...' parent='<div class="quote" itemscope itemtype="h...'>]+```+Trouvez les div et span de classe 'quote'. Aucun span ne correspond, donc seuls des div sont renvoyĂ©s :+```python+>>> page.find_all(['div', 'span'], {'class': 'quote'})+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,+...]+```+Combinez plusieurs filtres :+```python+>>> page.find_all({'itemtype':"http://schema.org/CreativeWork"}, 'div').css('.author::text').getall()+['Albert Einstein',+ 'J.K. Rowling',+...]+```+Une astuce supplĂ©mentaire : trouvez les Ă©lĂ©ments dont lâattribut `href` se termine par 'Einstein' :+```python+>>> page.find_all({'href$': 'Einstein'})+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>]+```+Autre astuce : trouvez les Ă©lĂ©ments dont lâattribut `href` contient '/author/' :+```python+>>> page.find_all({'href*': '/author/'})+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,+ <data='<a href="/author/J-K-Rowling">(about)</a...' parent='<span>by <small class="author" itemprop=...'>,+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,+...]+```+Et ainsi de suite...++## GĂ©nĂ©rer des sĂ©lecteurs {#generating-selectors}+Vous pouvez gĂ©nĂ©rer des sĂ©lecteurs CSS et XPath pour tout Ă©lĂ©ment, puis les rĂ©utiliser ici ou ailleurs. Peu importe la mĂ©thode utilisĂ©e pour trouver lâĂ©lĂ©ment.++GĂ©nĂ©rez un sĂ©lecteur CSS court pour `url_element`. Si ce nâest pas possible, gĂ©nĂ©rez un sĂ©lecteur complet :+```python+>>> url_element = page.find({'href*': '/author/'})+>>> url_element.generate_css_selector+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'+```+GĂ©nĂ©rez un sĂ©lecteur CSS complet pour `url_element`, depuis le dĂ©but de la page :+```python+>>> url_element.generate_full_css_selector+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'+```+GĂ©nĂ©rez un sĂ©lecteur XPath court pour `url_element`. Si ce nâest pas possible, gĂ©nĂ©rez un sĂ©lecteur complet :+```python+>>> url_element.generate_xpath_selector+'//body/div/div[2]/div/div/span[2]/a'+```+GĂ©nĂ©rez un sĂ©lecteur XPath complet pour `url_element`, depuis le dĂ©but de la page :+```python+>>> url_element.generate_full_xpath_selector+'//body/div/div[2]/div/div/span[2]/a'+```+!!! abstract "Note"++ Pour crĂ©er un sĂ©lecteur court, Scrapling cherche un Ă©lĂ©ment unique comme point de dĂ©part, par exemple un Ă©lĂ©ment avec un attribut `id`. Ici, il nây en a pas. Le sĂ©lecteur court et le sĂ©lecteur complet sont donc identiques.++## Utiliser des sĂ©lecteurs avec des expressions rĂ©guliĂšres {#using-selectors-with-regular-expressions}+Comme dans `parsel`/`scrapy`, vous pouvez utiliser `re` et `re_first` pour extraire des donnĂ©es avec des expressions rĂ©guliĂšres. Dans Scrapling, ces mĂ©thodes existent dans presque toutes les classes, comme `Selector`/`Selectors`/`TextHandler` et `TextHandlers`. Vous pouvez donc les utiliser directement sur un Ă©lĂ©ment sans sĂ©lectionner de nĆud de texte au prĂ©alable.++Nous les dĂ©taillerons avec [TextHandler](main_classes.md#texthandler). Pour le moment, voici comment elles fonctionnent :+```python+>>> page.css('.price_color')[0].re_first(r'[\d\.]+')+'51.77'++>>> page.css('.price_color').re_first(r'[\d\.]+')+'51.77'++>>> page.css('.price_color').re(r'[\d\.]+')+['51.77',+ '53.74',+ '50.10',+ '47.82',+ '54.23',+...]++>>> page.css('.product_pod h3 a::attr(href)').re(r'catalogue/(.*)/index.html')+['a-light-in-the-attic_1000',+ 'tipping-the-velvet_999',+ 'soumission_998',+ 'sharp-objects_997',+...]++>>> filtering_function = lambda e: e.parent.tag == 'h3' and e.parent.parent.has_class('product_pod') # As above selector+>>> page.find('a', filtering_function).attrib['href'].re(r'catalogue/(.*)/index.html')+['a-light-in-the-attic_1000']++>>> page.find_by_text('Tipping the Velvet').attrib['href'].re(r'catalogue/(.*)/index.html')+['tipping-the-velvet_999']+```+Et ainsi de suite. Nous expliquerons cela plus en dĂ©tail dans la prochaine page, avec la classe [TextHandler](main_classes.md#texthandler).\ No newline at end of filediff --git a/docs/locales/fr/spiders/advanced.md b/docs/locales/fr/spiders/advanced.mdnew file mode 100644index 0000000..650cb04--- /dev/null+++ b/docs/locales/fr/spiders/advanced.md@@ -0,0 +1,431 @@+---+title: "ContrĂŽlez lâexploration : AutoThrottle, points de reprise, cache et streaming"+description: "ContrĂŽlez la vitesse et la concurrence de lâexploration. DĂ©couvrez le cache, la pause et la reprise, les rĂ©sultats en temps rĂ©el et lâĂ©tat enregistrĂ©."+---++# Usages avancĂ©s {#advanced-usages}++## Introduction {#introduction}++!!! success "Avant de commencer"++ 1. Lisez la page [Premiers pas](getting-started.md) pour apprendre Ă crĂ©er et exĂ©cuter un spider simple.++Cette page explique les fonctions avancĂ©es des spiders : contrĂŽle de la concurrence, pause et reprise, streaming, hooks du cycle de vie, statistiques et journaux.++## ContrĂŽler la concurrence {#concurrency-control}++Le systĂšme de spiders utilise ces attributs de classe pour rĂ©gler le rythme de lâexploration :++| Attribut | Valeur par dĂ©faut | Description |+|----------|-------------------|-------------|+| `concurrent_requests` | `4` | Nombre maximal de requĂȘtes traitĂ©es en mĂȘme temps |+| `concurrent_requests_per_domain` | `0` | Nombre maximal de requĂȘtes simultanĂ©es par domaine. 0 signifie sans limite par domaine |+| `download_delay` | `0.0` | Secondes dâattente avant chaque requĂȘte |+| `robots_txt_obey` | `False` | Respecte les rĂšgles de robots.txt : Disallow, Crawl-delay et Request-rate |++```python+class PoliteSpider(Spider):+ name = "polite"+ start_urls = ["https://example.com"]++ # Be gentle with the server+ concurrent_requests = 4+ concurrent_requests_per_domain = 2+ download_delay = 1.0 # Wait 1 second between requests++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++Quand vous dĂ©finissez `concurrent_requests_per_domain`, chaque domaine a sa propre limite de concurrence, en plus de la limite globale. Vous pouvez ainsi explorer plusieurs domaines avec beaucoup de requĂȘtes au total, sans surcharger chacun dâeux.++!!! tip "Conseil"++ `download_delay` ajoute une attente fixe avant chaque requĂȘte, quel que soit le domaine. Utilisez-le pour limiter simplement le rythme.++## AutoThrottle {#autothrottle}++Choisir un `download_delay` fixe demande des essais : trop court, il risque de provoquer un blocage ; trop long, il ralentit lâexploration. AutoThrottle observe le temps de rĂ©ponse du site et ajuste lâattente pour chaque domaine. Il accĂ©lĂšre avec les serveurs rapides et ralentit avec ceux qui rĂ©pondent lentement ou bloquent les requĂȘtes.++| Attribut | Valeur par dĂ©faut | Description |+|----------|-------------------|-------------|+| `autothrottle_enabled` | `False` | Active lâajustement automatique du dĂ©lai |+| `autothrottle_start_delay` | `5.0` | DĂ©lai utilisĂ© pour la premiĂšre requĂȘte vers un domaine |+| `autothrottle_max_delay` | `60.0` | DĂ©lai maximal autorisĂ© |+| `autothrottle_target_concurrency` | `None` | Nombre de requĂȘtes simultanĂ©es visĂ© par domaine, expliquĂ© ci-dessous |+| `autothrottle_block_backoff` | `True` | Double le dĂ©lai dâun domaine chaque fois quâil bloque une requĂȘte |++```python+class AdaptiveSpider(Spider):+ name = "adaptive"+ start_urls = ["https://example.com"]++ concurrent_requests = 8+ concurrent_requests_per_domain = 1++ autothrottle_enabled = True+ autothrottle_start_delay = 2.0+ autothrottle_max_delay = 30.0++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++AprĂšs chaque rĂ©ponse, le dĂ©lai se rapproche du temps que le serveur a mis Ă rĂ©pondre. Par exemple, avec une rĂ©ponse en 0,5 seconde, le dĂ©lai se stabilise autour de 0,5 seconde, ce qui maintient environ une requĂȘte active. Le nombre visĂ© par domaine est choisi dans cet ordre : `autothrottle_target_concurrency` si vous le dĂ©finissez, sinon `concurrent_requests_per_domain`, sinon 1. Vous nâavez donc gĂ©nĂ©ralement pas besoin de dĂ©finir un objectif distinct : la limite par domaine sert dâobjectif, et le dĂ©lai est divisĂ© par cette valeur. Les hausses brusques du temps de rĂ©ponse sont appliquĂ©es immĂ©diatement, sans ĂȘtre moyennĂ©es. Le spider ralentit dĂšs que le serveur rencontre des difficultĂ©s et nâaccĂ©lĂšre de nouveau que progressivement.++### Ralentir en cas de blocage {#backing-off-when-blocked}++Le temps de rĂ©ponse seul ne permet pas de repĂ©rer les limites de requĂȘtes. Une rĂ©ponse `429`, `403` ou une page de captcha arrive souvent *plus vite* que le vrai contenu. En se basant seulement sur ce temps, le spider accĂ©lĂ©rerait. Câest pourquoi une rĂ©ponse avec un code hors 2xx ou signalĂ©e par `is_blocked()` **double** le dĂ©lai de ce domaine :++```+0.5s -> 1s -> 2s -> 4s -> 8s ... (up to autothrottle_max_delay)+```++Le spider continue de ralentir tant que le site refuse les requĂȘtes. Quand les rĂ©ponses normales reviennent, lâajustement habituel par la moyenne rĂ©duit peu Ă peu lâattente pour se rapprocher de la vitesse rĂ©elle du serveur. Vous nâavez rien Ă redĂ©marrer.++Si une rĂ©ponse `429` ou `503` contient un en-tĂȘte `Retry-After`, le dĂ©lai indiquĂ© est utilisĂ© au lieu du doublement. Les formats numĂ©rique (`Retry-After: 120`) et date HTTP sont tous deux acceptĂ©s.++DĂ©finissez `autothrottle_block_backoff = False` pour dĂ©sactiver ce comportement et rĂ©gler le rythme seulement selon le temps de rĂ©ponse. Dans ce cas, un blocage peut uniquement empĂȘcher le spider dâaccĂ©lĂ©rer.++Vous pouvez consulter le dĂ©lai final de chaque domaine dans les statistiques :++```python+result = AdaptiveSpider().start()+print(result.stats.autothrottle_delays) # {'example.com': 0.62}+```++!!! note "Notes"++ * `download_delay` et les dĂ©lais de robots.txt dĂ©finissent un minimum, mais `autothrottle_max_delay` limite aussi ce minimum. Choisissez un maximum au moins Ă©gal au dĂ©lai configurĂ© ou demandĂ© par robots.txt.<br/>+ * `concurrent_requests_per_domain` a deux rĂŽles : limiter les requĂȘtes actives dâun domaine et servir dâobjectif Ă AutoThrottle. Il nây a donc gĂ©nĂ©ralement pas dâautre objectif Ă dĂ©finir. Il est conseillĂ© de le rĂ©gler, car une requĂȘte en attente occupe une place dans la limite globale. Sans limite par domaine, ces attentes peuvent occuper les places nĂ©cessaires aux autres domaines.<br/>+ * Le temps mesurĂ© inclut toute la rĂ©cupĂ©ration, avec les nouvelles tentatives internes et, pour les sessions de navigateur, le rendu de la page.<br/>+ * `autothrottle_max_delay` limite toutes les attentes, y compris `Retry-After`. Si un site demande une attente plus longue, augmentez `autothrottle_max_delay` pour la respecter.<br/>+ * Les dĂ©lais appris ne sont pas enregistrĂ©s dans les points de reprise. AprĂšs une pause et une reprise, chaque domaine repart de `autothrottle_start_delay`.++## Utiliser uvloop {#using-uvloop}++La mĂ©thode `start()` accepte `use_uvloop` pour utiliser la boucle dâĂ©vĂ©nements plus rapide de [uvloop](https://github.com/MagicStack/uvloop)/[winloop](https://github.com/nicktimko/winloop), si elle est disponible :++```python+result = MySpider().start(use_uvloop=True)+```++Cela peut amĂ©liorer les performances des explorations avec beaucoup dâentrĂ©es et de sorties. Vous devez installer `uvloop` sur Linux/macOS ou `winloop` sur Windows sĂ©parĂ©ment.++## Mettre en pause et reprendre {#pause-resume}++Le spider permet de mettre en pause et de reprendre lâexploration grĂące aux points de reprise. Pour les activer, passez un dossier `crawldir` au constructeur :++```python+spider = MySpider(crawldir="crawl_data/my_spider")+result = spider.start()++if result.paused:+ print("Crawl was paused. Run again to resume.")+else:+ print("Crawl completed!")+```++### Fonctionnement {#how-it-works}++1. **Pause** : appuyez sur `Ctrl+C` pendant lâexploration. Le spider attend la fin des requĂȘtes actives, enregistre les requĂȘtes en attente et les empreintes dĂ©jĂ vues, puis sâarrĂȘte.+2. **ArrĂȘt forcĂ©** : appuyez une seconde fois sur `Ctrl+C` pour arrĂȘter immĂ©diatement, sans attendre les tĂąches actives.+3. **Reprise** : relancez le spider avec le mĂȘme `crawldir`. Il dĂ©tecte le point de reprise, restaure la file et les empreintes dĂ©jĂ vues, puis continue lĂ oĂč il sâĂ©tait arrĂȘtĂ©, sans exĂ©cuter `start_requests()`.+4. **Nettoyage** : quand lâexploration se termine complĂštement, sans rester en pause, les fichiers de reprise sont supprimĂ©s automatiquement.++**Des points de reprise sont aussi enregistrĂ©s pendant lâexploration, toutes les 5 minutes par dĂ©faut.**++Vous pouvez changer lâintervalle ainsi :++```python+# Save checkpoint every 2 minutes+spider = MySpider(crawldir="crawl_data/my_spider", interval=120.0)+```++LâĂ©criture sur disque est atomique pour Ă©viter les fichiers incomplets.++!!! tip "Conseil"++ Avec `start()`, appuyer sur `Ctrl+C` arrĂȘte proprement le spider, mĂȘme si les points de reprise ne sont pas activĂ©s. Appuyer de nouveau sans attendre force lâarrĂȘt immĂ©diat.++### Savoir si vous reprenez une exploration {#knowing-if-youre-resuming}++Le hook `on_start()` reçoit lâindicateur `resuming` :++```python+async def on_start(self, resuming: bool = False):+ if resuming:+ self.logger.info("Resuming from checkpoint!")+ else:+ self.logger.info("Starting fresh crawl")+```++## Mode dĂ©veloppement {#development-mode}++Quand vous ajustez la logique de `parse()`, tĂ©lĂ©charger les pages Ă chaque exĂ©cution prend du temps et envoie des requĂȘtes inutiles. Le mode dĂ©veloppement enregistre les rĂ©ponses sur disque lors de la premiĂšre exĂ©cution et les rĂ©utilise ensuite. Vous pouvez ainsi modifier vos sĂ©lecteurs et relancer le spider autant de fois que nĂ©cessaire, sans tĂ©lĂ©charger ces pages de nouveau.++Activez-le avec `development_mode = True` dans votre spider :++```python+class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ development_mode = True++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++La premiĂšre exĂ©cution tĂ©lĂ©charge les pages et enregistre chaque rĂ©ponse sur disque. Les suivantes utilisent le cache pour les mĂȘmes requĂȘtes. Avec `robots_txt_obey=True`, les rĂšgles de robots.txt sont vĂ©rifiĂ©es avant de consulter le cache.++### Emplacement du cache {#cache-location}++Par dĂ©faut, les rĂ©ponses sont enregistrĂ©es dans `.scrapling_cache/{spider.name}/`, dans le dossier de travail actuel. Câest le dossier depuis lequel vous avez lancĂ© le spider, **pas** celui qui contient son fichier. Vous pouvez changer cet emplacement avec `development_cache_dir` :++```python+class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ development_mode = True+ development_cache_dir = "/tmp/my_spider_cache"+```++### Fonctionnement {#how-it-works_1}++1. **ClĂ© du cache** : chaque rĂ©ponse est identifiĂ©e par lâempreinte de la requĂȘte. Modifier les attributs qui influencent cette empreinte (`fp_include_kwargs`, `fp_include_headers`, `fp_keep_fragments`) entraĂźne une nouvelle rĂ©cupĂ©ration.+2. **Format** : un fichier JSON par rĂ©ponse, nommĂ© `{fingerprint_hex}.json`. Le corps est encodĂ© en base64 pour garder les donnĂ©es binaires intactes. Les Ă©critures sont atomiques : un fichier temporaire est créé puis renommĂ©.+3. **RĂ©utilisation** : si une rĂ©ponse est en cache, le moteur Ă©vite la rĂ©cupĂ©ration, `download_delay`, les limites de rythme et les nouvelles tentatives de `is_blocked()`. La rĂ©ponse enregistrĂ©e passe directement au callback.+4. **Statistiques** : les requĂȘtes servies depuis le cache sont comptĂ©es dans `requests_count`, `response_bytes` et les compteurs par code de statut, comme dans une exploration normale. `cache_hits` et `cache_misses` indiquent combien de requĂȘtes ont trouvĂ© une rĂ©ponse enregistrĂ©e et combien nâen ont pas trouvĂ©.++### Vider le cache {#clearing-the-cache}++Le cache nâexpire pas automatiquement. Pour tout rĂ©cupĂ©rer de nouveau, supprimez son dossier ou appelez directement la mĂ©thode `clear()` du gestionnaire.++!!! warning "Attention"++ Ce mode est prĂ©vu pour le dĂ©veloppement, pas la production. Les rĂ©ponses enregistrĂ©es nâexpirent jamais et leur rĂ©utilisation Ă©vite les limites de rythme et les nouvelles tentatives en cas de blocage. Ne dĂ©ployez pas un spider avec `development_mode = True`.++## Streaming {#streaming}++Pour les spiders qui tournent longtemps ou les applications qui ont besoin des donnĂ©es en temps rĂ©el, utilisez `stream()` au lieu de `start()` :++```python+import anyio++async def main():+ spider = MySpider()+ async for item in spider.stream():+ print(f"Got item: {item}")+ # Access real-time stats+ print(f"Items so far: {spider.stats.items_scraped}")+ print(f"Requests made: {spider.stats.requests_count}")++anyio.run(main)+```++Principales diffĂ©rences avec `start()` :++- Vous devez appeler `stream()` depuis un contexte asynchrone.+- Les Ă©lĂ©ments sont produits un Ă un dĂšs leur extraction, au lieu dâĂȘtre rĂ©unis dans une liste.+- Vous pouvez consulter `spider.stats` pendant lâitĂ©ration pour obtenir les statistiques en temps rĂ©el.++!!! abstract "Pour en savoir plus"++ La section [RĂ©sultats et statistiques](#results-statistics) dĂ©crit toutes les statistiques disponibles dans `spider.stats`.++Vous pouvez aussi le combiner avec les points de reprise. Cela permet de crĂ©er des interfaces qui affichent les donnĂ©es en temps rĂ©el et proposent la pause et la reprise.++```python+import anyio++async def main():+ spider = MySpider(crawldir="crawl_data/my_spider")+ async for item in spider.stream():+ print(f"Got item: {item}")+ # Access real-time stats+ print(f"Items so far: {spider.stats.items_scraped}")+ print(f"Requests made: {spider.stats.requests_count}")++anyio.run(main)+```++Vous pouvez Ă©galement utiliser `spider.pause()` pour arrĂȘter le spider de cet exemple. Si les points de reprise ne sont pas activĂ©s, cela arrĂȘte simplement lâexploration.++## Hooks du cycle de vie {#lifecycle-hooks}++Le spider propose plusieurs hooks, des mĂ©thodes que vous pouvez redĂ©finir pour ajouter votre logique Ă diffĂ©rentes Ă©tapes de lâexploration :++### on_start {#on_start}++AppelĂ© avant le dĂ©but de lâexploration. Utilisez-le pour prĂ©parer le travail, par exemple charger des donnĂ©es ou initialiser des ressources :++```python+async def on_start(self, resuming: bool = False):+ self.logger.info("Spider starting up")+ # Load seed URLs from a database, initialize counters, etc.+```++### on_close {#on_close}++AppelĂ© Ă la fin de lâexploration, quâelle soit terminĂ©e ou mise en pause. Utilisez-le pour libĂ©rer des ressources :++```python+async def on_close(self):+ self.logger.info("Spider shutting down")+ # Close database connections, flush buffers, etc.+```++### on_error {#on_error}++AppelĂ© quand une requĂȘte Ă©choue avec une exception. Utilisez-le pour enregistrer les erreurs ou appliquer votre propre logique de rĂ©cupĂ©ration :++```python+async def on_error(self, request: Request, error: Exception):+ self.logger.error(f"Failed: {request.url} - {error}")+ # Log to error tracker, save failed URL for later, etc.+```++### on_scraped_item {#on_scraped_item}++AppelĂ© pour chaque Ă©lĂ©ment extrait, avant son ajout aux rĂ©sultats. Renvoyez lâĂ©lĂ©ment, modifiĂ© ou non, pour le garder. Renvoyez `None` pour lâĂ©carter :++```python+async def on_scraped_item(self, item: dict) -> dict | None:+ # Drop items without a title+ if not item.get("title"):+ return None++ # Modify items (e.g., add timestamps)+ item["scraped_at"] = "2026-01-01"+ return item+```++!!! tip "Conseil"++ Vous pouvez aussi utiliser ce hook pour envoyer les Ă©lĂ©ments dans votre propre traitement et les retirer des rĂ©sultats du spider.++### start_requests {#start_requests}++RedĂ©finissez `start_requests()` pour produire vos propres requĂȘtes initiales au lieu dâutiliser `start_urls` :++```python+async def start_requests(self):+ # POST request to log in first+ yield Request(+ "https://example.com/login",+ method="POST",+ data={"user": "admin", "pass": "secret"},+ callback=self.after_login,+ )++async def after_login(self, response: Response):+ # Now crawl the authenticated pages+ yield response.follow("/dashboard", callback=self.parse)+```++## RĂ©sultats et statistiques {#results-statistics}++Le `CrawlResult` renvoyĂ© par `start()` contient les Ă©lĂ©ments extraits et des statistiques dĂ©taillĂ©es :++```python+result = MySpider().start()++# Items+print(f"Total items: {len(result.items)}")+result.items.to_json("output.json", indent=True)++# Did the crawl complete?+print(f"Completed: {result.completed}")+print(f"Paused: {result.paused}")++# Statistics+stats = result.stats+print(f"Requests: {stats.requests_count}")+print(f"Failed: {stats.failed_requests_count}")+print(f"Blocked: {stats.blocked_requests_count}")+print(f"Offsite filtered: {stats.offsite_requests_count}")+print(f"Robots.txt disallowed: {stats.robots_disallowed_count}")+print(f"Cache hits: {stats.cache_hits}")+print(f"Cache misses: {stats.cache_misses}")+print(f"Items scraped: {stats.items_scraped}")+print(f"Items dropped: {stats.items_dropped}")+print(f"Response bytes: {stats.response_bytes}")+print(f"Duration: {stats.elapsed_seconds:.1f}s")+print(f"Speed: {stats.requests_per_second:.1f} req/s")+```++### Statistiques dĂ©taillĂ©es {#detailed-stats}++Lâobjet `CrawlStats` enregistre des informations dĂ©taillĂ©es :++```python+stats = result.stats++# Status code distribution+print(stats.response_status_count)+# {'status_200': 150, 'status_404': 3, 'status_403': 1}++# Bytes downloaded per domain+print(stats.domains_response_bytes)+# {'example.com': 1234567, 'api.example.com': 45678}++# Requests per session+print(stats.sessions_requests_count)+# {'http': 120, 'stealth': 34}++# Proxies used during the crawl+print(stats.proxies)+# ['http://proxy1:8080', 'http://proxy2:8080']++# Log level counts+print(stats.log_levels_counter)+# {'debug': 200, 'info': 50, 'warning': 3, 'error': 1, 'critical': 0}++# Timing information+print(stats.start_time) # Unix timestamp when crawl started+print(stats.end_time) # Unix timestamp when crawl finished+print(stats.download_delay) # The download delay used (seconds)++# Concurrency settings used+print(stats.concurrent_requests) # Global concurrency limit+print(stats.concurrent_requests_per_domain) # Per-domain concurrency limit++# AutoThrottle+print(stats.autothrottle_enabled) # Whether the adaptive delay was on+print(stats.autothrottle_delays) # Final delay per domain, {'example.com': 0.62}++# Custom stats (set by your spider code)+print(stats.custom_stats)+# {'login_attempts': 3, 'pages_with_errors': 5}++# Export everything as a dict+print(stats.to_dict())+```++## Journaux {#logging}++Le spider a un logger intĂ©grĂ©, disponible dans `self.logger`. Il utilise dĂ©jĂ le nom du spider et accepte ces rĂ©glages :++| Attribut | Valeur par dĂ©faut | Description |+|----------|-------------------|-------------|+| `logging_level` | `logging.DEBUG` | Niveau minimal enregistrĂ© |+| `logging_format` | `"[%(asctime)s]:({spider_name}) %(levelname)s: %(message)s"` | Format des messages |+| `logging_date_format` | `"%Y-%m-%d %H:%M:%S"` | Format de la date dans les messages |+| `log_file` | `None` | Chemin dâun fichier journal, en plus de la sortie dans la console |++```python+import logging++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ logging_level = logging.INFO+ log_file = "logs/my_spider.log"++ async def parse(self, response: Response):+ self.logger.info(f"Processing {response.url}")+ yield {"title": response.css("title::text").get("")}+```++Si le dossier du fichier journal nâexiste pas, il est créé automatiquement. La console et le fichier utilisent le mĂȘme format.diff --git a/docs/locales/fr/spiders/architecture.md b/docs/locales/fr/spiders/architecture.mdnew file mode 100644index 0000000..17f4ea4--- /dev/null+++ b/docs/locales/fr/spiders/architecture.md@@ -0,0 +1,105 @@+---+title: "Comment fonctionnent les robots dâexploration de Scrapling"+description: "Comprenez le rĂŽle des spiders, requĂȘtes, sessions, files dâattente et du moteur dâexploration. Comparez le fonctionnement avec Scrapy et choisissez par oĂč commencer."+---++# Architecture des spiders {#spiders-architecture}++!!! success "Avant de commencer"++ 1. Lisez la page [Bases des fetchers](../fetching/choosing.md) pour connaĂźtre les types de fetcher et savoir quand utiliser chacun.+ 2. Lisez la page [Classes principales](../parsing/main_classes.md) pour dĂ©couvrir les classes [Selector](../parsing/main_classes.md#selector) et [Response](../fetching/choosing.md#response-object).++Le systĂšme de spiders de Scrapling sâinspire de Scrapy. Il permet une exploration asynchrone avec plusieurs requĂȘtes et sessions Ă la fois, ainsi que la pause et la reprise. Il rĂ©unit lâanalyseur et les fetchers de Scrapling dans une seule API dâexploration, avec une file de requĂȘtes, un contrĂŽle de la concurrence et des points de reprise.++Si vous connaissez Scrapy, vous retrouverez vos habitudes. Sinon, pas dâinquiĂ©tude : le systĂšme est conçu pour ĂȘtre simple Ă utiliser.++## Circulation des donnĂ©es {#data-flow}++Ce schĂ©ma montre comment les donnĂ©es circulent dans le systĂšme pendant une exploration :++<img src="../assets/spider_architecture.png" title="SchĂ©ma de lâarchitecture des spiders par @TrueSkills" alt="SchĂ©ma de lâarchitecture des spiders par @TrueSkills" style="width: 70%;"/>++Voici les principales Ă©tapes quand vous lancez un spider :++1. Le **Spider** produit le premier groupe dâobjets `Request`. Par dĂ©faut, il crĂ©e une requĂȘte par URL de `start_urls`. Vous pouvez redĂ©finir `start_requests()` pour changer cette logique.+2. Le **Scheduler** reçoit les requĂȘtes, calcule leurs empreintes et les place dans une file de prioritĂ©. Les requĂȘtes les plus prioritaires sortent en premier.+3. Le **moteur dâexploration** demande la prochaine requĂȘte au **Scheduler**, en respectant les limites de concurrence globales et par domaine ainsi que les dĂ©lais entre les tĂ©lĂ©chargements. Si `robots_txt_obey` est actif, il vĂ©rifie les rĂšgles de robots.txt du domaine et Ă©carte les requĂȘtes interdites sans message. Il envoie ensuite la requĂȘte au **gestionnaire de sessions**, qui choisit la session selon le champ `sid`, lâidentifiant de session.+4. La **session** rĂ©cupĂšre la page et renvoie un objet [Response](../fetching/choosing.md#response-object) au **moteur dâexploration**. Le moteur enregistre des statistiques et vĂ©rifie si la rĂ©ponse indique un blocage. Si câest le cas, il rĂ©essaie la requĂȘte jusquâĂ `max_blocked_retries` fois. Vous pouvez personnaliser la dĂ©tection et la logique des nouvelles tentatives.+5. Le **moteur dâexploration** passe lâobjet [Response](../fetching/choosing.md#response-object) au callback de la requĂȘte. Le callback produit soit un dictionnaire, enregistrĂ© comme Ă©lĂ©ment extrait, soit une nouvelle requĂȘte, envoyĂ©e au Scheduler pour rejoindre la file.+6. Le cycle reprend Ă lâĂ©tape 2 jusquâĂ ce que la file soit vide et quâaucune tĂąche ne soit active, ou que le spider soit mis en pause.+7. Si vous dĂ©finissez `crawldir` au lancement, le **moteur dâexploration** enregistre rĂ©guliĂšrement un point de reprise sur disque avec les requĂȘtes en attente et les URL dĂ©jĂ vues. Lors dâun arrĂȘt propre avec Ctrl+C, il enregistre un dernier point. Au prochain lancement avec le mĂȘme `crawldir`, le spider restaure la file et continue lĂ oĂč il sâĂ©tait arrĂȘtĂ©, sans exĂ©cuter `start_requests()`.++## Composants {#components}++### Spider {#spider}++Câest la classe principale que vous utilisez. CrĂ©ez une sous-classe de `Spider` et dĂ©finissez `start_urls` et la mĂ©thode `parse()`. Vous pouvez aussi configurer des sessions et redĂ©finir les hooks des diffĂ©rentes Ă©tapes de lâexploration.++```python+from scrapling.spiders import Spider, Response, Request++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]++ async def parse(self, response: Response):+ for link in response.css("a::attr(href)").getall():+ yield response.follow(link, callback=self.parse_page)++ async def parse_page(self, response: Response):+ yield {"title": response.css("h1::text").get("")}+```++### Moteur dâexploration {#crawler-engine}++Le moteur coordonne toute lâexploration. Il gĂšre la boucle principale, applique les limites de concurrence, envoie les requĂȘtes par le gestionnaire de sessions et traite les rĂ©sultats des callbacks. Vous ne lâutilisez pas directement : `Spider.start()` et `Spider.stream()` sâen chargent.++### Scheduler {#scheduler}++Câest une file de prioritĂ© qui Ă©vite les URL en double. Elle calcule lâempreinte de chaque requĂȘte Ă partir de son URL, de sa mĂ©thode HTTP, de son corps et de son identifiant de session. Les mĂ©thodes `snapshot()` et `restore()` permettent dâenregistrer et de restaurer lâĂ©tat de lâexploration grĂące aux points de reprise.++### Gestionnaire de sessions {#session-manager}++Il gĂšre une ou plusieurs sessions identifiĂ©es par un nom. Chaque session peut ĂȘtre :++- [FetcherSession](../fetching/static.md)+- [AsyncStealthySession](../fetching/stealthy.md)++Quand une requĂȘte arrive, le gestionnaire choisit la session selon son champ `sid`. Les sessions peuvent dĂ©marrer avec le spider, ce qui est le comportement par dĂ©faut, ou Ă leur premiĂšre utilisation.++### SystĂšme de points de reprise {#checkpoint-system}++Ce systĂšme facultatif enregistre lâĂ©tat du robot dans un fichier pickle : les requĂȘtes en attente et les empreintes des URL dĂ©jĂ vues. Les Ă©critures sont atomiques : un fichier temporaire est créé puis renommĂ© pour Ă©viter de corrompre les donnĂ©es. LâĂ©tat est enregistrĂ© Ă intervalles rĂ©glables et lors dâun arrĂȘt propre. Quand lâexploration se termine complĂštement, sans rester en pause, les fichiers sont supprimĂ©s automatiquement.++### Cache des rĂ©ponses {#response-cache}++Quand le mode dĂ©veloppement est actif, ce cache facultatif enregistre les rĂ©ponses sur disque et les rĂ©utilise lors des exĂ©cutions suivantes. Chaque rĂ©ponse est identifiĂ©e par lâempreinte de la requĂȘte et enregistrĂ©e en JSON, avec le corps encodĂ© en base64 pour prĂ©server les donnĂ©es binaires. Il sert Ă ajuster la logique de `parse()` sans envoyer de nouvelles requĂȘtes aux serveurs. Il nâest pas prĂ©vu pour la production.++### RĂ©sultats {#output}++Les Ă©lĂ©ments extraits sont rĂ©unis dans un `ItemList`, une sous-classe de liste avec les mĂ©thodes dâexportation `to_json()`, `to_jsonl()`, `to_csv()` et `to_xml()`. Les statistiques sont enregistrĂ©es dans une dataclass `CrawlStats`, qui contient des informations dĂ©taillĂ©es sur lâexĂ©cution.++## Comparaison avec Scrapy {#comparison-with-scrapy}++Si vous utilisez dĂ©jĂ Scrapy, voici les Ă©quivalences dans Scrapling :++| Concept | Scrapy | Scrapling |+|---------|--------|-----------|+| DĂ©finition du spider | Sous-classe de `scrapy.Spider` | Sous-classe de `scrapling.spiders.Spider` |+| RequĂȘtes initiales | `start_requests()` | `async start_requests()` |+| Callbacks | `def parse(self, response)` | `async def parse(self, response)` |+| Suivi des liens | `response.follow(url)` | `response.follow(url)` |+| Production dâĂ©lĂ©ments | `yield dict` ou `yield Item` | `yield dict` |+| File de requĂȘtes | Scheduler + Dupefilter | Scheduler avec suppression des doublons intĂ©grĂ©e |+| TĂ©lĂ©chargement | Downloader + Middlewares | Gestionnaire de sessions avec prise en charge de plusieurs sessions |+| Traitement des Ă©lĂ©ments | Item Pipelines | Hook `on_scraped_item()` |+| DĂ©tection des blocages | Par des middlewares personnalisĂ©s | Hooks intĂ©grĂ©s `is_blocked()` + `retry_blocked_request()` |+| Concurrence | RĂ©glage `CONCURRENT_REQUESTS` | Attribut de classe `concurrent_requests` |+| Filtrage des domaines | `allowed_domains` | `allowed_domains` |+| Robots.txt | RĂ©glage `ROBOTSTXT_OBEY` | Attribut de classe `robots_txt_obey` |+| Pause et reprise | RĂ©glage `JOBDIR` | Argument `crawldir` du constructeur |+| Exportation | Feed exports | `result.items.to_json()` / `to_jsonl()` / `to_csv()` / `to_xml()`, ou par des hooks personnalisĂ©s |+| ExĂ©cution | `scrapy crawl spider_name` | `MySpider().start()` |+| Streaming | Non disponible | `async for item in spider.stream()` |+| Plusieurs sessions | Non disponible | Plusieurs sessions de types diffĂ©rents par spider |diff --git a/docs/locales/fr/spiders/generic-templates.md b/docs/locales/fr/spiders/generic-templates.mdnew file mode 100644index 0000000..4e43f9e--- /dev/null+++ b/docs/locales/fr/spiders/generic-templates.md@@ -0,0 +1,278 @@+---+title: "ModĂšles de spiders pour les liens, plans de site, flux et Markdown"+description: "Choisissez CrawlSpider, SitemapSpider, XMLFeedSpider, CSVFeedSpider ou ContentSpider. DĂ©finissez des rĂšgles pour collecter des pages, des lignes de flux ou des documents Markdown."+---++# ModĂšles gĂ©nĂ©riques de spiders {#generic-spider-templates}++La plupart des explorations suivent lâun de ces deux modĂšles : suivre les liens qui correspondent Ă une rĂšgle, ou parcourir toutes les URL dâun plan de site. Scrapling fournit des modĂšles pour les deux, pour vous Ă©viter de réécrire la mĂȘme logique de `parse()` Ă chaque fois.++`CrawlSpider` et `SitemapSpider` utilisent `LinkExtractor`, qui extrait les URL dâun `Response` ou filtre une URL avec `matches()`. `SitemapSpider` analyse aussi le contenu de sitemap.xml et sitemap_index.xml, avec ou sans compression gzip.++Vous pouvez utiliser `LinkExtractor` directement dans nâimporte quel `Spider.parse()`. Les modĂšles vous Ă©vitent simplement de relier ces composants vous-mĂȘme.++## CrawlSpider {#crawlspider}++`CrawlSpider` suit les liens automatiquement selon les rĂšgles que vous dĂ©finissez.++```python+from scrapling.spiders import CrawlSpider, CrawlRule, LinkExtractor++class QuotesSpider(CrawlSpider):+ name = "blog"+ start_urls = ["https://quotes.toscrape.com/"]++ def rules(self):+ return [+ CrawlRule(LinkExtractor(allow=r"/author/"), callback=self.parse_author),+ CrawlRule(LinkExtractor(allow=r"/page/\d+/")), # follow pagination, no callback+ ]++ async def parse_author(self, response):+ yield {+ '.author-title': response.css('.author-title::text').get(),+ "birthday": response.css('.author-born-date::text').get(),+ "url": response.url,+ }++result = QuotesSpider().start()+```++Un `CrawlRule` associe un `LinkExtractor` Ă trois options : `callback`, une mĂ©thode du spider ; `priority`, pour changer la prioritĂ© du `Request` produit ; et `process_request`, une mĂ©thode qui modifie chaque `Request` avant quâil soit produit. Le `parse()` par dĂ©faut applique toutes les rĂšgles Ă chaque rĂ©ponse et produit un `Request` pour chaque URL correspondante.++Si une rĂšgle nâa pas de callback, les URL correspondantes passent au `parse()` par dĂ©faut du spider. Câest pratique pour la pagination : vous pouvez extraire les liens des pages suivantes sans crĂ©er une mĂ©thode distincte pour les traiter.++### Ordre dâexploration {#crawl-order}++DĂ©finissez `crawl_strategy` sur `CrawlSpider` ou ses sous-classes, dont `ContentSpider`, pour choisir la prochaine requĂȘte en attente :++| `crawl_strategy` | Ordre des requĂȘtes avec le mĂȘme `Request.priority` |+|------------------|---------------------------------------------------|+| `"bfs"` (par dĂ©faut) | La requĂȘte la plus ancienne dans la file passe en premier |+| `"dfs"` | La derniĂšre requĂȘte ajoutĂ©e passe en premier |++Le Scheduler choisit toujours les requĂȘtes avec le plus grand `Request.priority` en premier. La stratĂ©gie ne trie que les requĂȘtes de mĂȘme prioritĂ©.++DĂ©finissez `concurrent_requests = 1` pour traiter une requĂȘte Ă la fois dans lâordre choisi. Les URL en double restent filtrĂ©es : retrouver une URL ne dĂ©place pas sa requĂȘte dans la file. Avec des requĂȘtes parallĂšles, le traitement des pages peut se terminer dans un autre ordre et les niveaux ou branches de lâexploration peuvent se chevaucher.++Gardez le mĂȘme `crawl_strategy` quand vous reprenez depuis un point de reprise.++### Combiner les rĂšgles avec votre propre logique {#combining-rules-with-custom-logic}++RedĂ©finissez `parse()` et appelez `super().parse(response)` pour garder le comportement des rĂšgles et ajouter vos propres rĂ©sultats :++```python+class MySpider(CrawlSpider):+ def rules(self):+ return [CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post)]++ async def parse(self, response):+ yield {"page_url": response.url}+ async for req in super().parse(response):+ yield req+```++### Modifier les requĂȘtes avec `process_request` {#mutating-requests-with-process_request}++```python+def add_priority(self, request, response):+ request.priority = 10+ return request++def rules(self):+ return [CrawlRule(+ LinkExtractor(allow=r"/posts/"),+ callback=self.parse_post,+ process_request=self.add_priority,+ )]+```++## SitemapSpider {#sitemapspider}++`SitemapSpider` dĂ©marre lâexploration avec les URL de sitemap.xml. Il utilise la mĂȘme API `rules()` que `CrawlSpider`, donc la configuration est similaire.++```python+from scrapling.spiders import SitemapSpider, CrawlRule, LinkExtractor++class MySitemap(SitemapSpider):+ name = "sm"+ sitemap_urls = ["https://example.com/sitemap.xml"]++ def rules(self):+ return [+ CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post),+ CrawlRule(LinkExtractor(allow=r"/products/"), callback=self.parse_product),+ ]++ async def parse_post(self, response):+ yield {"title": response.css("h1::text").get()}++ async def parse_product(self, response):+ yield {"sku": response.css(".sku::text").get()}++result = MySitemap().start()+```++### Choisir le callback de chaque URL {#how-urls-are-dispatched}++Pour chaque URL du plan de site, `SitemapSpider` vĂ©rifie `LinkExtractor.matches(url)` pour chaque rĂšgle dans lâordre. La premiĂšre rĂšgle correspondante est retenue, et un `Request` est produit avec son callback. Si aucune rĂšgle ne correspond et que `rules()` contient des rĂšgles, lâURL est Ă©cartĂ©e. Si `rules()` renvoie une liste vide, toutes les URL passent Ă la mĂ©thode `parse()` du spider. Vous devez redĂ©finir cette mĂ©thode, car elle lĂšve `NotImplementedError` par dĂ©faut.++### Index de plans de site {#sitemap-indexes}++Quand `SitemapSpider` rencontre un `<sitemapindex>`, un plan qui rĂ©pertorie dâautres plans de site, il parcourt automatiquement chaque plan enfant. Pour choisir ceux Ă suivre, affectez un `LinkExtractor` Ă `sitemap_follow` :++```python+class MySitemap(SitemapSpider):+ name = "sm"+ sitemap_urls = ["https://example.com/sitemap.xml"]+ sitemap_follow = LinkExtractor(allow=r"/posts-sitemap-\d+\.xml") # only post sitemaps+```++### Prise en charge de robots.txt {#robotstxt-support}++Ajoutez une URL de `robots.txt` directement Ă `sitemap_urls`. `SitemapSpider` la dĂ©tectera, extraira tous les plans de site indiquĂ©s et les suivra :++```python+class MySitemap(SitemapSpider):+ name = "sm"+ sitemap_urls = ["https://example.com/robots.txt"]+```++### URL dans dâautres langues {#alternate-language-urls}++DĂ©finissez `sitemap_alternate_links = True` pour que les URL de `<xhtml:link rel="alternate" hreflang="...">` passent aussi par vos rĂšgles.++## XMLFeedSpider {#xmlfeedspider}++`XMLFeedSpider` parcourt les nĆuds dâun flux XML, comme RSS, Atom ou un flux de produits. DĂ©finissez `itertag` avec le nom du nĆud Ă lire, `"item"` par dĂ©faut, et redĂ©finissez `parse_node()`. Cette mĂ©thode est appelĂ©e une fois pour chaque nĆud correspondant :++```python+from scrapling.spiders import XMLFeedSpider++class RSSSpider(XMLFeedSpider):+ name = "rss"+ start_urls = ["https://example.com/feed.xml"]+ itertag = "item"++ async def parse_node(self, response, node):+ yield {+ "title": node.findtext("title"),+ "link": node.findtext("link"),+ "date": node.findtext("pubDate"),+ }++result = RSSSpider().start()+```++Comme les autres callbacks, `parse_node()` peut aussi produire des objets `Request`. Par exemple, utilisez `response.follow(node.findtext("link"), callback=self.parse_post)` pour parcourir les pages liĂ©es dans le flux.++### Recherche et analyse des nĆuds {#how-nodes-are-matched-and-parsed}++Chaque nĆud reçu par `parse_node()` est un Ă©lĂ©ment `lxml` dont tous les espaces de noms ont Ă©tĂ© retirĂ©s. Vous pouvez donc utiliser `node.findtext("title")`, `node.find("thumbnail").get("url")` et `node.xpath(...)`, qui distingue les majuscules des minuscules, sans dĂ©finir de correspondances dâespaces de noms. Un `itertag` simple comme `"entry"` recherche les nĆuds par leur nom, quel que soit leur espace de noms. Cela convient Ă Atom et Ă la plupart des flux avec des espaces de noms. Pour chercher dans un espace de noms prĂ©cis, utilisez un `itertag` avec un prĂ©fixe et dĂ©finissez ce prĂ©fixe dans `namespaces` :++```python+class ThumbnailSpider(XMLFeedSpider):+ name = "thumbs"+ start_urls = ["https://example.com/feed.xml"]+ itertag = "media:thumbnail"+ namespaces = (("media", "http://search.yahoo.com/mrss/"),)++ async def parse_node(self, response, node):+ yield {"thumbnail": node.get("url")}+```++Les flux compressĂ©s avec gzip, avec une extension `.xml.gz` ou un content-type gzip, sont dĂ©compressĂ©s automatiquement avec les mĂȘmes protections que le spider de plans de site. Un XML mal formĂ© produit un avertissement dans les journaux au lieu dâarrĂȘter lâexploration.++## CSVFeedSpider {#csvfeedspider}++`CSVFeedSpider` parcourt les lignes dâun flux CSV. RedĂ©finissez `parse_row()`, qui reçoit chaque ligne sous forme de dictionnaire avec les noms des colonnes comme clĂ©s :++```python+from scrapling.spiders import CSVFeedSpider++class PriceSpider(CSVFeedSpider):+ name = "prices"+ start_urls = ["https://example.com/products.csv"]++ async def parse_row(self, response, row):+ yield {"product": row["title"], "price": float(row["price"])}++result = PriceSpider().start()+```++Par dĂ©faut, la premiĂšre ligne contient les noms des colonnes. Si le flux nâa pas cette ligne, indiquez les noms avec `headers`. Utilisez `delimiter`/`quotechar` pour les fichiers qui ne suivent pas le format habituel avec des virgules :++```python+class PriceSpider(CSVFeedSpider):+ name = "prices"+ start_urls = ["https://example.com/products.csv"]+ headers = ["title", "price", "url"]+ delimiter = ";"+```++Les flux gzip sont Ă©galement dĂ©compressĂ©s automatiquement, comme avec **XMLFeedSpider**.++<a id="sitetomarkdownspider"></a>++## ContentSpider {#contentspider}++`ContentSpider` sâappuie sur **CrawlSpider** pour parcourir un site et convertir chaque page en Markdown propre, prĂȘt pour un LLM. Il produit un Ă©lĂ©ment par page et peut aussi enregistrer chaque page dans son propre fichier Markdown :++```python+from scrapling.spiders import ContentSpider++class DocsSpider(ContentSpider):+ name = "docs"+ start_urls = ["https://example.com/docs/"]+ allowed_domains = {"example.com"}+ output_dir = "docs_markdown"++result = DocsSpider().start()+```++Vous devez dĂ©finir `allowed_domains` pour limiter lâexploration au site choisi. La page [CrĂ©er des systĂšmes RAG](../ai/building-rag-systems.md) explique toutes les options et comment intĂ©grer les rĂ©sultats dans un traitement RAG.++## Utiliser `LinkExtractor` directement {#using-linkextractor-directly}++Vous nâavez pas besoin des modĂšles. `LinkExtractor` fonctionne dans nâimporte quel `Spider` :++```python+from scrapling.spiders import Spider, LinkExtractor++class CustomSpider(Spider):+ name = "custom"+ start_urls = ["https://example.com"]++ def __init__(self):+ super().__init__()+ self._links = LinkExtractor(allow=r"/posts/", deny_domains="ads.example.com")++ async def parse(self, response):+ for url in self._links.extract(response):+ yield response.follow(url, callback=self.parse_post)++ async def parse_post(self, response):+ yield {"title": response.css("h1::text").get()}+```++## RĂ©fĂ©rence de LinkExtractor {#linkextractor-reference}++| Argument | Valeur par dĂ©faut | Description |+|----------|-------------------|-------------|+| `allow` | `()` | Motifs dâURL autorisĂ©s. Une valeur vide autorise tout. Accepte une chaĂźne, un `Pattern` compilĂ© ou un itĂ©rable contenant lâun ou lâautre |+| `deny` | `()` | Motifs dâURL Ă©cartĂ©s. Ils ont toujours prioritĂ© sur `allow` |+| `allow_domains` | `()` | Noms dâhĂŽtes autorisĂ©s. Les sous-domaines sont inclus automatiquement : `example.com` inclut `api.example.com` |+| `deny_domains` | `()` | Noms dâhĂŽtes Ă©cartĂ©s |+| `restrict_css` | `()` | SĂ©lecteurs CSS qui limitent lâextraction Ă une zone du DOM |+| `restrict_xpath` | `()` | SĂ©lecteurs XPath qui limitent lâextraction Ă une zone du DOM |+| `tags` | `("a", "area")` | Balises des Ă©lĂ©ments oĂč chercher les liens |+| `attrs` | `("href",)` | Attributs de ces balises dans lesquels lire les URL |+| `canonicalize` | `True` | Trie les paramĂštres de requĂȘte et normalise le chemin |+| `strip` | `True` | Retire les espaces au dĂ©but et Ă la fin des URL extraites |+| `keep_fragment` | `False` | Garde `#fragment` lors de la normalisation de lâURL |+| `deny_extensions` | `IGNORED_EXTENSIONS` | Extensions Ă©cartĂ©es, comme pdf, zip, images ou vidĂ©os |+| `process` | `None` | Fonction facultative appliquĂ©e Ă chaque URL extraite avant le filtrage. Renvoyez une valeur Ă©valuĂ©e comme fausse pour lâĂ©carter |++`LinkExtractor.extract(response)` renvoie une `list[str]` dâURL absolues, filtrĂ©es et sans doublons.++`LinkExtractor.matches(url)` renvoie un `bool`. Il applique Ă une URL les filtres de motifs autorisĂ©s ou exclus, de domaines et dâextensions. `SitemapSpider` lâutilise pour choisir les URL sans avoir besoin dâun `Response`.diff --git a/docs/locales/fr/spiders/getting-started.md b/docs/locales/fr/spiders/getting-started.mdnew file mode 100644index 0000000..6872e07--- /dev/null+++ b/docs/locales/fr/spiders/getting-started.md@@ -0,0 +1,199 @@+---+title: "CrĂ©ez votre premier robot dâexploration web en Python avec Scrapling"+description: "CrĂ©ez un spider qui extrait des donnĂ©es, suit la pagination et exporte les rĂ©sultats. DĂ©couvrez les URL de dĂ©part, les callbacks, les limites de domaine et robots.txt."+---++# Premiers pas {#getting-started}++## Introduction {#introduction}++!!! success "Avant de commencer"++ 1. Lisez la page [Bases des fetchers](../fetching/choosing.md) pour connaĂźtre les types de fetcher et savoir quand utiliser chacun.+ 2. Lisez la page [Classes principales](../parsing/main_classes.md) pour dĂ©couvrir les classes [Selector](../parsing/main_classes.md#selector) et [Response](../fetching/choosing.md#response-object).+ 3. Lisez la page [Architecture](architecture.md) pour comprendre le fonctionnement du systĂšme de spiders.++Le systĂšme de spiders permet dâexplorer plusieurs pages en mĂȘme temps avec quelques lignes de code. Si vous avez dĂ©jĂ utilisĂ© Scrapy, son fonctionnement vous sera familier. Sinon, ce guide explique tout ce dont vous avez besoin pour commencer.++## Votre premier spider {#your-first-spider}++Un spider est une classe qui dĂ©finit comment parcourir des sites et extraire leurs donnĂ©es. Voici lâexemple le plus simple :++```python+from scrapling.spiders import Spider, Response++class QuotesSpider(Spider):+ name = "quotes"+ start_urls = ["https://quotes.toscrape.com"]++ async def parse(self, response: Response):+ for quote in response.css("div.quote"):+ yield {+ "text": quote.css("span.text::text").get(""),+ "author": quote.css("small.author::text").get(""),+ }+```++Chaque spider a besoin de trois Ă©lĂ©ments :++1. **`name`** : un nom unique pour le spider.+2. **`start_urls`** : une liste dâURL Ă partir desquelles lancer lâexploration.+3. **`parse()`** : une mĂ©thode gĂ©nĂ©ratrice asynchrone qui traite chaque rĂ©ponse et produit les rĂ©sultats.++La mĂ©thode `parse()` contient la logique dâextraction. Vous utilisez les mĂȘmes mĂ©thodes de sĂ©lection que dans les objets [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object) de Scrapling et produisez les Ă©lĂ©ments extraits sous forme de dictionnaires avec `yield`.++## ExĂ©cuter le spider {#running-the-spider}++Pour exĂ©cuter votre spider, crĂ©ez une instance et appelez `start()` :++```python+result = QuotesSpider().start()+```++La mĂ©thode `start()` gĂšre lâexĂ©cution asynchrone : vous nâavez pas Ă gĂ©rer les boucles dâĂ©vĂ©nements. Pendant lâexĂ©cution, le spider Ă©crit les Ă©vĂ©nements dans le terminal. Ă la fin, il affiche des statistiques dĂ©taillĂ©es.++Ces statistiques sont aussi disponibles dans lâobjet `CrawlResult` renvoyé :++```python+result = QuotesSpider().start()++# Access scraped items+for item in result.items:+ print(item["text"], "-", item["author"])++# Check statistics+print(f"Scraped {result.stats.items_scraped} items")+print(f"Made {result.stats.requests_count} requests")+print(f"Took {result.stats.elapsed_seconds:.1f} seconds")++# Did the crawl finish or was it paused?+print(f"Completed: {result.completed}")+```++## Suivre des liens {#following-links}++La plupart des explorations doivent suivre des liens entre plusieurs pages. Utilisez `response.follow()` pour crĂ©er les requĂȘtes suivantes :++```python+from scrapling.spiders import Spider, Response++class QuotesSpider(Spider):+ name = "quotes"+ start_urls = ["https://quotes.toscrape.com"]++ async def parse(self, response: Response):+ # Extract items from the current page+ for quote in response.css("div.quote"):+ yield {+ "text": quote.css("span.text::text").get(""),+ "author": quote.css("small.author::text").get(""),+ }++ # Follow the "next page" link+ next_page = response.css("li.next a::attr(href)").get()+ if next_page:+ yield response.follow(next_page, callback=self.parse)+```++`response.follow()` rĂ©sout les URL relatives Ă partir de lâURL de la page actuelle. Par dĂ©faut, il utilise aussi cette page comme valeur de lâen-tĂȘte `Referer`.++Vous pouvez envoyer les requĂȘtes vers diffĂ©rents callbacks selon le type de page :++```python+async def parse(self, response: Response):+ for link in response.css("a.product-link::attr(href)").getall():+ yield response.follow(link, callback=self.parse_product)++async def parse_product(self, response: Response):+ yield {+ "name": response.css("h1::text").get(""),+ "price": response.css(".price::text").get(""),+ }+```++!!! note "Note"++ Tous les callbacks doivent ĂȘtre des mĂ©thodes gĂ©nĂ©ratrices asynchrones, avec `async def` et `yield`.++## Exporter les donnĂ©es {#exporting-data}++Lâobjet `ItemList` dans `result.items` contient des mĂ©thodes dâexportation :++```python+result = QuotesSpider().start()++# Export as JSON+result.items.to_json("quotes.json")++# Export as JSON with pretty-printing+result.items.to_json("quotes.json", indent=True)++# Export as JSON Lines (one JSON object per line)+result.items.to_jsonl("quotes.jsonl")++# Export as CSV or XML+result.items.to_csv("quotes.csv")+result.items.to_xml("quotes.xml")+```++Toutes crĂ©ent les dossiers nĂ©cessaires sâils nâexistent pas encore.++`to_csv()` crĂ©e une colonne pour chaque clĂ© trouvĂ©e dans les Ă©lĂ©ments. Si un Ă©lĂ©ment nâa pas une clĂ©, la cellule reste vide. Utilisez `fields=[...]` pour choisir les colonnes et leur ordre, ou `delimiter="\t"` pour crĂ©er un fichier TSV. `to_xml()` place chaque Ă©lĂ©ment dans une balise `<item>`, sous une racine `<items>`. Vous pouvez changer ces deux noms avec `root_tag` et `item_tag`.++Dans les deux formats, les valeurs qui ne sont pas des scalaires simples, comme une liste ou un dictionnaire imbriquĂ©, sont Ă©crites en JSON pour ne perdre aucune donnĂ©e.++## Limiter les domaines {#filtering-domains}++Utilisez `allowed_domains` pour limiter le spider Ă certains domaines. Cela Ă©vite quâil suive par erreur des liens vers dâautres sites :++```python+class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ allowed_domains = {"example.com"}++ async def parse(self, response: Response):+ for link in response.css("a::attr(href)").getall():+ # Links to other domains are silently dropped+ yield response.follow(link, callback=self.parse)+```++Les sous-domaines sont inclus automatiquement. Par exemple, `allowed_domains = {"example.com"}` autorise aussi `sub.example.com`, `blog.example.com`, etc.++Chaque requĂȘte Ă©cartĂ©e est comptĂ©e dans `stats.offsite_requests_count`, pour que vous puissiez voir combien ont Ă©tĂ© ignorĂ©es.++## Respecter robots.txt {#robotstxt-compliance}++DĂ©finissez `robots_txt_obey = True` pour que le spider consulte les rĂšgles de robots.txt avant dâexplorer un domaine :++```python+class PoliteSpider(Spider):+ name = "polite"+ start_urls = ["https://example.com"]+ robots_txt_obey = True++ async def parse(self, response: Response):+ for link in response.css("a::attr(href)").getall():+ yield response.follow(link, callback=self.parse)+```++Quand cette option est active, le spider :++1. **TĂ©lĂ©charge robots.txt** pour tous les domaines de `start_urls` avant de commencer. Ces tĂ©lĂ©chargements se font en parallĂšle.+2. **VĂ©rifie chaque requĂȘte** avec les rĂšgles `Disallow` du domaine. Les requĂȘtes interdites sont Ă©cartĂ©es sans message et comptĂ©es dans `stats.robots_disallowed_count`.+3. **Respecte les directives `Crawl-delay` et `Request-rate`** en utilisant la plus grande valeur entre la directive et votre `download_delay`. robots.txt peut donc augmenter lâattente, mais jamais la rĂ©duire. Si AutoThrottle est actif, son dĂ©lai maximal limite aussi cette valeur. Choisissez un `autothrottle_max_delay` assez Ă©levĂ© pour respecter lâattente demandĂ©e.++Les fichiers robots.txt sont tĂ©lĂ©chargĂ©s avec la session par dĂ©faut du spider et gardĂ©s en cache par domaine pendant toute lâexploration. Si un domaine absent de `start_urls` est dĂ©couvert en cours de route, son robots.txt est tĂ©lĂ©chargĂ© avant la premiĂšre requĂȘte vers ce domaine.++**Note :** `robots_txt_obey` est dĂ©sactivĂ© par dĂ©faut pour Ă©viter les changements de comportement inattendus. Son activation ne modifie pas les limites de concurrence (`concurrent_requests`, `concurrent_requests_per_domain`). Seule lâattente entre les requĂȘtes est ajustĂ©e.++Si vous prĂ©fĂ©rez ne pas choisir un `download_delay` Ă la main, dĂ©finissez `autothrottle_enabled = True`. Le spider ajustera lâattente de chaque domaine selon la vitesse des rĂ©ponses et ralentira en cas de blocage. Consultez [AutoThrottle](advanced.md#autothrottle).++## Pour aller plus loin {#whats-next}++Maintenant que vous connaissez les bases, vous pouvez consulter :++- [RequĂȘtes et rĂ©ponses](requests-responses.md) : prioritĂ©, suppression des doublons, mĂ©tadonnĂ©es et plus encore.+- [Sessions](sessions.md) : diffĂ©rents types de fetcher, comme HTTP, navigateur et navigateur furtif, dans un mĂȘme spider.+- [Gestion des proxies et des blocages](proxy-blocking.md) : rotation des proxies entre les requĂȘtes et traitement des blocages.+- [Fonctions avancĂ©es](advanced.md) : contrĂŽle de la concurrence, AutoThrottle, pause et reprise, streaming, hooks du cycle de vie et journaux.diff --git a/docs/locales/fr/spiders/platform-templates.md b/docs/locales/fr/spiders/platform-templates.mdnew file mode 100644index 0000000..b465a5c--- /dev/null+++ b/docs/locales/fr/spiders/platform-templates.md@@ -0,0 +1,59 @@+---+title: "Extrayez les donnĂ©es des produits Shopify avec Python"+description: "Extrayez le catalogue dâune boutique Shopify avec ShopifySpider. Indiquez son URL, collectez les variantes des produits et consultez les champs de chaque Ă©lĂ©ment."+---++# ModĂšles de spiders pour les plateformes {#platform-spider-templates}++Les modĂšles gĂ©nĂ©riques couvrent des *façons* dâexplorer, comme suivre des liens ou parcourir des plans de site. Les modĂšles pour plateformes visent des *plateformes* qui proposent la mĂȘme structure de donnĂ©es sur de nombreux sites indĂ©pendants. Le spider sait dĂ©jĂ oĂč chercher les donnĂ©es. Vous indiquez simplement le domaine.++## ShopifySpider {#shopifyspider}++`ShopifySpider` extrait tous les produits dâune boutique Shopify par lâAPI JSON de la plateforme, sans utiliser le HTML du site.++```python+from scrapling.spiders import ShopifySpider++class MyStore(ShopifySpider):+ target_website = "example.com"++result = MyStore().start()+print(result.items[0])+```++DĂ©finissez `target_website` avec le domaine de la boutique. Sâil est vide, le spider utilise la premiĂšre valeur de `start_urls`, puis celle de `allowed_domains` si nĂ©cessaire. Si les trois sont vides, il lĂšve `ValueError`. Les URL complĂštes sont automatiquement rĂ©duites Ă leur domaine.++### Fonctionnement {#how-it-works}++1. Parcourt les pages de `https://<store>/collections.json`, avec 250 collections par page, la limite de la plateforme.+2. Pour chaque collection qui indique avoir des produits, parcourt les pages de `/collections/<handle>/products.json`.+3. Produit un Ă©lĂ©ment par variante de produit, sans rĂ©pĂ©ter les variantes prĂ©sentes dans plusieurs collections.++### Champs de chaque Ă©lĂ©ment {#item-fields}++| Champ | Origine |+|-------|---------|+| `name` | Titre du produit, suivi du titre de la variante si ce nâest pas la variante par dĂ©faut |+| `price` | Prix de la variante sous forme de chaĂźne, tel que Shopify le renvoie |+| `category` | Identifiant textuel de la collection dans lâURL, avec une majuscule au dĂ©but de chaque mot (`summer-sale` devient `Summer Sale`) |+| `brand` | Fournisseur du produit |+| `identifier` | Identifiant de la variante |+| `sku` | SKU de la variante, ou `""` si la boutique nâen dĂ©finit pas |+| `stock` | `None` si la variante est disponible, ou `0` si elle est Ă©puisĂ©e |+| `image_url` | PremiĂšre image du produit, ou `""` |+| `url` | Page du produit dans la collection |+| `description` | Contenu de `body_html` du produit, sans les balises HTML |+| `old_price` | `compare_at_price` sâil sâagit dâun vrai prix avant promotion, sinon `""` |+| `barcode` | Code-barres de la variante, ou `""` (la plupart des boutiques ne le fournissent pas dans ces endpoints) |++Ces champs ne sont pas obligatoires. RedĂ©finissez `_process_product()` dans votre sous-classe pour changer la structure des Ă©lĂ©ments ou extraire dâautres champs des donnĂ©es du produit.++### Notes et limites {#notes-and-limits}++- Les endpoints JSON exposent uniquement les produits publiĂ©s sur le canal de la boutique en ligne. `products_count` peut donc ĂȘtre supĂ©rieur au nombre de produits rĂ©ellement accessibles. Le spider utilise seulement une valeur non nulle comme signal pour consulter la collection, jamais comme un total attendu.+- Ce modĂšle ne fonctionnera probablement pas avec les boutiques qui ajoutent des protections ou un mot de passe. MĂȘme si vous parvenez Ă lâutiliser, vous devrez redĂ©finir de nombreuses parties.+- Toutes les fonctions de `Spider` restent disponibles : limites de concurrence, dĂ©lais, respect de robots.txt, points de reprise et hooks du cycle de vie.++### Ce qui peut devenir un modĂšle pour plateforme {#what-qualifies-as-a-platform-template}++Les modĂšles sont acceptĂ©s pour les plateformes qui exposent une structure uniforme, lisible par un programme, sur de nombreux sites indĂ©pendants, comme Shopify. Les spiders destinĂ©s Ă un seul site ne font pas partie de la bibliothĂšque, quelle que soit la popularitĂ© du site.diff --git a/docs/locales/fr/spiders/proxy-blocking.md b/docs/locales/fr/spiders/proxy-blocking.mdnew file mode 100644index 0000000..505b085--- /dev/null+++ b/docs/locales/fr/spiders/proxy-blocking.md@@ -0,0 +1,247 @@+---+title: "Alternez les proxies et rĂ©essayez les requĂȘtes bloquĂ©es"+description: "Utilisez des proxies et des stratĂ©gies de rotation dans les spiders de Scrapling. DĂ©tectez les blocages, rĂ©essayez les requĂȘtes et passez dâune session HTTP Ă un navigateur."+---++# GĂ©rer les proxies et les blocages {#proxy-management-and-handling-blocks}++## Introduction {#introduction}++!!! success "Avant de commencer"++ 1. Lisez la page [Premiers pas](getting-started.md) pour apprendre Ă crĂ©er et exĂ©cuter un spider simple.+ 2. Lisez la page [Sessions](sessions.md) pour apprendre Ă les configurer.++Pour extraire beaucoup de donnĂ©es, vous aurez souvent besoin dâalterner entre plusieurs proxies afin dâĂ©viter les limites de requĂȘtes et les blocages. `ProxyRotator` de Scrapling simplifie ce travail. Il fonctionne avec tous les types de session et sâintĂšgre au systĂšme de nouvelles tentatives du spider.++Si vous ne savez pas ce quâest un proxy ou comment en choisir un, [ce guide peut vous aider](https://substack.thewebscraping.club/p/everything-about-proxies).++## ProxyRotator {#proxyrotator}++La classe `ProxyRotator` gĂšre une liste de proxies et les utilise Ă tour de rĂŽle. Passez-la Ă nâimporte quel type de session par le paramĂštre `proxy_rotator` :++```python+from scrapling.spiders import Spider, Response+from scrapling.fetchers import FetcherSession, ProxyRotator++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]++ def configure_sessions(self, manager):+ rotator = ProxyRotator([+ "http://proxy1:8080",+ "http://proxy2:8080",+ "http://user:pass@proxy3:8080",+ ])+ manager.add("default", FetcherSession(proxy_rotator=rotator))++ async def parse(self, response: Response):+ # Check which proxy was used+ print(f"Proxy used: {response.meta.get('proxy')}")+ yield {"title": response.css("title::text").get("")}+```++Chaque requĂȘte reçoit automatiquement le proxy suivant. Le proxy utilisĂ© est enregistrĂ© dans `response.meta["proxy"]`, pour que vous sachiez lequel a rĂ©cupĂ©rĂ© chaque page.++Pour lâutiliser avec des sessions de navigateur, configurez-le ainsi :++```python+from scrapling.fetchers import AsyncStealthySession, ProxyRotator++# String proxies work for all session types+rotator = ProxyRotator([+ "http://proxy1:8080",+ "http://proxy2:8080",+])++# Dict proxies (Playwright format) work for browser sessions+rotator = ProxyRotator([+ {"server": "http://proxy1:8080", "username": "user", "password": "pass"},+ {"server": "http://proxy2:8080"},+])++# Then inside the spider+def configure_sessions(self, manager):+ rotator = ProxyRotator(["http://proxy1:8080", "http://proxy2:8080"])+ manager.add("browser", AsyncStealthySession(proxy_rotator=rotator))+```++!!! info "Information"++ 1. Vous ne pouvez pas utiliser `proxy_rotator` avec les paramĂštres fixes `proxy` ou `proxies` dans la mĂȘme session. Choisissez une approche lors de la configuration. Vous pourrez ensuite choisir un autre proxy pour une requĂȘte prĂ©cise, comme expliquĂ© plus loin.+ 2. Par dĂ©faut, les sessions de navigateur utilisent un contexte persistant avec un groupe dâonglets. Les navigateurs ne permettent pas de choisir un proxy par onglet. Avec `ProxyRotator`, le fetcher ouvre donc un contexte sĂ©parĂ© pour chaque proxy, avec un onglet par contexte. Quand le travail de lâonglet est terminĂ©, lâonglet et son contexte sont fermĂ©s.++## StratĂ©gies de rotation personnalisĂ©es {#custom-rotation-strategies}++Par dĂ©faut, `ProxyRotator` parcourt les proxies dans lâordre puis revient au premier aprĂšs le dernier.++Vous pouvez fournir une fonction avec votre propre stratĂ©gie pour changer ce comportement. Elle doit avoir cette signature :++```python+from scrapling.core._types import ProxyType++def my_strategy(proxies: list, current_index: int) -> tuple[ProxyType, int]:+ ...+```++La fonction reçoit la liste des proxies et lâindice actuel. Elle doit renvoyer le proxy choisi et lâindice suivant.++Voici quelques exemples de stratĂ©gies que vous pouvez utiliser.++### Rotation alĂ©atoire {#random-rotation}++```python+import random+from scrapling.fetchers import ProxyRotator++def random_strategy(proxies, current_index):+ idx = random.randint(0, len(proxies) - 1)+ return proxies[idx], idx++rotator = ProxyRotator(+ ["http://proxy1:8080", "http://proxy2:8080", "http://proxy3:8080"],+ strategy=random_strategy,+)+```++### Rotation pondĂ©rĂ©e {#weighted-rotation}++```python+import random++def weighted_strategy(proxies, current_index):+ # First proxy gets 60% of traffic, others split the rest+ weights = [60] + [40 // (len(proxies) - 1)] * (len(proxies) - 1)+ proxy = random.choices(proxies, weights=weights, k=1)[0]+ return proxy, current_index # Index doesn't matter for weighted++rotator = ProxyRotator(proxies, strategy=weighted_strategy)+```++## Choisir un proxy pour une requĂȘte {#per-request-proxy-override}++Vous pouvez ignorer le rotateur pour une requĂȘte prĂ©cise en passant lâargument `proxy=` :++```python+async def parse(self, response: Response):+ # This request uses the rotator's next proxy+ yield response.follow("/page1", callback=self.parse_page)++ # This request uses a specific proxy, bypassing the rotator+ yield response.follow(+ "/special-page",+ callback=self.parse_page,+ proxy="http://special-proxy:8080",+ )+```++Câest utile quand une page exige un proxy prĂ©cis, par exemple situĂ© dans une rĂ©gion donnĂ©e pour accĂ©der Ă du contenu local.++## Traiter les requĂȘtes bloquĂ©es {#blocked-request-handling}++Le spider intĂšgre la dĂ©tection des blocages et les nouvelles tentatives. Par dĂ©faut, il considĂšre les rĂ©ponses avec ces codes HTTP comme bloquĂ©es : `401`, `403`, `407`, `429`, `444`, `500`, `502`, `503` et `504`.++Le systĂšme de nouvelles tentatives fonctionne ainsi :++1. Quand une rĂ©ponse arrive, le spider appelle `is_blocked(response)`.+2. Sâil dĂ©tecte un blocage, il copie la requĂȘte et appelle `retry_blocked_request()` pour vous permettre de la modifier avant de rĂ©essayer.+3. La requĂȘte retourne dans la file avec `dont_filter=True`, pour autoriser le doublon, et une prioritĂ© plus faible pour ne pas ĂȘtre rĂ©pĂ©tĂ©e immĂ©diatement.+4. Le processus se rĂ©pĂšte jusquâĂ `max_blocked_retries` fois. La valeur par dĂ©faut est 3.++!!! tip "Conseil"++ 1. Avant la nouvelle tentative, les arguments `proxy`/`proxies` sont retirĂ©s de la requĂȘte pour que le rotateur choisisse un nouveau proxy.+ 2. `max_blocked_retries` est indĂ©pendant des nouvelles tentatives de la session. Les compteurs sont sĂ©parĂ©s.++### Personnaliser la dĂ©tection des blocages {#custom-block-detection}++RedĂ©finissez `is_blocked()` pour ajouter votre propre logique :++```python+class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]++ async def is_blocked(self, response: Response) -> bool:+ # Check status codes (default behavior)+ if response.status in {403, 429, 503}:+ return True++ # Check response content+ body = response.body.decode("utf-8", errors="ignore")+ if "access denied" in body.lower() or "rate limit" in body.lower():+ return True++ return False++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++### Personnaliser les nouvelles tentatives {#customizing-retries}++RedĂ©finissez `retry_blocked_request()` pour modifier la requĂȘte avant de rĂ©essayer. Lâattribut `max_blocked_retries` indique combien de fois une requĂȘte bloquĂ©e est rĂ©pĂ©tĂ©e. Sa valeur par dĂ©faut est 3 :++```python+from scrapling.spiders import Spider, SessionManager, Request, Response+from scrapling.fetchers import FetcherSession, AsyncStealthySession+++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ max_blocked_retries = 5++ def configure_sessions(self, manager: SessionManager) -> None:+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari']))+ manager.add('stealth', AsyncStealthySession(block_webrtc=True), lazy=True)++ async def retry_blocked_request(self, request: Request, response: Response) -> Request:+ request.sid = "stealth"+ self.logger.info(f"Retrying blocked request: {request.url}")+ return request++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++Dans cet exemple, la dĂ©tection des blocages par dĂ©faut est conservĂ©e. Le spider utilise des requĂȘtes HTTP jusquâĂ un blocage, puis passe au navigateur furtif.++Nous pouvons maintenant tout combiner :++```python+from scrapling.spiders import Spider, SessionManager, Request, Response+from scrapling.fetchers import FetcherSession, AsyncStealthySession, ProxyRotator+++cheap_proxies = ProxyRotator([ "http://proxy1:8080", "http://proxy2:8080"])++# A format acceptable by the browser+expensive_proxies = ProxyRotator([+ {"server": "http://residential_proxy1:8080", "username": "user", "password": "pass"},+ {"server": "http://residential_proxy2:8080", "username": "user", "password": "pass"},+ {"server": "http://mobile_proxy1:8080", "username": "user", "password": "pass"},+ {"server": "http://mobile_proxy2:8080", "username": "user", "password": "pass"},+])+++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]+ max_blocked_retries = 5++ def configure_sessions(self, manager: SessionManager) -> None:+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari'], proxy_rotator=cheap_proxies))+ manager.add('stealth', AsyncStealthySession(block_webrtc=True, proxy_rotator=expensive_proxies), lazy=True)++ async def retry_blocked_request(self, request: Request, response: Response) -> Request:+ request.sid = "stealth"+ self.logger.info(f"Retrying blocked request: {request.url}")+ return request++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++La logique est la suivante : les requĂȘtes utilisent des proxies bon marchĂ©, comme ceux de centres de donnĂ©es, jusquâĂ un blocage. Elles sont alors rĂ©essayĂ©es avec des proxies de meilleure qualitĂ©, comme des proxies rĂ©sidentiels ou mobiles.diff --git a/docs/locales/fr/spiders/requests-responses.md b/docs/locales/fr/spiders/requests-responses.mdnew file mode 100644index 0000000..7168a34--- /dev/null+++ b/docs/locales/fr/spiders/requests-responses.md@@ -0,0 +1,207 @@+---+title: "RequĂȘtes, callbacks et Response.follow dans les spiders"+description: "CrĂ©ez des requĂȘtes, transmettez des mĂ©tadonnĂ©es et suivez des liens avec response.follow. DĂ©couvrez les callbacks, les prioritĂ©s et la suppression des doublons."+---++# RequĂȘtes et rĂ©ponses {#requests-responses}++!!! success "Avant de commencer"++ 1. Lisez la page [Premiers pas](getting-started.md) pour apprendre Ă crĂ©er et exĂ©cuter un spider simple.++Cette page explique lâobjet `Request` : comment crĂ©er des requĂȘtes, transmettre des donnĂ©es entre callbacks, gĂ©rer la prioritĂ© et les doublons, et suivre des liens avec `response.follow()`.++## Lâobjet Request {#the-request-object}++Un `Request` reprĂ©sente une URL Ă rĂ©cupĂ©rer. Vous pouvez crĂ©er des requĂȘtes directement ou avec `response.follow()` :++```python+from scrapling.spiders import Request++# Direct construction+request = Request(+ "https://example.com/page",+ callback=self.parse_page,+ priority=5,+)++# Via response.follow (preferred in callbacks)+request = response.follow("/page", callback=self.parse_page)+```++Voici tous les arguments acceptĂ©s par `Request` :++| Argument | Type | Valeur par dĂ©faut | Description |+|----------|------|-------------------|-------------|+| `url` | `str` | *obligatoire* | URL Ă rĂ©cupĂ©rer |+| `sid` | `str` | `""` | Identifiant de session. Envoie la requĂȘte vers une session prĂ©cise (voir [Sessions](sessions.md)) |+| `callback` | `callable` | `None` | MĂ©thode gĂ©nĂ©ratrice asynchrone qui traite la rĂ©ponse. Utilise `parse()` par dĂ©faut |+| `priority` | `int` | `0` | Les valeurs les plus Ă©levĂ©es sont traitĂ©es en premier |+| `dont_filter` | `bool` | `False` | Si la valeur est `True`, autorise les requĂȘtes en double |+| `meta` | `dict` | `{}` | MĂ©tadonnĂ©es de votre choix transmises Ă la rĂ©ponse |+| `**kwargs` | | | Arguments supplĂ©mentaires transmis Ă la mĂ©thode de rĂ©cupĂ©ration de la session, comme `headers`, `method` ou `data` |++Les arguments supplĂ©mentaires sont envoyĂ©s directement Ă la session. Par exemple, pour faire une requĂȘte POST :++```python+yield Request(+ "https://example.com/api",+ method="POST",+ data={"key": "value"},+ callback=self.parse_result,+)+```++## Response.follow() {#responsefollow}++`response.follow()` est la mĂ©thode recommandĂ©e pour crĂ©er de nouvelles requĂȘtes dans un callback. Elle offre plusieurs avantages par rapport Ă la crĂ©ation directe dâobjets `Request` :++- Les **URL relatives** sont rĂ©solues Ă partir de lâURL de la page actuelle.+- Lâ**en-tĂȘte Referer** utilise lâURL de la page actuelle par dĂ©faut.+- Les **arguments de session** de la requĂȘte dâorigine sont repris, comme les en-tĂȘtes et les rĂ©glages du proxy, sauf `method`, `params`, `data`, `json`, `files` et `multipart`. Les liens sont donc suivis avec de simples requĂȘtes GET.+- Le **callback, lâidentifiant de session et la prioritĂ©** sont repris de la requĂȘte dâorigine si vous ne les indiquez pas.++```python+async def parse(self, response: Response):+ # Minimal - inherits callback, sid, priority from current request+ yield response.follow("/next-page")++ # Override specific fields+ yield response.follow(+ "/product/123",+ callback=self.parse_product,+ priority=10,+ )++ # Pass additional metadata to+ yield response.follow(+ "/details",+ callback=self.parse_details,+ meta={"category": "electronics"},+ )+```++| Argument | Type | Valeur par dĂ©faut | Description |+|----------|------|-------------------|-------------|+| `url` | `str` | *obligatoire* | URL Ă suivre, absolue ou relative |+| `sid` | `str` | `""` | Identifiant de session. Repris de la requĂȘte dâorigine sâil est vide |+| `callback` | `callable` | `None` | MĂ©thode callback. Reprise de la requĂȘte dâorigine si la valeur est `None` |+| `priority` | `int` | `None` | PrioritĂ©. Reprise de la requĂȘte dâorigine si la valeur est `None` |+| `dont_filter` | `bool` | `False` | Autorise les requĂȘtes en double |+| `meta` | `dict` | `None` | MĂ©tadonnĂ©es combinĂ©es avec celles de la rĂ©ponse |+| **`referer_flow`** | `bool` | `True` | Utilise lâURL actuelle comme en-tĂȘte Referer |+| `**kwargs` | | | CombinĂ©s avec les arguments de session de la requĂȘte dâorigine |++### DĂ©sactiver lâenvoi de Referer {#disabling-referer-flow}++Par dĂ©faut, `response.follow()` utilise lâURL de la page actuelle comme en-tĂȘte `Referer`. Pour le dĂ©sactiver :++```python+yield response.follow("/page", referer_flow=False)+```++## Callbacks {#callbacks}++Les callbacks sont des mĂ©thodes gĂ©nĂ©ratrices asynchrones du spider qui traitent les rĂ©ponses. Elles doivent utiliser `yield` pour produire un de ces trois types :++- **`dict`** : un Ă©lĂ©ment extrait, ajoutĂ© aux rĂ©sultats.+- **`Request`** : une nouvelle requĂȘte, ajoutĂ©e Ă la file.+- **`None`** : ignorĂ© sans message.++```python+class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]++ async def parse(self, response: Response):+ # Yield items (dicts)+ yield {"url": response.url, "title": response.css("title::text").get("")}++ # Yield follow-up requests+ for link in response.css("a::attr(href)").getall():+ yield response.follow(link, callback=self.parse_page)++ async def parse_page(self, response: Response):+ yield {"content": response.css("article::text").get("")}+```++!!! tip "Note"++ Tous les callbacks doivent utiliser `async def` et `yield`, pas `return`. MĂȘme si un callback produit seulement des Ă©lĂ©ments, sans nouvelle requĂȘte, il doit rester un gĂ©nĂ©rateur asynchrone.++## PrioritĂ© des requĂȘtes {#request-priority}++Les requĂȘtes dont la prioritĂ© est la plus Ă©levĂ©e sont traitĂ©es en premier. Cela sert quand certaines pages doivent ĂȘtre traitĂ©es avant les autres :++```python+async def parse(self, response: Response):+ # High priority - process product pages first+ for link in response.css("a.product::attr(href)").getall():+ yield response.follow(link, callback=self.parse_product, priority=10)++ # Low priority - pagination links processed after products+ next_page = response.css("a.next::attr(href)").get()+ if next_page:+ yield response.follow(next_page, callback=self.parse, priority=0)+```++Avec `response.follow()`, la prioritĂ© est reprise de la requĂȘte dâorigine, sauf si vous en dĂ©finissez une autre.++## Supprimer les doublons {#deduplication}++Le spider Ă©vite les requĂȘtes en double grĂące Ă une empreinte calculĂ©e Ă partir de lâURL, de la mĂ©thode HTTP, du corps et de lâidentifiant de session. Si deux requĂȘtes ont la mĂȘme empreinte, la seconde est Ă©cartĂ©e sans message.++Pour autoriser une requĂȘte en double, par exemple pour revenir sur une page aprĂšs une connexion, utilisez `dont_filter=True` :++```python+yield Request("https://example.com/dashboard", dont_filter=True, callback=self.parse_dashboard)++# Or with response.follow+yield response.follow("/dashboard", dont_filter=True, callback=self.parse_dashboard)+```++Vous pouvez choisir les donnĂ©es incluses dans lâempreinte avec ces attributs de classe du spider :++| Attribut | Valeur par dĂ©faut | Effet |+|----------|-------------------|-------|+| `fp_include_kwargs` | `False` | Inclut dans lâempreinte les arguments supplĂ©mentaires transmis Ă la mĂ©thode de rĂ©cupĂ©ration de la session, comme les en-tĂȘtes |+| `fp_keep_fragments` | `False` | Garde les fragments dâURL (`#section`) lors du calcul de lâempreinte |+| `fp_include_headers` | `False` | Inclut les en-tĂȘtes de la requĂȘte dans lâempreinte |++Par exemple, pour traiter `https://example.com/page#section1` et `https://example.com/page#section2` comme des URL diffĂ©rentes :++```python+class MySpider(Spider):+ name = "my_spider"+ fp_keep_fragments = True+ # ...+```++## MĂ©tadonnĂ©es de la requĂȘte {#request-meta}++Le dictionnaire `meta` permet de transmettre des donnĂ©es entre callbacks. Il est utile quand vous avez besoin dâinformations dâune page pour en traiter une autre :++```python+async def parse(self, response: Response):+ for product in response.css("div.product"):+ category = product.css("span.category::text").get("")+ link = product.css("a::attr(href)").get()+ if link:+ yield response.follow(+ link,+ callback=self.parse_product,+ meta={"category": category},+ )++async def parse_product(self, response: Response):+ yield {+ "name": response.css("h1::text").get(""),+ "price": response.css(".price::text").get(""),+ # Access meta from the request+ "category": response.meta.get("category", ""),+ }+```++Avec `response.follow()`, les mĂ©tadonnĂ©es de la rĂ©ponse actuelle sont combinĂ©es avec les nouvelles valeurs fournies. Les nouvelles valeurs ont prioritĂ©.++Le systĂšme de spiders enregistre aussi certaines mĂ©tadonnĂ©es automatiquement. Par exemple, quand la rotation des proxies est active, le proxy utilisĂ© pour une requĂȘte est disponible dans `response.meta["proxy"]`.diff --git a/docs/locales/fr/spiders/sessions.md b/docs/locales/fr/spiders/sessions.mdnew file mode 100644index 0000000..6dc013e--- /dev/null+++ b/docs/locales/fr/spiders/sessions.md@@ -0,0 +1,230 @@+---+title: "Utilisez des sessions HTTP et navigateur dans un mĂȘme spider"+description: "Configurez des sessions nommĂ©es et envoyez les requĂȘtes du spider par HTTP ou par un navigateur. RĂ©utilisez les cookies, dĂ©marrez les sessions Ă la demande et consultez lâhistorique des API."+---++# Sessions des spiders {#spiders-sessions}++!!! success "Avant de commencer"++ 1. Lisez la page [Premiers pas](getting-started.md) pour apprendre Ă crĂ©er et exĂ©cuter un spider simple.+ 2. Consultez les [Bases des fetchers](../fetching/choosing.md) et les diffĂ©rences entre les sessions HTTP et Stealthy.++Un spider peut utiliser plusieurs sessions de fetcher en mĂȘme temps. Par exemple, une session HTTP rapide pour les pages simples et un navigateur furtif pour les pages protĂ©gĂ©es. Cette page explique comment configurer et utiliser les sessions.++## Quâest-ce quâune session ? {#what-are-sessions}++Une session est une instance de fetcher dĂ©jĂ configurĂ©e qui reste active pendant lâexploration. Au lieu de crĂ©er une connexion ou un navigateur pour chaque requĂȘte, le spider rĂ©utilise les sessions. Câest plus rapide et cela consomme moins de ressources.++Par dĂ©faut, chaque spider crĂ©e une seule [FetcherSession](../fetching/static.md). Vous pouvez ajouter dâautres sessions ou changer celle par dĂ©faut en redĂ©finissant `configure_sessions()`. Utilisez uniquement la version asynchrone de chaque session, comme dans ce tableau :++| Type de session | Utilisation |+|-----------------|-------------|+| [FetcherSession](../fetching/static.md) | RequĂȘtes HTTP rapides, sans JavaScript |+| [AsyncStealthySession](../fetching/stealthy.md) | JavaScript, automatisation du navigateur et contournement des protections antibot |++## Configurer les sessions {#configuring-sessions}++RedĂ©finissez `configure_sessions()` dans votre spider. Le paramĂštre `manager` est une instance de `SessionManager`. Utilisez `manager.add()` pour enregistrer chaque session :++```python+from scrapling.spiders import Spider, Response+from scrapling.fetchers import FetcherSession++class MySpider(Spider):+ name = "my_spider"+ start_urls = ["https://example.com"]++ def configure_sessions(self, manager):+ manager.add("default", FetcherSession())++ async def parse(self, response: Response):+ yield {"title": response.css("title::text").get("")}+```++La mĂ©thode `manager.add()` accepte ces arguments :++| Argument | Type | Valeur par dĂ©faut | Description |+|----------|------|-------------------|-------------|+| `session_id` | `str` | *obligatoire* | Nom utilisĂ© pour dĂ©signer cette session dans les requĂȘtes |+| `session` | `Session` | *obligatoire* | Instance de la session |+| `default` | `bool` | `False` | Utilise cette session par dĂ©faut |+| `lazy` | `bool` | `False` | DĂ©marre la session uniquement Ă sa premiĂšre utilisation |++!!! note "Notes"++ 1. Si une requĂȘte ne prĂ©cise pas la session Ă utiliser, la session par dĂ©faut est choisie. Elle est dĂ©finie de deux façons :+ 1. La premiĂšre session ajoutĂ©e au gestionnaire devient celle par dĂ©faut.+ 2. Vous pouvez en choisir une autre en lâajoutant avec `default=True`.+ 2. Vous nâavez pas besoin de dĂ©marrer les sessions avant de les fournir au gestionnaire. Le spider vĂ©rifie celles qui ne sont pas encore actives et les dĂ©marre.+ 3. Pour dĂ©marrer une session seulement quand elle est nĂ©cessaire, utilisez `lazy` lors de son ajout. Vous pouvez ainsi ouvrir le navigateur Ă sa premiĂšre utilisation plutĂŽt quâau lancement du spider.++## Spider avec plusieurs sessions {#multi-session-spider}++Cet exemple utilise une session HTTP rapide pour les pages de listes et un navigateur furtif pour les pages de dĂ©tails avec des protections antibot :++```python+from scrapling.spiders import Spider, Response+from scrapling.fetchers import FetcherSession, AsyncStealthySession++class ProductSpider(Spider):+ name = "products"+ start_urls = ["https://shop.example.com/products"]++ def configure_sessions(self, manager):+ # Fast HTTP for listing pages (default)+ manager.add("http", FetcherSession())++ self.browser_session = AsyncStealthySession(+ headless=True,+ network_idle=True,+ record_requests=True,+ )+ manager.add("stealth", self.browser_session)++ async def parse(self, response: Response):+ for link in response.css("a.product::attr(href)").getall():+ # Route product pages through the stealth session+ yield response.follow(link, sid="stealth", callback=self.parse_product)++ next_page = response.css("a.next::attr(href)").get()+ if next_page:+ yield response.follow(next_page)++ async def parse_product(self, response: Response):+ yield {+ "name": response.css("h1::text").get(""),+ "price": response.css(".price::text").get(""),+ }++ async def on_close(self):+ for api_response in self.browser_session.network.search(+ url_pattern=r"https://api\.shop\.example\.com/.*", limit=None+ ):+ self.logger.info(f"Saved API response: {api_response.url} ({api_response.status})")+```++Lâexemple conserve lâinstance du navigateur et consulte une seule fois son historique de rĂ©ponses dâAPI dans `on_close()`, avant la fermeture des sessions. Lâhistorique couvre toutes les pages de produits et reste lisible aprĂšs la fermeture. Les captures en cours ne sont pas attendues, et les limites de conservation restent appliquĂ©es.++Le paramĂštre `sid` indique au spider quelle session utiliser pour chaque requĂȘte. Si vous appelez `response.follow()` sans `sid`, lâidentifiant de session de la requĂȘte dâorigine est repris.++Les sessions ne doivent pas forcĂ©ment ĂȘtre de classes diffĂ©rentes. Vous pouvez aussi utiliser plusieurs instances de la mĂȘme classe avec des rĂ©glages diffĂ©rents :++```python+from scrapling.spiders import Spider, Response+from scrapling.fetchers import FetcherSession++class ProductSpider(Spider):+ name = "products"+ start_urls = ["https://shop.example.com/products"]++ def configure_sessions(self, manager):+ chrome_requests = FetcherSession(impersonate="chrome")+ firefox_requests = FetcherSession(impersonate="firefox")++ manager.add("chrome", chrome_requests)+ manager.add("firefox", firefox_requests)++ async def parse(self, response: Response):+ for link in response.css("a.product::attr(href)").getall():+ yield response.follow(link, callback=self.parse_product)++ next_page = response.css("a.next::attr(href)").get()+ if next_page:+ yield response.follow(next_page, sid="firefox")++ async def parse_product(self, response: Response):+ yield {+ "name": response.css("h1::text").get(""),+ "price": response.css(".price::text").get(""),+ }+```++Vous pouvez Ă©galement rĂ©server une session, avec ses propres cookies et son Ă©tat, Ă certaines requĂȘtes.++## Arguments de session {#session-arguments}++Les arguments supplĂ©mentaires dâun `Request`, ou de `response.follow(**kwargs)`, sont transmis Ă la mĂ©thode de rĂ©cupĂ©ration de la session. Vous pouvez ainsi ajuster une requĂȘte sans changer la configuration de toute la session :++```python+async def parse(self, response: Response):+ # Pass extra headers for this specific request+ yield Request(+ "https://api.example.com/data",+ headers={"Authorization": "Bearer token123"},+ callback=self.parse_api,+ )++ # Use a different HTTP method+ yield Request(+ "https://example.com/submit",+ method="POST",+ data={"field": "value"},+ sid="firefox",+ callback=self.parse_result,+ )+```++!!! warning "Attention"++ Habituellement, avec `FetcherSession`, `Fetcher` ou `AsyncFetcher`, vous choisissez la mĂ©thode HTTP en appelant `.get()`, `.post()` ou une autre mĂ©thode. Dans un spider, vous ne pouvez pas faire cela avec `FetcherSession`. Les requĂȘtes utilisent _HTTP GET_ par dĂ©faut. Pour choisir une autre mĂ©thode HTTP, passez-la dans lâargument `method`, comme dans lâexemple prĂ©cĂ©dent. Cela permet Ă tous les types de session de partager la mĂȘme interface `Request`.++Avec la session `"stealth"` (`AsyncStealthySession`) de lâexemple prĂ©cĂ©dent, vous pouvez transmettre des arguments propres au navigateur, comme `wait_selector`, `page_action` ou `extra_headers` :++```python+async def parse(self, response: Response):+ # Use Cloudflare solver with the `AsyncStealthySession` we configured above+ yield Request(+ "https://nopecha.com/demo/cloudflare",+ sid="stealth",+ callback=self.parse_result,+ solve_cloudflare=True,+ block_webrtc=True,+ hide_canvas=True,+ google_search=True,+ )++ yield response.follow(+ "/dynamic-page",+ sid="stealth",+ callback=self.parse_dynamic,+ wait_selector="div.loaded",+ network_idle=True,+ )+```++!!! warning "Attention"++ `response.follow()` reprend les arguments de session (**kwargs) de la requĂȘte dâorigine, sauf `method`, `params`, `data`, `json`, `files` et `multipart`. Suivre un lien aprĂšs un POST envoie donc un simple GET. Les nouveaux arguments ont prioritĂ© sur ceux qui sont repris.++```python+from scrapling.spiders import Spider, Response+from scrapling.fetchers import FetcherSession++class ProductSpider(Spider):+ name = "products"+ start_urls = ["https://shop.example.com/products"]++ def configure_sessions(self, manager):+ manager.add("http", FetcherSession(impersonate='chrome'))++ async def parse(self, response: Response):+ # I don't want the follow request to impersonate a desktop Chrome like the previous request, but a mobile one+ # so I override it like this+ for link in response.css("a.product::attr(href)").getall():+ yield response.follow(link, impersonate="chrome131_android", callback=self.parse_product)++ next_page = response.css("a.next::attr(href)").get()+ if next_page:+ yield response.follow(next_page)++ async def parse_product(self, response: Response):+ yield {+ "name": response.css("h1::text").get(""),+ "price": response.css(".price::text").get(""),+ }+```++!!! info "Information"++ Ă lâarrĂȘt du spider, le gestionnaire vĂ©rifie si des sessions sont encore actives et les ferme avant de terminer.diff --git a/docs/locales/fr/stylesheets b/docs/locales/fr/stylesheetsnew file mode 120000index 0000000..02c6ba6--- /dev/null+++ b/docs/locales/fr/stylesheets@@ -0,0 +1 @@+../../stylesheets\ No newline at end of filediff --git a/docs/locales/fr/tutorials/migrating_from_beautifulsoup.md b/docs/locales/fr/tutorials/migrating_from_beautifulsoup.mdnew file mode 100644index 0000000..0ba2f10--- /dev/null+++ b/docs/locales/fr/tutorials/migrating_from_beautifulsoup.md@@ -0,0 +1,99 @@+---+title: "Passer de BeautifulSoup Ă Scrapling"+description: "Comparez les tĂąches courantes de sĂ©lection, de texte, dâattributs et de navigation entre BeautifulSoup et Scrapling. DĂ©couvrez les diffĂ©rences dâAPI avec des exemples pratiques."+---++# Passer de BeautifulSoup Ă Scrapling {#migrating-from-beautifulsoup-to-scrapling}++Si vous connaissez dĂ©jĂ BeautifulSoup, vous prendrez vite Scrapling en main. Il est bien plus rapide, offre les mĂȘmes fonctions dâanalyse que BS et en ajoute dâautres que BS nâa pas. Il fournit aussi des outils pour rĂ©cupĂ©rer des pages web modernes et travailler avec elles. Ce guide vous aide Ă adapter votre code BeautifulSoup Ă Scrapling.++Le tableau suivant prĂ©sente les tĂąches les plus courantes lors de lâextraction de donnĂ©es web. Chaque ligne montre comment rĂ©aliser une tĂąche avec BeautifulSoup et la mĂ©thode correspondante dans Scrapling.++Vous remarquerez que certains raccourcis de BeautifulSoup nâexistent pas dans Scrapling. Câest une des raisons pour lesquelles BeautifulSoup est plus lent. LâidĂ©e est simple : si une fonction tient dĂ©jĂ sur une ligne courte, il nâest pas nĂ©cessaire de sacrifier les performances pour la raccourcir un peu plus :)++| TĂąche | Code BeautifulSoup | Code Scrapling |+|---|---|---|+| Importer le parser | `from bs4 import BeautifulSoup` | `from scrapling.parser import Selector` |+| Analyser du HTML depuis une chaĂźne | `soup = BeautifulSoup(html, 'html.parser')` | `page = Selector(html)` |+| Trouver un Ă©lĂ©ment | `element = soup.find('div', class_='example')` | `element = page.find('div', class_='example')` |+| Trouver plusieurs Ă©lĂ©ments | `elements = soup.find_all('div', class_='example')` | `elements = page.find_all('div', class_='example')` |+| Trouver un Ă©lĂ©ment (exemple 2) | `element = soup.find('div', attrs={"class": "example"})` | `element = page.find('div', {"class": "example"})` |+| Trouver un Ă©lĂ©ment (exemple 3) | `element = soup.find(re.compile("^b"))` | `element = page.find(lambda e: re.search(r"^b", e.tag) is not None)` |+| Trouver un Ă©lĂ©ment (exemple 4) | `element = soup.find(lambda e: len(list(e.children)) > 0)` | `element = page.find(lambda e: len(e.children) > 0)` |+| Trouver un Ă©lĂ©ment (exemple 5) | `element = soup.find(["a", "b"])` | `element = page.find(["a", "b"])` |+| Trouver un Ă©lĂ©ment par son texte | `element = soup.find(text="some text")` | `element = page.find_by_text("some text", partial=False)` |+| Utiliser CSS pour trouver la premiĂšre correspondance | `elements = soup.select_one('div.example')` | `elements = page.css('div.example').first` |+| Utiliser CSS pour trouver toutes les correspondances | `elements = soup.select('div.example')` | `elements = page.css('div.example')` |+| Obtenir le code de la page ou de lâĂ©lĂ©ment avec une mise en forme lisible | `prettified = soup.prettify()` | `prettified = page.prettify()` |+| Obtenir le code de la page ou de lâĂ©lĂ©ment sans mise en forme supplĂ©mentaire | `source = str(soup)` | `source = page.html_content` |+| Obtenir le nom de balise dâun Ă©lĂ©ment | `name = element.name` | `name = element.tag` |+| Extraire le texte dâun Ă©lĂ©ment | `string = element.string` | `string = element.text` |+| Extraire tout le texte dâun document ou sous une balise | `text = soup.get_text(strip=True)` | `text = page.get_all_text(strip=True)` |+| AccĂ©der au dictionnaire des attributs | `attrs = element.attrs` | `attrs = element.attrib` |+| Extraire des attributs | `attr = element['href']` | `attr = element['href']` |+| AccĂ©der Ă lâĂ©lĂ©ment parent | `parent = element.parent` | `parent = element.parent` |+| Obtenir tous les ancĂȘtres dâun Ă©lĂ©ment | `parents = list(element.parents)` | `parents = list(element.iterancestors())` |+| Chercher un Ă©lĂ©ment parmi les ancĂȘtres | `target_parent = element.find_parent("a")` | `target_parent = element.find_ancestor(lambda p: p.tag == 'a')` |+| Obtenir tous les Ă©lĂ©ments frĂšres | Non disponible | `siblings = element.siblings` |+| Obtenir lâĂ©lĂ©ment frĂšre suivant | `next_element = element.next_sibling` | `next_element = element.next` |+| Chercher un Ă©lĂ©ment parmi les frĂšres | `target_sibling = element.find_next_sibling("a")`<br/>`target_sibling = element.find_previous_sibling("a")` | `target_sibling = element.siblings.search(lambda s: s.tag == 'a')` |+| Chercher plusieurs Ă©lĂ©ments parmi les frĂšres | `target_sibling = element.find_next_siblings("a")`<br/>`target_sibling = element.find_previous_siblings("a")` | `target_sibling = element.siblings.filter(lambda s: s.tag == 'a')` |+| Chercher un Ă©lĂ©ment parmi les Ă©lĂ©ments suivants | `target_parent = element.find_next("a")` | `target_parent = element.below_elements.search(lambda p: p.tag == 'a')` |+| Chercher plusieurs Ă©lĂ©ments parmi les Ă©lĂ©ments suivants | `target_parent = element.find_all_next("a")` | `target_parent = element.below_elements.filter(lambda p: p.tag == 'a')` |+| Chercher un Ă©lĂ©ment parmi les ancĂȘtres | `target_parent = element.find_previous("a")` Âč | `target_parent = element.path.search(lambda p: p.tag == 'a')` |+| Chercher plusieurs Ă©lĂ©ments parmi les ancĂȘtres | `target_parent = element.find_all_previous("a")` Âč | `target_parent = element.path.filter(lambda p: p.tag == 'a')` |+| Obtenir lâĂ©lĂ©ment frĂšre prĂ©cĂ©dent | `prev_element = element.previous_sibling` | `prev_element = element.previous` |+| AccĂ©der aux Ă©lĂ©ments enfants | `children = list(element.children)` | `children = element.children` |+| Obtenir tous les descendants dâun Ă©lĂ©ment | `children = list(element.descendants)` | `children = element.below_elements` |+| SĂ©lectionner les liens dans les paragraphes de classe story | `group = soup.select('p.story a')` | `group = page.css('p.story a')` |++Une expression rĂ©guliĂšre compilĂ©e passĂ©e directement Ă `find()` ou `find_all()` de Scrapling cherche dans le texte des Ă©lĂ©ments, pas dans les noms de balises. Utilisez la lambda du tableau pour chercher par nom de balise, ou `page.find_by_regex(r"^b")` pour chercher directement dans le texte.++Âč **Note :** `find_previous`/`find_all_previous` de BS4 cherchent dans tous les Ă©lĂ©ments prĂ©cĂ©dents selon lâordre du document. En revanche, `path` de Scrapling ne renvoie que les ancĂȘtres, câest-Ă -dire la chaĂźne des Ă©lĂ©ments parents. Ce ne sont pas des Ă©quivalents exacts, mais la recherche parmi les ancĂȘtres couvre le cas le plus courant.++**Un point important** : BeautifulSoup propose des fonctions pour modifier la page aprĂšs son analyse. Scrapling se concentre sur lâextraction rapide des donnĂ©es, puis vous laisse en faire ce dont vous avez besoin. Les deux outils servent Ă extraire des donnĂ©es web, mais lâun dâeux se spĂ©cialise dans cette tĂąche :)++### Un exemple complet {#putting-it-all-together}++Cet exemple montre comment extraire tous les liens dâune page avec BeautifulSoup et Scrapling.++**Avec BeautifulSoup :**++```python+import requests+from bs4 import BeautifulSoup++url = 'https://example.com'+response = requests.get(url)+soup = BeautifulSoup(response.text, 'html.parser')++links = soup.find_all('a')+for link in links:+ print(link['href'])+```++**Avec Scrapling :**++```python+from scrapling import Fetcher++url = 'https://example.com'+page = Fetcher.get(url)++links = page.css('a::attr(href)').getall()+for link in links:+ print(link)+```++Comme vous le voyez, Scrapling rĂ©unit la rĂ©cupĂ©ration et lâanalyse de la page en une seule Ă©tape. Le code devient plus simple et plus efficace.++!!! abstract "**Notes supplĂ©mentaires :**"++ - **Des parsers diffĂ©rents** : BeautifulSoup permet de choisir le moteur dâanalyse, dont `lxml`. Scrapling utilise la bibliothĂšque `lxml` par dĂ©faut pour des raisons de performances.+ - **Types dâĂ©lĂ©ments** : Dans BeautifulSoup, les Ă©lĂ©ments sont des objets `Tag` ; dans Scrapling, ce sont des objets `Selector`. Les deux proposent des mĂ©thodes et propriĂ©tĂ©s similaires pour naviguer et extraire des donnĂ©es.+ - **Gestion des erreurs** : Les deux bibliothĂšques renvoient `None` lorsquâun Ă©lĂ©ment nâest pas trouvĂ©, par exemple avec `soup.find()` ou `page.find()`. Dans Scrapling, `page.css()` renvoie une liste `Selectors` vide si rien ne correspond. Vous pouvez utiliser `page.css('.foo').first` pour obtenir la premiĂšre correspondance ou `None`. Pour Ă©viter les erreurs, vĂ©rifiez si le rĂ©sultat vaut `None` ou sâil est vide avant dâaccĂ©der aux propriĂ©tĂ©s.+ - **Extraction de texte** : Scrapling offre dâautres mĂ©thodes pour traiter le texte avec `TextHandler`, comme `clean()`. Cette mĂ©thode aide Ă supprimer les espaces superflus, les espaces consĂ©cutifs ou les caractĂšres indĂ©sirables. Consultez la documentation pour voir la liste complĂšte.++La documentation dĂ©crit les fonctions de Scrapling plus en dĂ©tail et donne la liste de tous les arguments acceptĂ©s par chaque mĂ©thode.++Nous espĂ©rons que ce guide facilitera votre passage de BeautifulSoup Ă Scrapling. Bonne extraction !diff --git a/docs/locales/fr/tutorials/replacing_ai.md b/docs/locales/fr/tutorials/replacing_ai.mdnew file mode 100644index 0000000..b60a700--- /dev/null+++ b/docs/locales/fr/tutorials/replacing_ai.md@@ -0,0 +1,121 @@+---+title: "Une solution gratuite pour extraire des donnĂ©es web de façon fiable sans IA"+description: "Scrapling gĂšre les pages qui changent, les sĂ©lecteurs instables, les protections antibot et la pagination sans appeler un LLM pour chaque page."+---++# Scrapling : une solution gratuite pour extraire des donnĂ©es web de façon fiable sans IA {#scrapling-a-free-alternative-to-ai-for-robust-web-scraping}++Lâextraction de donnĂ©es web sert depuis longtemps Ă collecter des informations, indexer du contenu et prĂ©parer des jeux de donnĂ©es, entre autres usages. Mais les utilisateurs expĂ©rimentĂ©s rencontrent souvent des problĂšmes qui compliquent le travail. RĂ©cemment, lâintĂ©rĂȘt pour lâextraction avec lâIA a augmentĂ©, car elle peut rĂ©soudre une partie de ces difficultĂ©s.++Dans cet article, nous verrons ces problĂšmes courants, pourquoi les entreprises se tournent vers lâIA, les limites de cette approche et comment Scrapling peut vous aider sans le coĂ»t de lâIA.++## ProblĂšmes courants et objectifs difficiles {#common-issues-and-challenging-goals}++Si vous extrayez des donnĂ©es web depuis un certain temps, vous avez sans doute dĂ©jĂ rencontrĂ© ces problĂšmes :++1. **Des structures de sites qui changent souvent** : Les sites modifient leur DOM et les sĂ©lecteurs XPath/CSS fixes ne fonctionnent plus.+2. **Des sĂ©lecteurs instables** : Les noms de classes et les identifiants changent ou sont gĂ©nĂ©rĂ©s au hasard. Cela casse les scrapers ou rend lâextraction difficile.+3. **Des protections antibot de plus en plus complexes** : Les CAPTCHA, lâempreinte du navigateur et lâanalyse du comportement compliquent lâextraction classique.++Et ce ne sont pas les seuls. Tout cela arrive mĂȘme avec des sites connus pour lesquels vous pouvez Ă©crire du code prĂ©cis.++Si vous voulez aller plus loin et extraire des donnĂ©es sur de nombreux sites diffĂ©rents, ce quâon appelle parfois Broad Scraping ou Generic Web Scraping, ces difficultĂ©s augmentent et dâautres apparaissent :++1. **Une grande diversitĂ© de sites** : Un scraper gĂ©nĂ©rique doit gĂ©rer de nombreuses structures HTML, façons dâutiliser CSS, frameworks JavaScript et technologies cĂŽtĂ© serveur.+2. **Trouver les donnĂ©es utiles** : Comment le scraper sait-il quelles donnĂ©es comptent sur une page quâil nâa jamais vue ?+3. **DiffĂ©rentes formes de pagination** : Le dĂ©filement infini, les pages numĂ©rotĂ©es et les boutons pour charger plus de contenu demandent des approches diffĂ©rentes.++Et la liste continue. Comment rĂ©soudre tout cela Ă la main ? Je parle ici de sites diffĂ©rents qui ne partagent pas les mĂȘmes technologies.++## LâIA aide, mais coĂ»te cher {#ai-to-the-rescue-but-at-a-high-cost}++LâIA peut rĂ©soudre beaucoup de ces problĂšmes parce quâelle comprend le code de la page, trouve les champs souhaitĂ©s ou crĂ©e des sĂ©lecteurs pour eux. Bien sĂ»r, cela suppose que vous avez dĂ©jĂ gĂ©rĂ© les protections antibot avec dâautres outils :)++Jâaime cette approche. Je trouve lâIA fascinante, surtout lâIA gĂ©nĂ©rative. Vous passerez probablement beaucoup de temps Ă rĂ©gler les instructions donnĂ©es au modĂšle. Si cela ne vous gĂȘne pas, vous arriverez vite au vrai problĂšme de lâIA dans ce contexte.++Beaucoup de pages contiennent Ă©normĂ©ment de contenu, quâil faut transmettre dâune façon ou dâune autre au modĂšle. Cela consomme des tokens trĂšs vite et les coĂ»ts peuvent grimper rapidement.++Ă moins que le budget ne compte pas pour vous, vous chercherez des solutions moins chĂšres. Câest lĂ que Scrapling intervient :smile:++## Scrapling vous aide {#scrapling-got-you-covered}++Scrapling peut gĂ©rer presque tous les problĂšmes que vous rencontrerez en extrayant des donnĂ©es web. Les prochaines mises Ă jour prendront en charge les autres.++### RĂ©soudre T1 : des structures de sites qui changent souvent {#solving-issue-t1-rapidly-changing-website-structures}++Câest pour cela que la fonction [adaptive](../parsing/adaptive.md) existe. Vous saviez que jâallais en parler, et nous y voilĂ :)++Avec `adaptive` activĂ©, vous pouvez enregistrer les propriĂ©tĂ©s qui distinguent un Ă©lĂ©ment pour le retrouver plus tard, mĂȘme si la structure du site change. Le plus difficile est que nâimporte quelle partie de lâĂ©lĂ©ment peut changer. Il nây a donc pas toujours de propriĂ©tĂ© fixe sur laquelle sâappuyer.++La fonction enregistre tout ce qui distingue lâĂ©lĂ©ment. Lorsque la structure du site change, elle renvoie lâĂ©lĂ©ment dont le score de ressemblance avec lâancien est le plus Ă©levĂ©.++Jâai dĂ©jĂ expliquĂ© cela en dĂ©tail, avec plusieurs exemples. Vous pouvez les lire [ici](../parsing/adaptive.md#how-the-adaptive-scraping-feature-works).++### RĂ©soudre T2 : des sĂ©lecteurs instables {#solving-issue-t2-unstable-selectors}++Si vous extrayez des donnĂ©es depuis longtemps, cela vous est sans doute arrivĂ© : un site en HTML sans identifiants ni classes, des noms de classes alĂ©atoires ou une structure qui nâoffre rien de stable pour sĂ©lectionner les Ă©lĂ©ments.++Dans ces cas, les sĂ©lecteurs CSS/XPath classiques ne sont pas toujours le meilleur choix. Scrapling propose donc trois autres façons de sĂ©lectionner les Ă©lĂ©ments :++1. [SĂ©lectionner par le contenu](../parsing/selection.md#text-content-selection) : Cherchez du texte avec `find_by_text`, ou utilisez une expression rĂ©guliĂšre qui correspond au texte avec `find_by_regex`.+2. [SĂ©lectionner des Ă©lĂ©ments qui ressemblent Ă un autre](../parsing/selection.md#finding-similar-elements) : Trouvez un Ă©lĂ©ment et nous cherchons les autres.+3. [SĂ©lectionner avec des filtres](../parsing/selection.md#filters-based-searching) : Indiquez les conditions que lâĂ©lĂ©ment doit remplir et nous le trouvons.++Ouvrez les liens pour voir comment Scrapling rĂ©sout chaque cas.++### RĂ©soudre T3 : des protections antibot de plus en plus complexes {#solving-issue-t3-increasingly-complex-anti-bot-measures}++Les proxies et les actions qui imitent une personne ne suffisent pas toujours sur les sites protĂ©gĂ©s. [StealthyFetcher](../fetching/stealthy.md) combine lâautomatisation du navigateur, des modifications de son empreinte et des options pour gĂ©rer les protections antibot. Activez `solve_cloudflare=True` pour les dĂ©fis Turnstile et Interstitial de Cloudflare.++### RĂ©soudre B1 et B2 : diversitĂ© des sites et recherche des donnĂ©es utiles {#solving-issues-b1-b2-extreme-website-diversity-identifying-relevant-data}++Ce problĂšme est difficile, mais la souplesse de Scrapling permet de lâaborder.++Jâai parlĂ© avec une personne qui utilise lâIA pour extraire des prix sur diffĂ©rents sites. Seuls les prix et les titres lâintĂ©ressent, alors elle demande Ă lâIA de trouver les prix.++Je lui ai dit que lâIA nâĂ©tait pas nĂ©cessaire ici et donnĂ© cet exemple :+```python+price_element = page.find_by_regex(r'ÂŁ[\d\.,]+', first_match=True) # Get the first element that contains a text that matches price regex eg. ÂŁ10.50+# If you want the container/element that contains the price element+price_element_container = price_element.parent or price_element.find_ancestor(lambda ancestor: ancestor.has_class('product')) # or other methods...+target_element_selector = price_element_container.generate_css_selector or price_element_container.generate_full_css_selector # or xpath+```+Elle mâa alors demandĂ© comment gĂ©rer un cas comme celui-ci :+```html+<span class='currency'> $ </span> <span class='a-price'> 45,000 </span>+```+Jâai donc adaptĂ© le code :+```python+price_element_container = page.find_by_regex(r'[\d,]+', first_match=True).parent # Adjusted the regex for this example+full_price_data = price_element_container.get_all_text(separator="", strip=True) # Returns '$45,000' in this case+```+Cela suffisait pour son besoin. Vous pouvez essayer la premiĂšre expression rĂ©guliĂšre et, si elle ne trouve rien, passer Ă la suivante. Commencez par les motifs les plus frĂ©quents, puis couvrez les autres.+Cela peut ĂȘtre un peu fastidieux, mais coĂ»te bien moins cher que lâIA.++VoilĂ ce que montre cet exemple : tous les problĂšmes ne demandent pas une IA. Parfois, chercher une autre solution peut vous faire Ă©conomiser beaucoup dâargent.++### RĂ©soudre B3 : diffĂ©rentes formes de pagination {#solving-issue-b3-pagination-variations}++Scrapling nâa pas encore de mĂ©thode qui dĂ©tecte automatiquement les liens de pagination. Ses spiders suivent ces liens avec `response.follow()`.++Vous pouvez toutefois couvrir beaucoup de sites en cherchant les motifs courants avec `page.find_by_text('Next')['href']` ou `page.find_by_text('load more')['href']`, ou avec des sĂ©lecteurs comme `'a[href*="?page="]'` ou `'a[href*="/page/"]'`. Vous voyez lâidĂ©e.++## Comparaison des coĂ»ts et Ă©conomies {#cost-comparison-and-savings}++Voici une comparaison rapide :++| Aspect | Scrapling | Outils avec IA (par exemple Browse AI ou Oxylabs) |+|---|---|---|+| CoĂ»t | Gratuit, sans frais par utilisation de la bibliothĂšque | Offres payantes, avec un prix qui dĂ©pend du fournisseur et de lâusage |+| Configuration | Demande quelques connaissances techniques et une configuration manuelle | Souvent sans code, donc plus simple sans connaissances techniques |+| Modes dâutilisation | Code, terminal ou serveur MCP | Souvent une interface graphique ou une API, selon lâoffre de lâentreprise |+| Passage Ă grande Ă©chelle | DĂ©pend de la mise en Ćuvre par lâutilisateur | Services gĂ©rĂ©s avec prise en charge de grands volumes |+| Adaptation aux changements | ĂlevĂ©e avec `adaptive` et les mĂ©thodes de sĂ©lection sans sĂ©lecteurs CSS/XPath | ĂlevĂ©e et automatique avec lâIA, mais chĂšre si les changements sont frĂ©quents |++Consultez les tarifs actuels de [Browse AI](https://www.browse.ai/pricing) et de la [Web Scraper API dâOxylabs](https://oxylabs.io/products/scraper-api/web/pricing).++## Conclusion {#conclusion}++LâIA offre des fonctions puissantes, mais son coĂ»t peut ĂȘtre trop Ă©levĂ© pour beaucoup de tĂąches dâextraction web. Scrapling rĂ©unit des outils fiables, souples et Ă©conomiques pour extraire des donnĂ©es sur des sites prĂ©cis ou sur de nombreux sites diffĂ©rents. Il Ă©vite souvent de recourir Ă des solutions dâIA coĂ»teuses. Avec `adaptive`, plusieurs mĂ©thodes de sĂ©lection et des fetchers avancĂ©s, vous pouvez crĂ©er des scrapers qui rĂ©sistent mieux aux changements.++Explorez la documentation pour dĂ©couvrir comment Scrapling peut simplifier vos prochains projets dâextraction de donnĂ©es web !diff --git a/docs/overrides/api/python/material/languages/fr.html.jinja b/docs/overrides/api/python/material/languages/fr.html.jinjanew file mode 100644index 0000000..5d23e49--- /dev/null+++ b/docs/overrides/api/python/material/languages/fr.html.jinja@@ -0,0 +1,17 @@+{% macro t(key) %}{{ {+ "ATTRIBUTE": "ATTRIBUT", "Attributes": "Attributs", "Attributes:": "Attributs :",+ "BOUND:": "BORNE :", "Bound or Constraints": "Borne ou contraintes",+ "Classes": "Classes", "Classes:": "Classes :", "CLASS": "CLASSE",+ "Class Type Parameters:": "ParamĂštres de type de la classe :", "CLASS TYPE PARAMETER": "PARAMĂTRE DE TYPE DE LA CLASSE",+ "CONSTRAINTS:": "CONTRAINTES :", "DEFAULT:": "PAR DĂFAUT :", "Default": "Par dĂ©faut", "default:": "par dĂ©faut :",+ "DESCRIPTION": "DESCRIPTION", "Description": "Description", "Examples:": "Exemples :",+ "Functions": "Fonctions", "Functions:": "Fonctions :", "FUNCTION": "FONCTION",+ "Init Type Parameters:": "ParamĂštres de type de lâinitialisation :", "INIT TYPE PARAMETER": "PARAMĂTRE DE TYPE DE LâINITIALISATION",+ "Methods:": "MĂ©thodes :", "METHOD": "MĂTHODE", "Modules": "Modules", "Modules:": "Modules :", "MODULE": "MODULE",+ "Name": "Nom", "Other Parameters:": "Autres paramĂštres :", "PARAMETER": "PARAMĂTRE", "Parameters:": "ParamĂštres :",+ "RAISES": "EXCEPTIONS", "Raises:": "Exceptions :", "RECEIVES": "REĂOIT", "Receives:": "Reçoit :",+ "required": "obligatoire", "RETURNS": "RENVOIE", "Returns:": "Renvoie :", "Source code in": "Code source dans",+ "TYPE:": "TYPE :", "Type": "Type", "Type Aliases": "Alias de types", "Type Aliases:": "Alias de types :",+ "TYPE ALIAS": "ALIAS DE TYPE", "Type Parameters:": "ParamĂštres de type :", "TYPE PARAMETER": "PARAMĂTRE DE TYPE",+ "WARNS": "AVERTISSEMENTS", "Warns:": "Avertissements :", "YIELDS": "PRODUIT", "Yields:": "Produit :"+}.get(key, "") }}{% endmacro %}diff --git a/docs/overrides/api/python/material/translations/fr.html.jinja b/docs/overrides/api/python/material/translations/fr.html.jinjanew file mode 100644index 0000000..e025703--- /dev/null+++ b/docs/overrides/api/python/material/translations/fr.html.jinja@@ -0,0 +1,369 @@+{% set translations = {+ "<p>This class is returned by all engines as a way to unify the response type between different libraries.</p>": "<p>Tous les moteurs renvoient cette classe pour utiliser le mĂȘme type de rĂ©ponse entre les diffĂ©rentes bibliothĂšques.</p>",+ "<p>HTTP status code.</p>": "<p>Code de statut HTTP.</p>",+ "<p>HTTP status message.</p>": "<p>Message de statut HTTP.</p>",+ "<p>Response cookies.</p>": "<p>Cookies de la rĂ©ponse.</p>",+ "<p>Response headers.</p>": "<p>En-tĂȘtes de la rĂ©ponse.</p>",+ "<p>Request headers sent with the request.</p>": "<p>En-tĂȘtes envoyĂ©s avec la requĂȘte.</p>",+ "<p>List of redirect responses, if any.</p>": "<p>Liste des rĂ©ponses de redirection, sâil y en a.</p>",+ "<p>Metadata dictionary (e.g., proxy used).</p>": "<p>Dictionnaire de mĂ©tadonnĂ©es, comme le proxy utilisĂ©.</p>",+ "<p>Associated spider Request object (set by crawler, in the spiders framework).</p>": "<p>Objet Request associĂ©, dĂ©fini par le moteur dâexploration dans le systĂšme de spiders.</p>",+ "<p>The main class that works as a wrapper for the HTML input data. Using this class, you can search for elements\nwith expressions in CSS, XPath, or with simply text. Check the docs for more info.</p>": "<p>Classe principale qui enveloppe les donnĂ©es HTML dâentrĂ©e. Elle permet de chercher des Ă©lĂ©ments avec CSS, XPath ou du texte. Consultez la documentation pour en savoir plus.</p>",+ "<p>Here we try to extend module <code>lxml.html.HtmlElement</code> while maintaining a simpler interface, We are not\ninheriting from the <code>lxml.html.HtmlElement</code> because it's not pickleable, which makes a lot of reference jobs\nnot possible. You can test it here and see code explodes with <code>AssertionError: invalid Element proxy at...</code>.\nIt's an old issue with lxml, see <code>this entry <https://bugs.launchpad.net/lxml/+bug/736708></code></p>": "<p>Cette classe Ă©tend les fonctions de <code>lxml.html.HtmlElement</code> avec une interface plus simple. Elle nâhĂ©rite pas de <code>lxml.html.HtmlElement</code>, car ce type ne peut pas ĂȘtre sĂ©rialisĂ© avec pickle, ce qui empĂȘche plusieurs opĂ©rations utilisant des rĂ©fĂ©rences. Si vous essayez, vous obtiendrez <code>AssertionError: invalid Element proxy at...</code>. Câest un ancien problĂšme de lxml ; voir <code>this entry <https://bugs.launchpad.net/lxml/+bug/736708></code>.</p>",+ "<p>HTML content as either string or bytes.</p>": "<p>Contenu HTML sous forme de chaĂźne ou de bytes.</p>",+ "<p>It allows storing a URL with the HTML data for retrieving later.</p>": "<p>Permet dâenregistrer une URL avec les donnĂ©es HTML pour la retrouver plus tard.</p>",+ "<p>The encoding type that will be used in HTML parsing, default is <code>UTF-8</code></p>": "<p>Encodage utilisĂ© pour analyser le HTML. La valeur par dĂ©faut est <code>UTF-8</code>.</p>",+ "<p>Enabled by default, should always be enabled when parsing large HTML documents. This controls\nthe libxml2 feature that forbids parsing certain large documents to protect from possible memory exhaustion.</p>": "<p>ActivĂ© par dĂ©faut et doit le rester pour analyser de grands documents HTML. ContrĂŽle la fonction de libxml2 qui empĂȘche lâanalyse de certains documents volumineux pour Ă©viter un manque de mĂ©moire.</p>",+ "<p>Used internally to pass etree objects instead of text/body arguments, it takes the highest priority.\nDon't use it unless you know what you are doing!</p>": "<p>UtilisĂ© en interne pour passer des objets etree Ă la place des arguments de texte ou de corps. Sa prioritĂ© est la plus Ă©levĂ©e. Utilisez-le seulement si vous savez comment il agit sur le traitement.</p>",+ "<p>While parsing the HTML body, drop comments or not. Disabled by default for obvious reasons</p>": "<p>Indique si les commentaires sont conservĂ©s pendant lâanalyse du HTML. DĂ©sactivĂ© par dĂ©faut.</p>",+ "<p>Globally turn off the adaptive feature in all functions, this argument takes higher\npriority over all adaptive related arguments/functions in the class.</p>": "<p>DĂ©sactive la fonction adaptative globalement dans toutes les mĂ©thodes. Cet argument a prioritĂ© sur tous les arguments et mĂ©thodes de la classe liĂ©s Ă cette fonction.</p>",+ "<p>The storage class to be passed for adaptive functionalities, see <code>Docs</code> for more info.</p>": "<p>Classe de stockage utilisĂ©e pour les fonctions adaptatives. Consultez <code>Docs</code> pour en savoir plus.</p>",+ "<p>A dictionary of <code>argument->value</code> pairs to be passed for the storage class.\nIf empty, default values will be used.</p>": "<p>Dictionnaire de paires <code>argument->value</code> transmis Ă la classe de stockage. Sâil est vide, les valeurs par dĂ©faut sont utilisĂ©es.</p>",+ "<p>Return the raw body of the current <code>Selector</code> without any processing. Useful for binary and non-HTML requests.</p>": "<p>Renvoie le corps brut du <code>Selector</code> actuel sans traitement. Utile pour les requĂȘtes de contenu binaire ou autre que du HTML.</p>",+ "<p>Return the raw body of the response as bytes.</p>": "<p>Renvoie le corps brut de la rĂ©ponse sous forme de bytes.</p>",+ "<p>Generate a CSS selector for the current element</p>": "<p>GĂ©nĂšre un sĂ©lecteur CSS pour lâĂ©lĂ©ment actuel.</p>",+ "<p>A string of the generated selector.</p>": "<p>ChaĂźne contenant le sĂ©lecteur gĂ©nĂ©rĂ©.</p>",+ "<p>Generate a complete CSS selector for the current element</p>": "<p>GĂ©nĂšre un sĂ©lecteur CSS complet pour lâĂ©lĂ©ment actuel.</p>",+ "<p>Generate an XPath selector for the current element</p>": "<p>GĂ©nĂšre un sĂ©lecteur XPath pour lâĂ©lĂ©ment actuel.</p>",+ "<p>Generate a complete XPath selector for the current element</p>": "<p>GĂ©nĂšre un sĂ©lecteur XPath complet pour lâĂ©lĂ©ment actuel.</p>",+ "<p>Get the tag name of the element</p>": "<p>Obtient le nom de la balise de lâĂ©lĂ©ment.</p>",+ "<p>Get text content of the element</p>": "<p>Obtient le texte de lâĂ©lĂ©ment.</p>",+ "<p>Get attributes of the element</p>": "<p>Obtient les attributs de lâĂ©lĂ©ment.</p>",+ "<p>Return the inner HTML code of the element</p>": "<p>Renvoie le code HTML interne de lâĂ©lĂ©ment.</p>",+ "<p>Return the direct parent of the element or <code>None</code> otherwise</p>": "<p>Renvoie le parent direct de lâĂ©lĂ©ment, ou <code>None</code> sâil nâen a pas.</p>",+ "<p>Return all elements under the current element in the DOM tree</p>": "<p>Renvoie tous les Ă©lĂ©ments situĂ©s sous lâĂ©lĂ©ment actuel dans lâarbre DOM.</p>",+ "<p>Return the children elements of the current element or empty list otherwise</p>": "<p>Renvoie les Ă©lĂ©ments enfants de lâĂ©lĂ©ment actuel, ou une liste vide sâil nâen a pas.</p>",+ "<p>Return other children of the current element's parent or empty list otherwise</p>": "<p>Renvoie les autres enfants du parent de lâĂ©lĂ©ment actuel, ou une liste vide sâil nây en a pas.</p>",+ "<p>Returns a list of type <code>Selectors</code> that contains the path leading to the current element from the root.</p>": "<p>Renvoie une liste de type <code>Selectors</code> contenant le chemin de la racine jusquâĂ lâĂ©lĂ©ment actuel.</p>",+ "<p>Returns the next element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Renvoie lâĂ©lĂ©ment suivant parmi les enfants du mĂȘme parent, ou <code>None</code> sâil nây en a pas.</p>",+ "<p>Returns the previous element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Renvoie lâĂ©lĂ©ment prĂ©cĂ©dent parmi les enfants du mĂȘme parent, ou <code>None</code> sâil nây en a pas.</p>",+ "<p>Convert the response content to clean Markdown.</p>": "<p>Convertit le contenu de la rĂ©ponse en Markdown propre.</p>",+ "<p>Scripts, styles, and hidden/prompt-injection content are always removed before conversion, which is\nthe same cleaning the MCP server does. Requires the \"markdownify\" package (<code>pip install \"scrapling[rag]\"</code>).</p>": "<p>Avant la conversion, les scripts, styles et contenus cachĂ©s ou contenant des instructions malveillantes sont toujours retirĂ©s, comme dans le serveur MCP. NĂ©cessite le paquet \"markdownify\" (<code>pip install \"scrapling[rag]\"</code>).</p>",+ "<p>CSS selector to convert only the matching elements. All matches are concatenated.</p>": "<p>SĂ©lecteur CSS pour convertir uniquement les Ă©lĂ©ments correspondants. Tous les rĂ©sultats sont rĂ©unis.</p>",+ "<p>Convert only the content inside the <code><body></code> tag.</p>": "<p>Convertit uniquement le contenu de la balise <code><body></code>.</p>",+ "<p>Create a Request to follow a URL.</p>": "<p>CrĂ©e un objet Request pour suivre une URL.</p>",+ "<p>This is a helper method for spiders to easily follow links found in pages.</p>": "<p>MĂ©thode utilitaire qui aide les spiders Ă suivre les liens trouvĂ©s dans les pages.</p>",+ "<p><strong>IMPORTANT</strong>: The below arguments if left empty, the corresponding value from the previous request will be used. The only exception is <code>dont_filter</code>.</p>": "<p><strong>IMPORTANT</strong> : si les arguments suivants restent vides, la valeur de la requĂȘte prĂ©cĂ©dente est utilisĂ©e. La seule exception est <code>dont_filter</code>.</p>",+ "<p>The session kwargs of the previous request are inherited as well, except <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code>, and <code>multipart</code>, so a followed link is a plain GET unless you pass them again.</p>": "<p>Les arguments de session de la requĂȘte prĂ©cĂ©dente sont aussi repris, sauf <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code> et <code>multipart</code>. Le lien est donc suivi avec un simple GET, sauf si vous passez ces arguments de nouveau.</p>",+ "<p>The URL to follow (can be relative, will be joined with current URL)</p>": "<p>URL Ă suivre. Elle peut ĂȘtre relative et sera combinĂ©e avec lâURL actuelle.</p>",+ "<p>The session id to use</p>": "<p>Identifiant de la session Ă utiliser.</p>",+ "<p>Spider callback method to use</p>": "<p>MĂ©thode callback du spider Ă utiliser.</p>",+ "<p>The priority number to use, the higher the number, the higher priority to be processed first.</p>": "<p>Valeur de prioritĂ©. Plus elle est Ă©levĂ©e, plus la requĂȘte est traitĂ©e tĂŽt.</p>",+ "<p>If this request has been done before, disable the filter to allow it again.</p>": "<p>DĂ©sactive le filtre pour autoriser cette requĂȘte mĂȘme si elle a dĂ©jĂ Ă©tĂ© faite.</p>",+ "<p>Additional meta data to included in the request</p>": "<p>MĂ©tadonnĂ©es supplĂ©mentaires Ă inclure dans la requĂȘte.</p>",+ "<p>Enabled by default, set the current response url as referer for the new request url.</p>": "<p>ActivĂ© par dĂ©faut. Utilise lâURL de la rĂ©ponse actuelle comme referer de la nouvelle requĂȘte.</p>",+ "<p>Additional Request arguments</p>": "<p>Arguments supplĂ©mentaires de Request.</p>",+ "<p>Request object ready to be yielded</p>": "<p>Objet Request prĂȘt Ă ĂȘtre produit avec yield.</p>",+ "<p>Get all child strings of this element, concatenated using the given separator.</p>": "<p>Obtient toutes les chaĂźnes des descendants de cet Ă©lĂ©ment et les rĂ©unit avec le sĂ©parateur indiquĂ©.</p>",+ "<p>Strings will be concatenated using this separator.</p>": "<p>SĂ©parateur utilisĂ© pour rĂ©unir les chaĂźnes.</p>",+ "<p>If True, strings will be stripped before being concatenated.</p>": "<p>Si la valeur est True, retire les espaces au dĂ©but et Ă la fin de chaque chaĂźne avant de les rĂ©unir.</p>",+ "<p>A tuple of all tag names you want to ignore</p>": "<p>Tuple contenant les noms des balises Ă ignorer.</p>",+ "<p>If enabled, elements with text-content that is empty or only whitespaces will be ignored</p>": "<p>Si activĂ©, ignore les Ă©lĂ©ments dont le texte est vide ou ne contient que des espaces.</p>",+ "<p>A TextHandler</p>": "<p>Un TextHandler.</p>",+ "<p>Join this Selector's url with a relative url to form an absolute full URL.</p>": "<p>Combine lâURL de ce Selector avec une URL relative pour former une URL absolue.</p>",+ "<p>Return a prettified version of the element's inner html-code</p>": "<p>Renvoie le HTML interne de lâĂ©lĂ©ment dans un format plus lisible.</p>",+ "<p>Check if the element has a specific class</p>": "<p>VĂ©rifie si lâĂ©lĂ©ment possĂšde une classe prĂ©cise.</p>",+ "<p>The class name to check for</p>": "<p>Nom de la classe Ă vĂ©rifier.</p>",+ "<p>True if element has class with that name otherwise False</p>": "<p>True si lâĂ©lĂ©ment possĂšde une classe de ce nom, sinon False.</p>",+ "<p>Return a generator that loops over all ancestors of the element, starting with the element's parent.</p>": "<p>Renvoie un gĂ©nĂ©rateur qui parcourt tous les ancĂȘtres de lâĂ©lĂ©ment, en commençant par son parent.</p>",+ "<p>Loop over all ancestors of the element till one match the passed function</p>": "<p>Parcourt les ancĂȘtres de lâĂ©lĂ©ment jusquâĂ ce que lâun satisfasse la fonction fournie.</p>",+ "<p>A function that takes each ancestor as an argument and returns True/False</p>": "<p>Fonction qui reçoit chaque ancĂȘtre et renvoie True ou False.</p>",+ "<p>The first ancestor that match the function or <code>None</code> otherwise.</p>": "<p>Premier ancĂȘtre qui satisfait la fonction, ou <code>None</code> si aucun ne correspond.</p>",+ "<p>Serialize this element to a string.\nFor text nodes, returns the text value. For HTML elements, returns the outer HTML.</p>": "<p>SĂ©rialise cet Ă©lĂ©ment sous forme de chaĂźne. Pour un nĆud de texte, renvoie sa valeur. Pour un Ă©lĂ©ment HTML, renvoie le HTML externe, y compris sa propre balise.</p>",+ "<p>Return a single-element list containing this element's serialized string.</p>": "<p>Renvoie une liste dâun seul Ă©lĂ©ment contenant la chaĂźne sĂ©rialisĂ©e de cet Ă©lĂ©ment.</p>",+ "<p>This function will search again for the element in the page tree, used automatically on page structure change</p>": "<p>Cherche de nouveau lâĂ©lĂ©ment dans lâarbre de la page. UtilisĂ© automatiquement quand la structure de la page change.</p>",+ "<p>The element we want to relocate in the tree</p>": "<p>ĂlĂ©ment Ă retrouver dans lâarbre.</p>",+ "<p>The minimum percentage to accept and not going lower than that. Be aware that the percentage\ncalculation depends solely on the page structure, so don't play with this number unless you must know\nwhat you are doing!</p>": "<p>Pourcentage minimal de correspondance acceptĂ©. Son calcul dĂ©pend uniquement de la structure de la page. Changez cette valeur seulement si vous comprenez son effet sur les rĂ©sultats.</p>",+ "<p>If True, the return result will be converted to <code>Selectors</code> object</p>": "<p>Si la valeur est True, convertit le rĂ©sultat en objet <code>Selectors</code>.</p>",+ "<p>List of pure HTML elements that got the highest matching score or 'Selectors' object</p>": "<p>Liste des Ă©lĂ©ments HTML ayant le meilleur score de correspondance, ou objet 'Selectors'.</p>",+ "<p>Search the current tree with CSS3 selectors</p>": "<p>Cherche dans lâarbre actuel avec des sĂ©lecteurs CSS3.</p>",+ "<p><strong>Important:\nIt's recommended to use the identifier argument if you plan to use a different selector later\nand want to relocate the same element(s)</strong></p>": "<p><strong>Important : utilisez lâargument identifier si vous prĂ©voyez de changer de sĂ©lecteur plus tard et souhaitez retrouver les mĂȘmes Ă©lĂ©ments.</strong></p>",+ "<p>The CSS3 selector to be used.</p>": "<p>SĂ©lecteur CSS3 Ă utiliser.</p>",+ "<p>Enabled will make the function try to relocate the element if it was 'saved' before</p>": "<p>Si activĂ©, essaie de retrouver lâĂ©lĂ©ment sâil a dĂ©jĂ Ă©tĂ© enregistrĂ©.</p>",+ "<p>A string that will be used to save/retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>ChaĂźne utilisĂ©e pour enregistrer et retrouver les donnĂ©es de lâĂ©lĂ©ment en mode adaptatif. Sinon, le sĂ©lecteur est utilisĂ©.</p>",+ "<p>Automatically save new elements for <code>adaptive</code> later</p>": "<p>Enregistre automatiquement les nouveaux Ă©lĂ©ments pour les utiliser plus tard avec <code>adaptive</code>.</p>",+ "<p>The minimum percentage to accept while <code>adaptive</code> is working and not going lower than that.\nBe aware that the percentage calculation depends solely on the page structure, so don't play with this\nnumber unless you must know what you are doing!</p>": "<p>Pourcentage minimal de correspondance acceptĂ© par <code>adaptive</code>. Son calcul dĂ©pend uniquement de la structure de la page. Changez cette valeur seulement si vous comprenez son effet sur les rĂ©sultats.</p>",+ "<p><code>Selectors</code> class.</p>": "<p>Classe <code>Selectors</code>.</p>",+ "<p>Search the current tree with XPath selectors</p>": "<p>Cherche dans lâarbre actuel avec des sĂ©lecteurs XPath.</p>",+ "<p>Note: <strong>Additional keyword arguments will be passed as XPath variables in the XPath expression!</strong></p>": "<p>Note : <strong>les arguments supplĂ©mentaires sont transmis comme variables Ă lâexpression XPath.</strong></p>",+ "<p>The XPath selector to be used.</p>": "<p>SĂ©lecteur XPath Ă utiliser.</p>",+ "<p>Find elements by filters of your creations for ease.</p>": "<p>Cherche des Ă©lĂ©ments avec des filtres que vous pouvez dĂ©finir.</p>",+ "<p>Tag name(s), iterable of tag names, regex patterns, function, or a dictionary of elements' attributes. Leave empty for selecting all.</p>": "<p>Un ou plusieurs noms de balises, un itĂ©rable de noms, des motifs regex, une fonction ou un dictionnaire dâattributs. Laissez vide pour sĂ©lectionner tous les Ă©lĂ©ments.</p>",+ "<p>The attributes you want to filter elements based on it.</p>": "<p>Attributs utilisĂ©s pour filtrer les Ă©lĂ©ments.</p>",+ "<p>The <code>Selectors</code> object of the elements or empty list</p>": "<p>Objet <code>Selectors</code> contenant les Ă©lĂ©ments, ou liste vide.</p>",+ "<p>Find elements by filters of your creations for ease, then return the first result. Otherwise return <code>None</code>.</p>": "<p>Cherche des Ă©lĂ©ments avec vos propres filtres et renvoie le premier rĂ©sultat. Si aucun nâest trouvĂ©, renvoie <code>None</code>.</p>",+ "<p>The <code>Selector</code> object of the element or <code>None</code> if the result didn't match</p>": "<p>Objet <code>Selector</code> de lâĂ©lĂ©ment, ou <code>None</code> si aucun rĂ©sultat ne correspond.</p>",+ "<p>Saves the element's unique properties to the storage for retrieval and relocation later</p>": "<p>Enregistre les propriĂ©tĂ©s uniques de lâĂ©lĂ©ment pour rĂ©cupĂ©rer ses donnĂ©es et le localiser de nouveau plus tard.</p>",+ "<p>The element itself that we want to save to storage, it can be a <code>Selector</code> or pure <code>HtmlElement</code></p>": "<p>ĂlĂ©ment Ă enregistrer. Peut ĂȘtre un <code>Selector</code> ou directement un <code>HtmlElement</code>.</p>",+ "<p>This is the identifier that will be used to retrieve the element later from the storage. See\nthe docs for more info.</p>": "<p>Identifiant utilisĂ© pour retrouver lâĂ©lĂ©ment dans le stockage plus tard. Consultez la documentation pour en savoir plus.</p>",+ "<p>Using the identifier, we search the storage and return the unique properties of the element</p>": "<p>Cherche dans le stockage avec lâidentifiant et renvoie les propriĂ©tĂ©s uniques de lâĂ©lĂ©ment.</p>",+ "<p>This is the identifier that will be used to retrieve the element from the storage. See\nthe docs for more info.</p>": "<p>Identifiant utilisĂ© pour retrouver lâĂ©lĂ©ment dans le stockage. Consultez la documentation pour en savoir plus.</p>",+ "<p>A dictionary of the unique properties</p>": "<p>Dictionnaire des propriĂ©tĂ©s uniques.</p>",+ "<p>Return JSON response if the response is jsonable otherwise throws error</p>": "<p>Renvoie la rĂ©ponse en JSON si la conversion est possible, sinon lĂšve une erreur.</p>",+ "<p>Apply the given regex to the current text and return a list of strings with the matches.</p>": "<p>Applique lâexpression rĂ©guliĂšre au texte actuel et renvoie une liste de chaĂźnes contenant les correspondances.</p>",+ "<p>Can be either a compiled regular expression or a string.</p>": "<p>Peut ĂȘtre une expression rĂ©guliĂšre compilĂ©e ou une chaĂźne.</p>",+ "<p>If enabled character entity references are replaced by their corresponding character</p>": "<p>Si activĂ©, remplace les rĂ©fĂ©rences aux entitĂ©s par les caractĂšres correspondants.</p>",+ "<p>if enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Si activĂ©, ignore les caractĂšres dâespacement et les espaces consĂ©cutifs lors de la recherche.</p>",+ "<p>if disabled, the function will set the regex to ignore the letters case while compiling it</p>": "<p>Si dĂ©sactivĂ©, compile lâexpression rĂ©guliĂšre sans distinguer les majuscules des minuscules.</p>",+ "<p>Apply the given regex to text and return the first match if found, otherwise return the default value.</p>": "<p>Applique lâexpression rĂ©guliĂšre au texte et renvoie la premiĂšre correspondance, ou la valeur par dĂ©faut si aucune nâest trouvĂ©e.</p>",+ "<p>The default value to be returned if there is no match</p>": "<p>Valeur renvoyĂ©e si aucune correspondance nâest trouvĂ©e.</p>",+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>None</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>PAR DĂFAUT :</b>\n <code>None</code>\n </span>\n </p>",+ "<p>if enabled character entity references are replaced by their corresponding character</p>": "<p>Si activĂ©, remplace les rĂ©fĂ©rences aux entitĂ©s par les caractĂšres correspondants.</p>",+ "<p>Find elements that are in the same tree depth in the page with the same tag name and same parent tag etc...\nthen return the ones that match the current element attributes with a percentage higher than the input threshold.</p>": "<p>Cherche des Ă©lĂ©ments Ă la mĂȘme profondeur de lâarbre, avec les mĂȘmes noms de balise et de balise parente, entre autres critĂšres. Renvoie ceux dont les attributs correspondent Ă lâĂ©lĂ©ment actuel au-dessus du seuil indiquĂ©.</p>",+ "<p>This function is inspired by AutoScraper and made for cases where you, for example, found a product div inside\na products-list container and want to find other products using that element as a starting point EXCEPT\nthis function works in any case without depending on the element type.</p>": "<p>Cette fonction sâinspire dâAutoScraper. Elle sert par exemple quand vous trouvez un div de produit dans une liste et voulez vous en servir pour trouver les autres produits. Elle fonctionne avec tous les types dâĂ©lĂ©ments.</p>",+ "<p>The percentage to use while comparing element attributes.\nNote: Elements found before attributes matching/comparison will be sharing the same depth, same tag name,\nsame parent tag name, and same grand parent tag name. So they are 99% likely to be correct unless you are\nextremely unlucky, then attributes matching comes into play, so don't play with this number unless\nyou are getting the results you don't want.\nAlso, if the current element doesn't have attributes and the similar element as well, then it's a 100% match.</p>": "<p>Pourcentage utilisĂ© pour comparer les attributs. Avant cette comparaison, les Ă©lĂ©ments trouvĂ©s ont dĂ©jĂ la mĂȘme profondeur et les mĂȘmes noms de balise pour lâĂ©lĂ©ment, son parent et son grand-parent. Ils ont donc de fortes chances dâĂȘtre corrects, environ 99 %. La comparaison des attributs ajoute un filtre. Changez cette valeur uniquement si vous nâobtenez pas les rĂ©sultats souhaitĂ©s. Si ni lâĂ©lĂ©ment actuel ni lâĂ©lĂ©ment similaire nâont dâattributs, la correspondance est de 100 %.</p>",+ "<p>Attribute names passed will be ignored while matching the attributes in the last step.\nThe default value is to ignore <code>href</code> and <code>src</code> as URLs can change a lot between elements, so it's unreliable</p>": "<p>Noms des attributs ignorĂ©s lors de la comparaison finale. Par dĂ©faut, <code>href</code> et <code>src</code> sont ignorĂ©s, car les URL peuvent beaucoup varier entre les Ă©lĂ©ments et ne sont pas une rĂ©fĂ©rence fiable.</p>",+ "<p>If True, element text content will be taken into calculation while matching.\nNot recommended to use in normal cases, but it depends.</p>": "<p>Si la valeur est True, le texte des Ă©lĂ©ments est aussi comparĂ©. Cette option nâest gĂ©nĂ©ralement pas conseillĂ©e, mais elle peut ĂȘtre utile dans certains cas.</p>",+ "<p>A <code>Selectors</code> container of <code>Selector</code> objects or empty list</p>": "<p>Conteneur <code>Selectors</code> dâobjets <code>Selector</code>, ou liste vide.</p>",+ "<p>Find elements that its text content fully/partially matches input.</p>": "<p>Cherche les Ă©lĂ©ments dont le texte correspond entiĂšrement ou en partie au texte fourni.</p>",+ "<p>Text query to match</p>": "<p>Texte Ă chercher.</p>",+ "<p>Returns the first element that matches conditions, enabled by default</p>": "<p>Renvoie le premier Ă©lĂ©ment qui remplit les conditions. ActivĂ© par dĂ©faut.</p>",+ "<p>If enabled, the function returns elements that contain the input text</p>": "<p>Si activĂ©, renvoie les Ă©lĂ©ments qui contiennent le texte fourni.</p>",+ "<p>if enabled, the letters case will be taken into consideration</p>": "<p>Si activĂ©, distingue les majuscules des minuscules.</p>",+ "<p>Find elements that its text content matches the input regex pattern.</p>": "<p>Cherche les Ă©lĂ©ments dont le texte correspond au motif dâexpression rĂ©guliĂšre fourni.</p>",+ "<p>Regex query/pattern to match</p>": "<p>Expression rĂ©guliĂšre ou motif Ă chercher.</p>",+ "<p>Return the first element that matches conditions; enabled by default.</p>": "<p>Renvoie le premier Ă©lĂ©ment qui remplit les conditions. ActivĂ© par dĂ©faut.</p>",+ "<p>If enabled, the letters case will be taken into consideration in the regex.</p>": "<p>Si activĂ©, lâexpression rĂ©guliĂšre distingue les majuscules des minuscules.</p>",+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching.</p>": "<p>Si activĂ©, ignore les caractĂšres dâespacement et les espaces consĂ©cutifs lors de la recherche.</p>",+ "<p>A basic <code>Fetcher</code> class type that can only do basic GET, POST, PUT, and DELETE HTTP requests based on <code>curl_cffi</code>.</p>": "<p>Classe <code>Fetcher</code> simple qui effectue des requĂȘtes HTTP GET, POST, PUT et DELETE avec <code>curl_cffi</code>.</p>",+ "<p>Set multiple arguments for the parser at once globally</p>": "<p>Configure plusieurs arguments de lâanalyseur Ă la fois, de façon globale.</p>",+ "<p>The keywords can be any arguments of the following: huge_tree, keep_comments, adaptive, storage, storage_args, adaptive_domain</p>": "<p>Les arguments disponibles sont huge_tree, keep_comments, adaptive, storage, storage_args et adaptive_domain.</p>",+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>{}</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>PAR DĂFAUT :</b>\n <code>{}</code>\n </span>\n </p>",+ "<p>A <code>Fetcher</code> class type which is a completely stealthy built on top of Chromium.</p>": "<p>Classe <code>Fetcher</code> furtive basĂ©e sur Chromium.</p>",+ "<p>It works as real browsers passing almost all online tests/protections with many customization options.</p>": "<p>Se comporte comme un vrai navigateur, passe presque tous les tests et protections en ligne et propose de nombreux rĂ©glages.</p>",+ "<p>Opens up a browser and do your request based on your chosen options below.</p>": "<p>Ouvre un navigateur et effectue votre requĂȘte avec les options choisies ci-dessous.</p>",+ "<p>Target url.</p>": "<p>URL cible.</p>",+ "<p>Run the browser in headless/hidden (default), or headful/visible mode.</p>": "<p>ExĂ©cute le navigateur sans fenĂȘtre visible par dĂ©faut, ou avec une fenĂȘtre visible.</p>",+ "<p>Drop requests for unnecessary resources for a speed boost.\nRequests dropped are of type <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code>, and <code>stylesheet</code>.</p>": "<p>Ăcarte les requĂȘtes de ressources inutiles pour accĂ©lĂ©rer le chargement. Les types Ă©cartĂ©s sont <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code> et <code>stylesheet</code>.</p>",+ "<p>A set of domain names to block requests to. Subdomains are also matched (e.g., <code>\"example.com\"</code> blocks <code>\"sub.example.com\"</code> too).</p>": "<p>Ensemble de domaines vers lesquels les requĂȘtes sont bloquĂ©es. Les sous-domaines sont inclus : par exemple, <code>\"example.com\"</code> bloque aussi <code>\"sub.example.com\"</code>.</p>",+ "<p>Block requests to ~3,500 known ad/tracking domains. Can be combined with <code>blocked_domains</code>.</p>": "<p>Bloque les requĂȘtes vers environ 3 500 domaines connus de publicitĂ© et de suivi. Peut ĂȘtre combinĂ© avec <code>blocked_domains</code>.</p>",+ "<p>Route DNS queries through Cloudflare's DNS-over-HTTPS to prevent DNS leaks when using proxies.</p>": "<p>Envoie les requĂȘtes DNS par le DNS-over-HTTPS de Cloudflare pour Ă©viter les fuites DNS avec les proxies.</p>",+ "<p>Pass a useragent string to be used. Otherwise the fetcher will generate a real Useragent of the same browser and use it.</p>": "<p>ChaĂźne User-Agent Ă utiliser. Sinon, le fetcher en gĂ©nĂšre une qui correspond Ă un navigateur rĂ©el du mĂȘme type.</p>",+ "<p>Set cookies for the next request.</p>": "<p>Cookies Ă utiliser pour la prochaine requĂȘte.</p>",+ "<p>Wait for the page until there are no network connections for at least 500 ms.</p>": "<p>Attend que la page nâait plus de connexions rĂ©seau pendant au moins 500 ms.</p>",+ "<p>The timeout in milliseconds that is used in all operations and waits through the page. The default is 30,000</p>": "<p>DĂ©lai maximal en millisecondes pour toutes les opĂ©rations et attentes de la page. La valeur par dĂ©faut est 30 000.</p>",+ "<p>The time (milliseconds) the fetcher will wait after everything finishes before closing the page and returning the <code>Response</code> object.</p>": "<p>DurĂ©e en millisecondes pendant laquelle le fetcher attend une fois tout terminĂ©, avant de fermer la page et de renvoyer lâobjet <code>Response</code>.</p>",+ "<p>Added for automation. A function that takes the <code>page</code> object, runs after navigation, and does the automation you need.</p>": "<p>Fonction pour automatiser des tĂąches. Elle reçoit lâobjet <code>page</code> et sâexĂ©cute aprĂšs la navigation.</p>",+ "<p>A function that takes the <code>page</code> object, runs before navigation. Use it to register event listeners or routes that must be set up before the page loads.</p>": "<p>Fonction qui reçoit lâobjet <code>page</code> et sâexĂ©cute avant la navigation. Utilisez-la pour enregistrer des Ă©couteurs dâĂ©vĂ©nements ou des routes qui doivent ĂȘtre prĂȘts avant le chargement.</p>",+ "<p>Wait for a specific CSS selector to be in a specific state.</p>": "<p>Attend quâun sĂ©lecteur CSS prĂ©cis atteigne lâĂ©tat indiquĂ©.</p>",+ "<p>An absolute path to a JavaScript file to be executed on page creation for all pages in this session.</p>": "<p>Chemin absolu dâun fichier JavaScript exĂ©cutĂ© Ă la crĂ©ation de chaque page de cette session.</p>",+ "<p>Specify user locale, for example, <code>en-GB</code>, <code>de-DE</code>, etc. Locale will affect navigator.language value, Accept-Language request header value as well as number and date formatting\nrules. Defaults to the system default locale.</p>": "<p>ParamĂštres rĂ©gionaux de lâutilisateur, comme <code>en-GB</code> ou <code>de-DE</code>. Ils influencent navigator.language, lâen-tĂȘte Accept-Language et le format des nombres et dates. Par dĂ©faut, utilise ceux du systĂšme.</p>",+ "<p>Changes the timezone of the browser. Defaults to the system timezone.</p>": "<p>Change le fuseau horaire du navigateur. Utilise celui du systĂšme par dĂ©faut.</p>",+ "<p>The state to wait for the selector given with <code>wait_selector</code>. The default state is <code>attached</code>.</p>": "<p>Ătat Ă attendre pour le sĂ©lecteur dĂ©fini dans <code>wait_selector</code>. La valeur par dĂ©faut est <code>attached</code>.</p>",+ "<p>Solves all types of the Cloudflare's Turnstile/Interstitial challenges before returning the response to you.</p>": "<p>RĂ©sout les diffĂ©rents types de dĂ©fis Turnstile et Interstitial de Cloudflare avant de renvoyer la rĂ©ponse.</p>",+ "<p>If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it.</p>": "<p>Si Chrome est installĂ© sur votre appareil, activez cette option pour que le fetcher ouvre et utilise une instance de ce navigateur.</p>",+ "<p>Add random noise to canvas operations to prevent fingerprinting.</p>": "<p>Ajoute du bruit alĂ©atoire aux opĂ©rations canvas pour Ă©viter lâidentification par empreinte du navigateur.</p>",+ "<p>Forces WebRTC to respect proxy settings to prevent local IP address leak.</p>": "<p>Force WebRTC Ă respecter les rĂ©glages du proxy pour Ă©viter une fuite de lâadresse IP locale.</p>",+ "<p>Enabled by default. Disabling it disables WebGL and WebGL 2.0 support entirely. Disabling WebGL is not recommended as many WAFs now check if WebGL is enabled.</p>": "<p>ActivĂ© par dĂ©faut. Le dĂ©sactiver supprime entiĂšrement la prise en charge de WebGL et WebGL 2.0. Ce nâest pas conseillĂ©, car de nombreux WAF vĂ©rifient si WebGL est actif.</p>",+ "<p>Enabled by default, wait for all JavaScript on page(s) to fully load and execute.</p>": "<p>ActivĂ© par dĂ©faut. Attend le chargement et lâexĂ©cution de tout le JavaScript des pages.</p>",+ "<p>Include open Shadow DOM content in the response HTML. Defaults to False.</p>": "<p>Inclut le contenu du Shadow DOM ouvert dans le HTML de la rĂ©ponse. La valeur par dĂ©faut est False.</p>",+ "<p>Instead of launching a new browser instance, connect to this CDP URL to control real browsers through CDP.</p>": "<p>Se connecte Ă cette URL CDP pour contrĂŽler un navigateur existant au lieu dâouvrir une nouvelle instance.</p>",+ "<p>Enabled by default, Scrapling will set a Google referer header.</p>": "<p>ActivĂ© par dĂ©faut. Scrapling ajoute un en-tĂȘte referer de Google.</p>",+ "<p>A dictionary of extra headers to add to the request. <em>The referer set by <code>google_search</code> takes priority over the referer set here if used together.</em></p>": "<p>Dictionnaire dâen-tĂȘtes supplĂ©mentaires pour la requĂȘte. <em>Le referer de <code>google_search</code> a prioritĂ© sur celui dĂ©fini ici si les deux sont utilisĂ©s.</em></p>",+ "<p>The proxy to be used with requests, it can be a string or a dictionary with the keys 'server', 'username', and 'password' only.</p>": "<p>Proxy utilisĂ© pour les requĂȘtes. Peut ĂȘtre une chaĂźne ou un dictionnaire contenant uniquement les clĂ©s 'server', 'username' et 'password'.</p>",+ "<p>Path to a User Data Directory, which stores browser session data like cookies and local storage. The default is to create a temporary directory.</p>": "<p>Chemin du dossier de donnĂ©es utilisateur, qui conserve les cookies et le stockage local du navigateur. Par dĂ©faut, crĂ©e un dossier temporaire.</p>",+ "<p>A list of additional browser flags to pass to the browser on launch.</p>": "<p>Liste dâoptions supplĂ©mentaires transmises au navigateur Ă son lancement.</p>",+ "<p>The arguments that will be passed in the end while creating the final Selector's class.</p>": "<p>Arguments transmis lors de la crĂ©ation de la classe Selector finale.</p>",+ "<p>Additional arguments to be passed to Playwright's context as additional settings, and it takes higher priority than Scrapling's settings.</p>": "<p>RĂ©glages supplĂ©mentaires du contexte Playwright. Ils ont prioritĂ© sur les rĂ©glages de Scrapling.</p>",+ "<p>A <code>Response</code> object.</p>": "<p>Objet <code>Response</code>.</p>",+ "<p>A factory context manager that provides configured Fetcher sessions.</p>": "<p>Gestionnaire de contexte qui crĂ©e des sessions Fetcher avec la configuration indiquĂ©e.</p>",+ "<p>When this manager is used in a 'with' or 'async with' block,\nit yields a new session configured with the manager's defaults.\nA single instance of this manager should ideally be used for one active\nsession at a time (or sequentially). Re-entering a context with the\nsame manager instance while a session is already active is disallowed.</p>": "<p>Utiliser ce gestionnaire dans un bloc 'with' ou 'async with' fournit une nouvelle session avec ses valeurs par dĂ©faut. Utilisez chaque instance pour une seule session active Ă la fois, ou pour des sessions successives. Vous ne pouvez pas entrer de nouveau dans un contexte avec la mĂȘme instance si une session est dĂ©jĂ active.</p>",+ "<p>Browser version to impersonate. Can be a single browser string or a list of browser strings for random selection. (Default: latest available Chrome version)</p>": "<p>Version du navigateur Ă imiter. Peut ĂȘtre une chaĂźne ou une liste de chaĂźnes pour un choix alĂ©atoire. Par dĂ©faut, utilise la derniĂšre version disponible de Chrome.</p>",+ "<p>Whether to use HTTP3. Defaults to False. It might be problematic if used it with <code>impersonate</code>.</p>": "<p>Indique si HTTP3 est utilisĂ©. La valeur par dĂ©faut est False. Peut poser problĂšme avec <code>impersonate</code>.</p>",+ "<p>If enabled (default), it creates and adds real browser headers. It also sets a Google referer header.</p>": "<p>Si activĂ©, ce qui est le cas par dĂ©faut, crĂ©e et ajoute de vrais en-tĂȘtes de navigateur ainsi quâun referer de Google.</p>",+ "<p>Dict of proxies to use. Format: {\"http\": proxy_url, \"https\": proxy_url}.</p>": "<p>Dictionnaire des proxies Ă utiliser. Format : {\"http\": proxy_url, \"https\": proxy_url}.</p>",+ "<p>Proxy URL to use. Format: \"http://username:password@localhost:8030\".\nCannot be used together with the <code>proxies</code> parameter.</p>": "<p>URL du proxy. Format : \"http://username:password@localhost:8030\". Ne peut pas ĂȘtre utilisĂ© avec <code>proxies</code>.</p>",+ "<p>HTTP basic auth for proxy, tuple of (username, password).</p>": "<p>Authentification HTTP Basic du proxy sous forme de tuple (username, password).</p>",+ "<p>Number of seconds to wait before timing out.</p>": "<p>Nombre de secondes avant expiration du dĂ©lai.</p>",+ "<p>Headers to include in the session with every request.</p>": "<p>En-tĂȘtes inclus dans chaque requĂȘte de la session.</p>",+ "<p>Number of retry attempts. Defaults to 3.</p>": "<p>Nombre de nouvelles tentatives. La valeur par dĂ©faut est 3.</p>",+ "<p>Number of seconds to wait between retry attempts. Defaults to 1 second.</p>": "<p>Secondes dâattente entre les nouvelles tentatives. La valeur par dĂ©faut est 1 seconde.</p>",+ "<p>Whether to follow redirects. Defaults to \"safe\", which follows redirects but rejects those targeting internal/private IPs (SSRF protection). Pass True to follow all redirects without restriction.</p>": "<p>Indique si les redirections sont suivies. La valeur par dĂ©faut est \"safe\" : suit les redirections, mais refuse celles qui visent des IP internes ou privĂ©es, pour protĂ©ger contre les SSRF. Utilisez True pour toutes les suivre sans restriction.</p>",+ "<p>Maximum number of redirects. Default 30, use -1 for unlimited.</p>": "<p>Nombre maximal de redirections. La valeur par dĂ©faut est 30. Utilisez -1 pour ne pas fixer de limite.</p>",+ "<p>Whether to verify HTTPS certificates. Defaults to True.</p>": "<p>Indique si les certificats HTTPS sont vĂ©rifiĂ©s. La valeur par dĂ©faut est True.</p>",+ "<p>Tuple of (cert, key) filenames for the client certificate.</p>": "<p>Tuple (cert, key) avec les noms des fichiers du certificat client et de sa clĂ©.</p>",+ "<p>Arguments passed when creating the final Selector class.</p>": "<p>Arguments transmis lors de la crĂ©ation de la classe Selector finale.</p>",+ "<p>A ProxyRotator instance for automatic proxy rotation.</p>": "<p>Instance de ProxyRotator pour la rotation automatique des proxies.</p>",+ "<p>Creates and returns a new synchronous Fetcher Session</p>": "<p>CrĂ©e et renvoie une nouvelle session Fetcher synchrone.</p>",+ "<p>Creates and returns a new asynchronous Session.</p>": "<p>CrĂ©e et renvoie une nouvelle session asynchrone.</p>",+ "<p>A Stealthy Browser session manager with page pooling.</p>": "<p>Gestionnaire de sessions de navigateur furtif avec un groupe de pages rĂ©utilisables.</p>",+ "<p>A Browser session manager with page pooling, it's using a persistent browser Context by default with a temporary user profile directory.</p>": "<p>Gestionnaire de sessions de navigateur avec un groupe de pages rĂ©utilisables. Par dĂ©faut, utilise un contexte persistant et un dossier temporaire pour le profil utilisateur.</p>",+ "<p>Save completed browser requests and responses. Failed or unfinished requests are omitted. Defaults to False.</p>": "<p>Enregistre les requĂȘtes et rĂ©ponses du navigateur qui sont terminĂ©es. Ignore celles qui ont Ă©chouĂ© ou sont encore en cours. La valeur par dĂ©faut est False.</p>",+ "<p>Maximum retained requests per session. Defaults to 1000; older entries are removed.</p>": "<p>Nombre maximal de requĂȘtes conservĂ©es par session. La valeur par dĂ©faut est 1 000. Les plus anciennes sont supprimĂ©es.</p>",+ "<p>Save cookies, local storage and IndexedDB to a Playwright-compatible JSON file.</p>": "<p>Enregistre les cookies, le stockage local et IndexedDB dans un fichier JSON compatible avec Playwright.</p>",+ "<p>Requires a started session without proxy rotation. Does not save sessionStorage.</p>": "<p>NĂ©cessite une session dĂ©marrĂ©e sans rotation des proxies. Nâenregistre pas sessionStorage.</p>",+ "<p>Replace cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Remplace les cookies, le stockage local et IndexedDB par les donnĂ©es dâun fichier JSON compatible avec Playwright.</p>",+ "<p>Requires a started session without proxy rotation. Fetch or reload pages to use the restored login.</p>": "<p>NĂ©cessite une session dĂ©marrĂ©e sans rotation des proxies. Chargez ou rechargez les pages pour utiliser la connexion restaurĂ©e.</p>",+ "<p>Close every open tab in the session's pool. The next request opens a fresh tab.</p>": "<p>Ferme tous les onglets du groupe de la session. La prochaine requĂȘte ouvre un nouvel onglet.</p>",+ "<p>Close all resources</p>": "<p>Ferme toutes les ressources.</p>",+ "<p>Get statistics about the current page pool</p>": "<p>Obtient les statistiques du groupe de pages actuel.</p>",+ "<p>Create a browser for this instance and context.</p>": "<p>CrĂ©e un navigateur pour cette instance et son contexte.</p>",+ "<p>Opens up the browser and do your request based on your chosen options.</p>": "<p>Ouvre le navigateur et effectue la requĂȘte avec les options choisies.</p>",+ "<p>The Target url.</p>": "<p>URL cible.</p>",+ "<p>Static proxy to override rotator and session proxy. A new browser context will be created and used with it.</p>": "<p>Proxy fixe qui remplace le rotateur et le proxy de la session. Un nouveau contexte de navigateur est créé pour lâutiliser.</p>",+ "<p>An async Stealthy Browser session manager with page pooling.</p>": "<p>Gestionnaire asynchrone de sessions de navigateur furtif avec un groupe de pages rĂ©utilisables.</p>",+ "<p>A thread-safe proxy rotator with pluggable rotation strategies.</p>": "<p>Rotateur de proxies utilisable sans conflit entre threads, avec des stratĂ©gies de rotation interchangeables.</p>",+ "<p>Supports:\n- Cyclic rotation (default)\n- Custom rotation strategies via callable\n- Both string URLs and Playwright-style dict proxies</p>": "<p>Accepte la rotation cyclique par dĂ©faut, des stratĂ©gies personnalisĂ©es dĂ©finies par un objet appelable et des proxies sous forme de chaĂźnes dâURL ou de dictionnaires au format Playwright.</p>",+ "<p>Initialize the proxy rotator.</p>": "<p>Initialise le rotateur de proxies.</p>",+ "<p>List of proxy URLs or Playwright-style proxy dicts.\n- String format: \"http://proxy1:8080\" or \"http://user:pass@proxy:8080\"\n- Dict format: {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}</p>": "<p>Liste dâURL de proxies ou de dictionnaires au format Playwright. Format chaĂźne : \"http://proxy1:8080\" ou \"http://user:pass@proxy:8080\". Format dictionnaire : {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}.</p>",+ "<p>Rotation strategy function. Takes (proxies, current_index) and returns (proxy, next_index). Defaults to cyclic_rotation.</p>": "<p>Fonction qui dĂ©finit la stratĂ©gie de rotation. Reçoit (proxies, current_index) et renvoie (proxy, next_index). La valeur par dĂ©faut est cyclic_rotation.</p>",+ "<p>Get a copy of all configured proxies.</p>": "<p>Obtient une copie de tous les proxies configurĂ©s.</p>",+ "<p>Get the next proxy according to the rotation strategy.</p>": "<p>Obtient le prochain proxy selon la stratĂ©gie de rotation.</p>",+ "<p>Return the total number of configured proxies.</p>": "<p>Renvoie le nombre total de proxies configurĂ©s.</p>",+ "<p>Extends standard Python string by adding more functionality</p>": "<p>Ătend les chaĂźnes Python avec des fonctions supplĂ©mentaires.</p>",+ "<p>Return a sorted version of the string</p>": "<p>Renvoie une version triĂ©e de la chaĂźne.</p>",+ "<p>Return a new version of the string after removing all white spaces and consecutive spaces</p>": "<p>Renvoie une nouvelle version de la chaĂźne aprĂšs suppression des caractĂšres dâespacement et des espaces consĂ©cutifs.</p>",+ "<p>Return JSON response if the response is jsonable otherwise throw error</p>": "<p>Renvoie la rĂ©ponse en JSON si la conversion est possible, sinon lĂšve une erreur.</p>",+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Si activĂ©, ignore les caractĂšres dâespacement et les espaces consĂ©cutifs lors de la recherche.</p>",+ "<p>If disabled, function will set the regex to ignore the letters-case while compiling it</p>": "<p>Si dĂ©sactivĂ©, compile lâexpression rĂ©guliĂšre sans distinguer les majuscules des minuscules.</p>",+ "<p>Used to quickly check if this regex matches or not without any operations on the results</p>": "<p>VĂ©rifie rapidement si lâexpression rĂ©guliĂšre correspond, sans traiter les rĂ©sultats.</p>",+ "<p>The :class:<code>TextHandlers</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>La classe :class:<code>TextHandlers</code> hĂ©rite de la classe intĂ©grĂ©e <code>List</code> et ajoute quelques mĂ©thodes.</p>",+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as TextHandlers.</p>": "<p>Appelle <code>.re()</code> pour chaque Ă©lĂ©ment de cette liste et rĂ©unit les rĂ©sultats dans un TextHandlers, sans listes imbriquĂ©es.</p>",+ "<p>if disabled, the function will set the regex to ignore the letters-case while compiling it</p>": "<p>Si dĂ©sactivĂ©, compile lâexpression rĂ©guliĂšre sans distinguer les majuscules des minuscules.</p>",+ "<p>Call the <code>.re_first()</code> method for each element in this list and return\nthe first result or the default value otherwise.</p>": "<p>Appelle <code>.re_first()</code> pour chaque Ă©lĂ©ment de cette liste et renvoie le premier rĂ©sultat, ou la valeur par dĂ©faut sâil nây en a pas.</p>",+ "<p>Returns the first item of the current list</p>": "<p>Renvoie le premier Ă©lĂ©ment de la liste actuelle.</p>",+ "<p>the default value to return if the current list is empty</p>": "<p>Valeur renvoyĂ©e si la liste actuelle est vide.</p>",+ "<p>A read-only mapping to use instead of the standard dictionary for the speed boost, but at the same time I use it to add more functionalities.\nIf the standard dictionary is needed, convert this class to a dictionary with the <code>dict</code> function</p>": "<p>Mapping en lecture seule qui remplace le dictionnaire habituel pour amĂ©liorer la vitesse et ajouter des fonctions. Si vous avez besoin dâun dictionnaire normal, convertissez-le avec la fonction <code>dict</code>.</p>",+ "<p>Convert current attributes to JSON bytes if the attributes are JSON serializable otherwise throws error</p>": "<p>Convertit les attributs actuels en bytes JSON sâils peuvent ĂȘtre sĂ©rialisĂ©s. Sinon, lĂšve une erreur.</p>",+ "<p>Acts like the standard dictionary <code>.get()</code> method</p>": "<p>Fonctionne comme la mĂ©thode <code>.get()</code> dâun dictionnaire normal.</p>",+ "<p>Search current attributes by values and return a dictionary of each matching item</p>": "<p>Cherche dans les valeurs des attributs actuels et renvoie un dictionnaire pour chaque correspondance.</p>",+ "<p>The keyword to search for in the attribute values</p>": "<p>Texte Ă chercher dans les valeurs des attributs.</p>",+ "<p>If True, the function will search if keyword in each value instead of perfect match</p>": "<p>Si la valeur est True, vĂ©rifie si chaque valeur contient le texte au lieu dâexiger une correspondance exacte.</p>",+ "<p>Request's response information structure.</p>": "<p>Structure contenant les informations de rĂ©ponse dâune requĂȘte.</p>",+ "<p><code>browser_network_requests</code> returns <code>NetworkRequestsModel</code> with <code>requests</code>, <code>next_cursor</code>, <code>has_more</code>, and <code>dropped_count</code>. Each <code>NetworkRequestInfo</code> contains <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code>, and <code>status</code>. Pass <code>next_cursor</code> as <code>after_id</code> to continue; <code>has_more</code> indicates more current matches.</p>": "<p><code>browser_network_requests</code> renvoie un <code>NetworkRequestsModel</code> avec <code>requests</code>, <code>next_cursor</code>, <code>has_more</code> et <code>dropped_count</code>. Chaque <code>NetworkRequestInfo</code> contient <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code> et <code>status</code>. Passez <code>next_cursor</code> comme <code>after_id</code> pour continuer. <code>has_more</code> indique sâil reste des correspondances dans lâhistorique actuel.</p>",+ "<p><code>browser_network_request</code> returns <code>NetworkRequestModel</code> with <code>request_id</code>, <code>part</code>, <code>data</code>, and <code>note</code>. Summaries and headers are objects; the full saved body text is returned as a string, including JSON response text. <code>note</code> explains missing body data or partial headers.</p>": "<p><code>browser_network_request</code> renvoie un <code>NetworkRequestModel</code> avec <code>request_id</code>, <code>part</code>, <code>data</code> et <code>note</code>. Les rĂ©sumĂ©s et en-tĂȘtes sont des objets. Le texte complet du corps enregistrĂ© est renvoyĂ© sous forme de chaĂźne, y compris pour les rĂ©ponses JSON. <code>note</code> explique si le corps manque ou si les en-tĂȘtes sont incomplets.</p>",+ "<p>Summary of a recorded browser request.</p>": "<p>RĂ©sumĂ© dâune requĂȘte enregistrĂ©e du navigateur.</p>",+ "<p>Recorded request summaries and pagination details.</p>": "<p>RĂ©sumĂ©s des requĂȘtes enregistrĂ©es et informations de pagination.</p>",+ "<p>One complete saved request part, with an optional note.</p>": "<p>Une partie complĂšte dâune requĂȘte enregistrĂ©e, avec une note facultative.</p>",+ "<p>Model classes for session management:</p>": "<p>Classes de modĂšles pour gĂ©rer les sessions :</p>",+ "<p>Information about an open browser session.</p>": "<p>Informations sur une session de navigateur ouverte.</p>",+ "<p>Response returned when a new session is created.</p>": "<p>RĂ©ponse renvoyĂ©e Ă la crĂ©ation dâune session.</p>",+ "<p>Response returned when a session is closed.</p>": "<p>RĂ©ponse renvoyĂ©e Ă la fermeture dâune session.</p>",+ "<p>The main MCP server class that provides all web scraping tools:</p>": "<p>Classe principale du serveur MCP, qui fournit tous les outils dâextraction web :</p>",+ "<p><strong><code>browser_fetch_once</code></strong>: Fetch one URL through a stealthy browser with JavaScript rendering and Cloudflare handling, then close the browser. Use a persistent session for later actions or network history.</p>": "<p><strong><code>browser_fetch_once</code></strong> : rĂ©cupĂšre une URL avec un navigateur furtif, le rendu JavaScript et la gestion des dĂ©fis Cloudflare, puis ferme le navigateur. Utilisez une session persistante pour effectuer dâautres actions ensuite ou consulter lâhistorique rĂ©seau.</p>",+ "<p><strong><code>browser_extract</code></strong>: Read the current page or one element as an AI snapshot, HTML, Markdown, or text without reloading it. Keep results from forms and page actions. Snapshots include element roles, names, references, positions, and sizes; regex search returns matching lines with nearby context and parent nodes.</p>": "<p><strong><code>browser_extract</code></strong> : lit la page actuelle ou un Ă©lĂ©ment sous forme de snapshot pour lâIA, de HTML, de Markdown ou de texte, sans recharger. Conserve les rĂ©sultats des formulaires et des actions. Les snapshots incluent les rĂŽles, noms, rĂ©fĂ©rences, positions et tailles des Ă©lĂ©ments. La recherche regex renvoie les lignes correspondantes avec le contexte proche et les nĆuds parents.</p>",+ "<p><strong><code>browser_actions</code></strong>: Chain mouse moves, hovers, clicks, scrolling, field filling, keyboard shortcuts, dialog replies, and waits in one call. Accept or dismiss alerts and confirmations, or enter text in prompts. Fill a search box, submit it, wait for results, and open a result without a separate call for each step.</p>": "<p><strong><code>browser_actions</code></strong> : combine les dĂ©placements de souris, survols, clics, dĂ©filements, remplissages de champs, raccourcis clavier, rĂ©ponses aux boĂźtes de dialogue et attentes dans un appel. Accepte ou ferme les alertes et confirmations, ou saisit du texte dans les invites. Vous pouvez remplir un champ de recherche, envoyer la recherche, attendre les rĂ©sultats et en ouvrir un sans faire un appel par Ă©tape.</p>",+ "<p>Moves and clicks target selectors, snapshot references, or coordinates; element targets wait and scroll into view. Supports movement in multiple steps, left, right, and middle clicks, double-clicks, and scrolling nested panels.</p>": "<p>Les dĂ©placements et clics peuvent utiliser des sĂ©lecteurs, des rĂ©fĂ©rences de snapshot ou des coordonnĂ©es. Si la cible est un Ă©lĂ©ment, lâaction attend sa disponibilitĂ© et fait dĂ©filer la page pour le rendre visible. Accepte les dĂ©placements en plusieurs Ă©tapes, les clics gauche, droit et central, les doubles clics et le dĂ©filement des panneaux imbriquĂ©s.</p>",+ "<p>Target fields anywhere on the page through selectors or snapshot references. Fill text, check or uncheck boxes, select radio buttons, and choose one or more native dropdown options by label. Replace or clear text, or type at the current caret. Keyboard shortcuts use the current focus. Slow mode adds random pauses between typed characters and all actions.</p>": "<p>Ciblez des champs partout dans la page avec des sĂ©lecteurs ou des rĂ©fĂ©rences de snapshot. Saisissez du texte, cochez ou dĂ©cochez des cases, choisissez des boutons radio et sĂ©lectionnez une ou plusieurs options de listes dĂ©roulantes natives par leur libellĂ©. Vous pouvez remplacer ou effacer du texte, ou Ă©crire Ă la position du curseur. Les raccourcis clavier utilisent le focus actuel. Le mode lent ajoute des pauses alĂ©atoires entre les caractĂšres saisis et entre toutes les actions.</p>",+ "<p>Wait for content or loading overlays through selectors or snapshot references, wait for page load events or settled network activity, or add a fixed pause before continuing.</p>": "<p>Attendez le contenu ou les indicateurs de chargement superposĂ©s avec des sĂ©lecteurs ou des rĂ©fĂ©rences de snapshot. Vous pouvez aussi attendre les Ă©vĂ©nements de chargement, la stabilisation de lâactivitĂ© rĂ©seau ou une durĂ©e fixe avant de continuer.</p>",+ "<p><strong><code>browser_evaluate</code></strong>: Run JavaScript on the current page to extract custom data, calculate results, read application state, or update page content. Supports asynchronous scripts and returns their results as JSON.</p>": "<p><strong><code>browser_evaluate</code></strong> : exĂ©cute JavaScript dans la page actuelle pour extraire des donnĂ©es, calculer des rĂ©sultats, lire lâĂ©tat de lâapplication ou modifier le contenu. Accepte les scripts asynchrones et renvoie leurs rĂ©sultats en JSON.</p>",+ "<p>Create a Scrapling MCP server.</p>": "<p>CrĂ©e un serveur MCP Scrapling.</p>",+ "<p>Optional global Chromium-compatible browser executable path for browser tools.\nIf omitted, the SCRAPLING_EXECUTABLE_PATH environment variable is used when set.</p>": "<p>Chemin global facultatif vers un exĂ©cutable compatible avec Chromium pour les outils de navigateur. Sâil nâest pas fourni, utilise la variable dâenvironnement SCRAPLING_EXECUTABLE_PATH quand elle est dĂ©finie.</p>",+ "<p>Optional shared token that clients must send as <code>Authorization: Bearer <token></code>.\nIf omitted, the SCRAPLING_MCP_AUTH_TOKEN environment variable is used when set. It only applies\nto the streamable-http transport.</p>": "<p>Jeton partagĂ© facultatif que les clients doivent envoyer sous la forme <code>Authorization: Bearer <token></code>. Sâil nâest pas fourni, utilise la variable dâenvironnement SCRAPLING_MCP_AUTH_TOKEN quand elle est dĂ©finie. Sâapplique uniquement au transport streamable-http.</p>",+ "<p>Open a reusable stealthy browser session. Pass per-request options to <code>browser_fetch</code>.</p>": "<p>Ouvre une session rĂ©utilisable de navigateur furtif. Passez les options propres Ă chaque requĂȘte Ă <code>browser_fetch</code>.</p>",+ "<p>Save browser cookies, local storage and IndexedDB as Playwright-compatible JSON. Excludes sessionStorage.</p>": "<p>Enregistre les cookies du navigateur, le stockage local et IndexedDB en JSON compatible avec Playwright. Nâinclut pas sessionStorage.</p>",+ "<p>Replace browser cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Remplace les cookies du navigateur, le stockage local et IndexedDB par les donnĂ©es dâun fichier JSON compatible avec Playwright.</p>",+ "<p>Leaves sessionStorage and open tabs unchanged. Fetch or reload pages to use the restored login.</p>": "<p>Ne modifie ni sessionStorage ni les onglets ouverts. Chargez ou rechargez les pages pour utiliser la connexion restaurĂ©e.</p>",+ "<p>Open a reusable HTTP session for <code>session_make_request</code>, keeping cookies, connections, and request settings.</p>": "<p>Ouvre une session HTTP rĂ©utilisable pour <code>session_make_request</code>, en gardant les cookies, connexions et rĂ©glages des requĂȘtes.</p>",+ "<p>Close a session and free its resources.</p>": "<p>Ferme une session et libĂšre ses ressources.</p>",+ "<p>List registered sessions, their status, and effective settings.</p>": "<p>Liste les sessions enregistrĂ©es, leur Ă©tat et leurs rĂ©glages actifs.</p>",+ "<p>List completed requests across page changes, with IDs and pagination. Recording starts when the browser session opens.</p>": "<p>Liste les requĂȘtes terminĂ©es, mĂȘme aprĂšs un changement de page, avec identifiants et pagination. Lâenregistrement commence Ă lâouverture de la session de navigateur.</p>",+ "<p>Read a complete saved request part without resending it, with structured data and availability notes.</p>": "<p>Lit une partie complĂšte dâune requĂȘte enregistrĂ©e sans la renvoyer, avec des donnĂ©es structurĂ©es et des notes sur leur disponibilitĂ©.</p>",+ "<p>Read the current page or one element as snapshot, HTML, Markdown, or text without navigating.\nReturn plain text; snapshot search keeps refs, ancestor paths and three lines of nearby context.</p>": "<p>Lit la page actuelle ou un Ă©lĂ©ment sous forme de snapshot, HTML, Markdown ou texte, sans naviguer. Renvoie du texte brut. La recherche dans les snapshots conserve les rĂ©fĂ©rences, les chemins des ancĂȘtres et trois lignes de contexte proche.</p>",+ "<p>Run mouse, field, key, dialog, and wait actions in order; return plain text without a snapshot.\nStop on the first error, identifying its action; partial effects remain. No retries.\nElement mouse targets auto-wait and scroll into view; coordinates and wheel do not wait for navigation or scrolling.\nCancelled/timed-out clicks attempt button release. Load waits observe the current document, not future navigation.</p>": "<p>ExĂ©cute dans lâordre les actions de souris, champs, touches, boĂźtes de dialogue et attentes. Renvoie du texte brut, sans snapshot. SâarrĂȘte Ă la premiĂšre erreur en indiquant lâaction concernĂ©e ; les effets dĂ©jĂ produits restent et aucune nouvelle tentative nâest faite. Une cible de souris qui est un Ă©lĂ©ment dĂ©clenche une attente et un dĂ©filement pour la rendre visible. Les actions avec coordonnĂ©es et la molette nâattendent pas la fin dâune navigation ou dâun dĂ©filement. En cas dâannulation ou de dĂ©passement du dĂ©lai dâun clic, le relĂąchement du bouton est tentĂ©. Les attentes de chargement observent le document actuel, pas une future navigation.</p>",+ "<p>Run JavaScript on the current page, await promises, and return JSON text without a snapshot.\nReturn JSON-compatible values; null/undefined become null. Script effects are not undone on failure.\nCancellation stops waiting, but may not stop the script.</p>": "<p>ExĂ©cute JavaScript dans la page actuelle, attend les promesses et renvoie du texte JSON sans snapshot. Renvoie des valeurs compatibles avec JSON ; null et undefined deviennent null. Les effets du script ne sont pas annulĂ©s en cas dâĂ©chec. Une annulation arrĂȘte lâattente, mais peut ne pas arrĂȘter le script.</p>",+ "<p>Capture the current page or one element without navigating; return the image and current URL.\nElement capture waits and scrolls into view. Use browser_actions for other waits before capture.</p>": "<p>Capture la page actuelle ou un Ă©lĂ©ment sans naviguer et renvoie lâimage et lâURL actuelle. La capture dâun Ă©lĂ©ment attend sa disponibilitĂ© et fait dĂ©filer la page pour le rendre visible. Utilisez browser_actions pour dâautres attentes avant la capture.</p>",+ "<p>Make an HTTP request without JavaScript. Suitable for low-to-mid protection.</p>": "<p>Effectue une requĂȘte HTTP sans JavaScript. AdaptĂ© aux sites avec une protection faible ou moyenne.</p>",+ "<p>Fetch a page with a stealth browser and JavaScript rendering.</p>": "<p>RĂ©cupĂšre une page avec un navigateur furtif et le rendu JavaScript.</p>",+ "<p>Fetch a URL in an open stealthy browser session. Options apply only to this request.</p>": "<p>RĂ©cupĂšre une URL dans une session ouverte de navigateur furtif. Les options sâappliquent uniquement Ă cette requĂȘte.</p>",+ "<p>Make an HTTP request using the session's cookies, connections, impersonation, and proxy. Options apply to this request.</p>": "<p>Effectue une requĂȘte HTTP avec les cookies, connexions, identitĂ© de navigateur et proxy de la session. Les options sâappliquent Ă cette requĂȘte.</p>",+ "<p>Serve the MCP server.</p>": "<p>DĂ©marre le serveur MCP.</p>",+ "<p>Serve over the streamable-http transport instead of stdio.</p>": "<p>Utilise le transport streamable-http au lieu de stdio.</p>",+ "<p>The host to bind to when <code>http</code> is enabled.</p>": "<p>HĂŽte sur lequel Ă©couter quand <code>http</code> est actif.</p>",+ "<p>The port to bind to when <code>http</code> is enabled.</p>": "<p>Port sur lequel Ă©couter quand <code>http</code> est actif.</p>",+ "<p>Host names to accept, which turns on DNS-rebinding protection.</p>": "<p>Noms dâhĂŽtes acceptĂ©s. Active la protection contre le DNS rebinding.</p>",+ "<p>Start the streamable-http transport without a token. The transport\nrequires authentication by default, so this is the explicit opt-out.</p>": "<p>DĂ©marre le transport streamable-http sans jeton. Il exige une authentification par dĂ©faut ; cette option la dĂ©sactive explicitement.</p>",+ "<p>The <code>Selectors</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>La classe <code>Selectors</code> hĂ©rite de la classe intĂ©grĂ©e <code>List</code> et ajoute quelques mĂ©thodes.</p>",+ "<p>Returns the first Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Renvoie le premier Selector de la liste actuelle, ou <code>None</code> si elle est vide.</p>",+ "<p>Returns the last Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Renvoie le dernier Selector de la liste actuelle, ou <code>None</code> si elle est vide.</p>",+ "<p>Returns the length of the current list</p>": "<p>Renvoie la longueur de la liste actuelle.</p>",+ "<p>Call the <code>.xpath()</code> method for each element in this list and return\ntheir results as another <code>Selectors</code> class.</p>": "<p>Appelle <code>.xpath()</code> pour chaque Ă©lĂ©ment de cette liste et renvoie les rĂ©sultats dans un autre <code>Selectors</code>.</p>",+ "<p>A string that will be used to retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>ChaĂźne utilisĂ©e pour retrouver les donnĂ©es de lâĂ©lĂ©ment en mode adaptatif. Sinon, le sĂ©lecteur est utilisĂ©.</p>",+ "<p>Call the <code>.css()</code> method for each element in this list and return\ntheir results flattened as another <code>Selectors</code> class.</p>": "<p>Appelle <code>.css()</code> pour chaque Ă©lĂ©ment de cette liste et rĂ©unit les rĂ©sultats dans un autre <code>Selectors</code>, sans listes imbriquĂ©es.</p>",+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as List of TextHandler.</p>": "<p>Appelle <code>.re()</code> pour chaque Ă©lĂ©ment de cette liste et rĂ©unit les rĂ©sultats dans une liste de TextHandler, sans listes imbriquĂ©es.</p>",+ "<p>if disabled, function will set the regex to ignore the letters case while compiling it</p>": "<p>Si dĂ©sactivĂ©, compile lâexpression rĂ©guliĂšre sans distinguer les majuscules des minuscules.</p>",+ "<p>Loop over all current elements and return the first element that matches the passed function</p>": "<p>Parcourt les Ă©lĂ©ments actuels et renvoie le premier qui satisfait la fonction fournie.</p>",+ "<p>A function that takes each element as an argument and returns True/False</p>": "<p>Fonction qui reçoit chaque Ă©lĂ©ment et renvoie True ou False.</p>",+ "<p>The first element that match the function or <code>None</code> otherwise.</p>": "<p>Premier Ă©lĂ©ment qui satisfait la fonction, ou <code>None</code> si aucun ne correspond.</p>",+ "<p>Filter current elements based on the passed function</p>": "<p>Filtre les Ă©lĂ©ments actuels avec la fonction fournie.</p>",+ "<p>The new <code>Selectors</code> object or empty list otherwise.</p>": "<p>Nouvel objet <code>Selectors</code>, ou liste vide si aucun rĂ©sultat ne correspond.</p>",+ "<p>Returns the serialized string of the first element, or <code>default</code> if empty.</p>": "<p>Renvoie la chaĂźne sĂ©rialisĂ©e du premier Ă©lĂ©ment, ou <code>default</code> si la liste est vide.</p>",+ "<p>Serialize all elements and return as a TextHandlers list.</p>": "<p>SĂ©rialise tous les Ă©lĂ©ments et les renvoie sous forme de liste TextHandlers.</p>",+ "<p>An abstract base class for creating web spiders.</p>": "<p>Classe de base abstraite pour crĂ©er des spiders web.</p>",+ "<p>Check the documentation website for more information.</p>": "<p>Consultez le site de documentation pour en savoir plus.</p>",+ "<p>Initialize the spider.</p>": "<p>Initialise le spider.</p>",+ "<p>Directory for checkpoint files. If provided, enables pause/resume.</p>": "<p>Dossier des fichiers de reprise. Sâil est dĂ©fini, active la pause et la reprise.</p>",+ "<p>Seconds between periodic checkpoint saves (default 5 minutes).</p>": "<p>Secondes entre les points de reprise pĂ©riodiques. La valeur par dĂ©faut correspond Ă 5 minutes.</p>",+ "<p>Access current crawl stats (works during streaming).</p>": "<p>AccĂšde aux statistiques actuelles de lâexploration, y compris pendant le streaming.</p>",+ "<p>Generate initial requests to start the crawl.</p>": "<p>Produit les requĂȘtes initiales pour lancer lâexploration.</p>",+ "<p>By default, this generates Request objects for each URL in <code>start_urls</code>\nusing the session manager's default session and <code>parse()</code> as callback.</p>": "<p>Par dĂ©faut, produit un objet Request pour chaque URL de <code>start_urls</code>, avec la session par dĂ©faut du gestionnaire et <code>parse()</code> comme callback.</p>",+ "<p>Override this method for more control over initial requests\n(e.g., to add custom headers, use different callbacks, etc.)</p>": "<p>RedĂ©finissez cette mĂ©thode pour contrĂŽler les requĂȘtes initiales, par exemple pour ajouter des en-tĂȘtes ou utiliser dâautres callbacks.</p>",+ "<p>Default callback for processing responses</p>": "<p>Callback par dĂ©faut pour traiter les rĂ©ponses.</p>",+ "<p>Called before crawling starts. Override for setup logic.</p>": "<p>AppelĂ© avant le dĂ©but de lâexploration. RedĂ©finissez-le pour prĂ©parer le travail.</p>",+ "<p>It's enabled if the spider is resuming from a checkpoint, left for the user to use.</p>": "<p>ActivĂ© si le spider reprend depuis un point de reprise. Vous pouvez lâutiliser dans votre logique.</p>",+ "<p>Called after crawling finishes. Override for cleanup logic.</p>": "<p>AppelĂ© aprĂšs la fin de lâexploration. RedĂ©finissez-le pour libĂ©rer les ressources.</p>",+ "<p>Handle request errors for all spider requests.</p>": "<p>GĂšre les erreurs de toutes les requĂȘtes du spider.</p>",+ "<p>Override for custom error handling.</p>": "<p>RedĂ©finissez-le pour appliquer votre propre gestion des erreurs.</p>",+ "<p>A hook to be overridden by users to do some processing on scraped items, return <code>None</code> to drop the item silently.</p>": "<p>Hook que vous pouvez redĂ©finir pour traiter les Ă©lĂ©ments extraits. Renvoyez <code>None</code> pour Ă©carter un Ă©lĂ©ment sans message.</p>",+ "<p>Check if the response is blocked. Users should override this for custom detection logic.</p>": "<p>VĂ©rifie si la rĂ©ponse est bloquĂ©e. RedĂ©finissez-le pour utiliser votre propre dĂ©tection.</p>",+ "<p>Users should override this to prepare the blocked request before retrying, if needed.</p>": "<p>RedĂ©finissez-le pour modifier une requĂȘte bloquĂ©e avant de rĂ©essayer, si nĂ©cessaire.</p>",+ "<p>String representation of the spider.</p>": "<p>ReprĂ©sentation du spider sous forme de chaĂźne.</p>",+ "<p>Configure sessions for this spider.</p>": "<p>Configure les sessions de ce spider.</p>",+ "<p>Override this method to add custom sessions.\nThe default implementation creates a FetcherSession session.</p>": "<p>RedĂ©finissez cette mĂ©thode pour ajouter vos propres sessions. LâimplĂ©mentation par dĂ©faut crĂ©e une FetcherSession.</p>",+ "<p>The first session added becomes the default for <code>start_requests()</code> unless specified otherwise.</p>": "<p>La premiĂšre session ajoutĂ©e est utilisĂ©e par dĂ©faut pour <code>start_requests()</code>, sauf si vous en indiquez une autre.</p>",+ "<p>SessionManager to configure</p>": "<p>SessionManager Ă configurer.</p>",+ "<p>Request graceful shutdown of the crawling process.</p>": "<p>Demande un arrĂȘt propre de lâexploration.</p>",+ "<p>Run the spider and return results.</p>": "<p>ExĂ©cute le spider et renvoie les rĂ©sultats.</p>",+ "<p>This is the main entry point for running a spider.\nHandles async execution internally via anyio.</p>": "<p>Point dâentrĂ©e principal pour exĂ©cuter un spider. GĂšre lâexĂ©cution asynchrone avec anyio.</p>",+ "<p>Pressing Ctrl+C will initiate graceful shutdown (waits for active tasks to complete).\nPressing Ctrl+C a second time will force immediate stop.</p>": "<p>Appuyer sur Ctrl+C lance un arrĂȘt propre qui attend la fin des tĂąches actives. Appuyer une seconde fois force lâarrĂȘt immĂ©diat.</p>",+ "<p>If crawldir is set, a checkpoint will also be saved on graceful shutdown,\nallowing you to resume the crawl later by running the spider again.</p>": "<p>Si crawldir est dĂ©fini, un point de reprise est aussi enregistrĂ© lors de lâarrĂȘt propre. Vous pouvez ainsi reprendre lâexploration en relançant le spider.</p>",+ "<p>Whether to use the faster uvloop/winloop event loop implementation, if available.</p>": "<p>Indique si la boucle dâĂ©vĂ©nements plus rapide de uvloop ou winloop est utilisĂ©e, quand elle est disponible.</p>",+ "<p>Asyncio backend options to be used with <code>anyio.run</code></p>": "<p>Options du backend asyncio transmises Ă <code>anyio.run</code>.</p>",+ "<p>Stream items as they're scraped. Ideal for long-running spiders or building applications on top of the spiders.</p>": "<p>Produit les Ă©lĂ©ments dĂšs leur extraction. Utile pour les spiders qui tournent longtemps ou les applications construites autour dâeux.</p>",+ "<p>Must be called from an async context. Yields items one by one as they are scraped.\nAccess <code>spider.stats</code> during iteration for real-time statistics.</p>": "<p>Doit ĂȘtre appelĂ© depuis un contexte asynchrone. Produit les Ă©lĂ©ments un Ă un dĂšs leur extraction. Consultez <code>spider.stats</code> pendant lâitĂ©ration pour voir les statistiques en temps rĂ©el.</p>",+ "<p>Note: SIGINT handling for pause/resume is not available in stream mode.</p>": "<p>Note : la gestion de SIGINT pour la pause et la reprise nâest pas disponible en mode streaming.</p>",+ "<p>Create a copy of this request.</p>": "<p>CrĂ©e une copie de cette requĂȘte.</p>",+ "<p>Generate a unique fingerprint for deduplication.</p>": "<p>GĂ©nĂšre une empreinte unique pour Ă©viter les doublons.</p>",+ "<p>Caches the result in self._fp after first computation.</p>": "<p>Conserve le rĂ©sultat dans self._fp aprĂšs le premier calcul.</p>",+ "<p>Compare requests by priority</p>": "<p>Compare les requĂȘtes selon leur prioritĂ©.</p>",+ "<p>Requests are equal if they have the same fingerprint.</p>": "<p>Deux requĂȘtes sont Ă©gales si elles ont la mĂȘme empreinte.</p>",+ "<p>Prepare state for pickling - store callback as name string for pickle compatibility.</p>": "<p>PrĂ©pare lâĂ©tat pour pickle en enregistrant le nom du callback comme chaĂźne pour assurer la compatibilitĂ©.</p>",+ "<p>Restore state from pickle - callback restored later via _restore_callback().</p>": "<p>Restaure lâĂ©tat depuis pickle. Le callback est restaurĂ© plus tard par _restore_callback().</p>",+ "<p>Complete result from a spider run.</p>": "<p>RĂ©sultat complet dâune exĂ©cution du spider.</p>",+ "<p>True if the crawl completed normally (not paused).</p>": "<p>True si lâexploration sâest terminĂ©e normalement, sans rester en pause.</p>",+ "<p>Statistics for a crawl run.</p>": "<p>Statistiques dâune exĂ©cution dâexploration.</p>",+ "<p>A list of scraped items with export capabilities.</p>": "<p>Liste dâĂ©lĂ©ments extraits avec des fonctions dâexportation.</p>",+ "<p>Export items to a JSON file.</p>": "<p>Exporte les Ă©lĂ©ments dans un fichier JSON.</p>",+ "<p>Path to the output file</p>": "<p>Chemin du fichier de sortie.</p>",+ "<p>Pretty-print with 2-space indentation (slightly slower)</p>": "<p>Utilise une mise en forme lisible avec une indentation de 2 espaces. Un peu plus lent.</p>",+ "<p>Export items as JSON Lines (one JSON object per line).</p>": "<p>Exporte les Ă©lĂ©ments en JSON Lines, avec un objet JSON par ligne.</p>",+ "<p>Export items to a CSV file.</p>": "<p>Exporte les Ă©lĂ©ments dans un fichier CSV.</p>",+ "<p>Items that don't share the same keys are still written, with the missing cells left empty, and any value\nthat isn't a scalar (a nested dictionary or a list) is written as JSON.</p>": "<p>Les Ă©lĂ©ments qui nâont pas les mĂȘmes clĂ©s sont aussi Ă©crits, avec les cellules manquantes laissĂ©es vides. Les valeurs non scalaires, comme les listes et dictionnaires imbriquĂ©s, sont Ă©crites en JSON.</p>",+ "<p>The columns to write, defaulting to every key found in the items, in the order they appeared</p>": "<p>Colonnes Ă Ă©crire. Par dĂ©faut, inclut toutes les clĂ©s trouvĂ©es dans les Ă©lĂ©ments, dans leur ordre dâapparition.</p>",+ "<p>The character separating the columns</p>": "<p>CaractĂšre qui sĂ©pare les colonnes.</p>",+ "<p>Export items to an XML file.</p>": "<p>Exporte les Ă©lĂ©ments dans un fichier XML.</p>",+ "<p>Each item becomes an element whose children are named after the item's keys. Keys that aren't valid XML\nnames are rewritten and keep the original in a <code>name</code> attribute, and any value that isn't a scalar\n(a nested dictionary or a list) is written as JSON.</p>": "<p>Chaque Ă©lĂ©ment devient un nĆud dont les enfants prennent ses clĂ©s comme noms. Les clĂ©s qui ne sont pas des noms XML valides sont adaptĂ©es et conservent leur forme dâorigine dans un attribut <code>name</code>. Les valeurs non scalaires, comme les listes et dictionnaires imbriquĂ©s, sont Ă©crites en JSON.</p>",+ "<p>The name of the element wrapping all the items</p>": "<p>Nom de lâĂ©lĂ©ment qui contient tous les Ă©lĂ©ments.</p>",+ "<p>The name of the element wrapping every item</p>": "<p>Nom de la balise qui contient chaque Ă©lĂ©ment.</p>",+ "<p>Pretty-print the file instead of writing it on a single line</p>": "<p>Met le fichier en forme pour faciliter la lecture au lieu de lâĂ©crire sur une seule ligne.</p>",+ "<p>Manages pre-configured session instances.</p>": "<p>GĂšre des instances de session dĂ©jĂ configurĂ©es.</p>",+ "<p>Register a session instance.</p>": "<p>Enregistre une instance de session.</p>",+ "<p>Name to reference this session in requests</p>": "<p>Nom utilisĂ© pour dĂ©signer cette session dans les requĂȘtes.</p>",+ "<p>Your pre-configured session instance</p>": "<p>Instance de session que vous avez configurĂ©e.</p>",+ "<p>If True, this becomes the default session</p>": "<p>Si la valeur est True, cette session devient celle par dĂ©faut.</p>",+ "<p>If True, the session will be started only when a request uses its ID.</p>": "<p>Si la valeur est True, la session dĂ©marre seulement quand une requĂȘte utilise son identifiant.</p>",+ "<p>Removes a session.</p>": "<p>Retire une session.</p>",+ "<p>ID of session to remove</p>": "<p>Identifiant de la session Ă retirer.</p>",+ "<p>Remove and returns a session.</p>": "<p>Retire et renvoie une session.</p>",+ "<p>Start all sessions that aren't already alive.</p>": "<p>DĂ©marre toutes les sessions qui ne sont pas encore actives.</p>",+ "<p>Close all registered sessions.</p>": "<p>Ferme toutes les sessions enregistrĂ©es.</p>",+ "<p>Check if a session ID is registered.</p>": "<p>VĂ©rifie si un identifiant de session est enregistrĂ©.</p>",+ "<p>Number of registered sessions.</p>": "<p>Nombre de sessions enregistrĂ©es.</p>"+} %}+{% macro translate(value) %}+ {% set result = namespace(html=value | replace("Bases:", "Classes de base :")) %}+ {% for source, target in translations.items() %}+ {% set result.html = result.html | replace(source, target | safe) %}+ {% endfor %}+ {{ result.html | safe }}+{% endmacro %}diff --git a/zensical-base.yml b/zensical-base.ymlindex bfb4b75..9a201e6 100644--- a/zensical-base.yml+++ b/zensical-base.yml@@ -126,6 +126,9 @@ extra:- name: PortuguĂȘs (Brasil)link: https://scrapling.readthedocs.io/en/latest/pt-BR/lang: pt-BR+ - name: Français+ link: https://scrapling.readthedocs.io/en/latest/fr/+ lang: frwatch:- zensical-base.yml- docs/assetsdiff --git a/zensical.fr.yml b/zensical.fr.ymlnew file mode 100644index 0000000..a06ed98--- /dev/null+++ b/zensical.fr.yml@@ -0,0 +1,99 @@+INHERIT: zensical-base.yml+site_description: Scrapling - Extrayez simplement les donnĂ©es du web moderne.+site_url: https://scrapling.readthedocs.io/en/latest/fr/+docs_dir: docs/locales/fr+site_dir: site/fr+edit_uri: edit/main/docs/locales/fr/+copyright: Copyright © 2025 Karim Shoair - <a href="#__consent">Modifier les rĂ©glages des cookies</a>+nav:+- Introduction: index.md+- Vue dâensemble: overview.md+- Tests de performance: benchmarks.md+- Guide dâutilisation:+ - Analyse de pages:+ - SĂ©lection dâĂ©lĂ©ments: parsing/selection.md+ - Classes principales: parsing/main_classes.md+ - Scraping adaptatif: parsing/adaptive.md+ - RĂ©cupĂ©ration de pages:+ - Choisir un fetcher: fetching/choosing.md+ - RequĂȘtes HTTP: fetching/static.md+ - RĂ©cupĂ©ration avec un navigateur: fetching/stealthy.md+ - Spiders:+ - Architecture: spiders/architecture.md+ - Premiers pas: spiders/getting-started.md+ - RequĂȘtes et rĂ©ponses: spiders/requests-responses.md+ - Sessions: spiders/sessions.md+ - Proxies et blocages: spiders/proxy-blocking.md+ - ModĂšles gĂ©nĂ©raux: spiders/generic-templates.md+ - ModĂšles de plateformes: spiders/platform-templates.md+ - Fonctions avancĂ©es: spiders/advanced.md+ - Ligne de commande:+ - Vue dâensemble: cli/overview.md+ - Shell interactif: cli/interactive-shell.md+ - Commandes dâextraction: cli/extract-commands.md+ - Utilisation avec lâIA:+ - Serveur MCP: ai/mcp-server.md+ - Agent Skill: ai/agent-skill.md+ - CrĂ©er des systĂšmes RAG: ai/building-rag-systems.md+ - IntĂ©grations et migrations:+ - IntĂ©gration avec Scrapy: integrations/scrapy.md+ - Migrer depuis BeautifulSoup: tutorials/migrating_from_beautifulsoup.md+- Tutoriels:+ - Une solution gratuite pour extraire des donnĂ©es sans IA: tutorials/replacing_ai.md+- DĂ©veloppement:+ - RĂ©fĂ©rence de lâAPI:+ - Selector: api-reference/selector.md+ - Fetchers: api-reference/fetchers.md+ - Serveur MCP: api-reference/mcp-server.md+ - Types personnalisĂ©s: api-reference/custom-types.md+ - Response: api-reference/response.md+ - Spiders: api-reference/spiders.md+ - Rotation des proxies: api-reference/proxy-rotation.md+ - CrĂ©er votre systĂšme de rĂ©cupĂ©ration: development/adaptive_storage_system.md+ - Utiliser les types personnalisĂ©s de Scrapling: development/scrapling_custom_types.md+- Soutien et publicitĂ©: donate.md+- Contribuer: https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md+- Historique des changements: https://github.com/D4Vinci/Scrapling/blob/main/CHANGELOG.md+theme:+ language: fr+ palette:+ - media: '(prefers-color-scheme: light)'+ scheme: default+ accent: green+ primary: deep purple+ toggle:+ icon: lucide/sun+ name: Passer au mode sombre+ - media: '(prefers-color-scheme: dark)'+ scheme: slate+ accent: light green+ primary: deep purple+ toggle:+ icon: lucide/moon+ name: Passer au mode clair+markdown_extensions:+ toc:+ permalink_title: Lien permanent+plugins:+ mkdocstrings:+ locale: fr+extra:+ analytics:+ feedback:+ title: Cette page vous a-t-elle Ă©tĂ© utileâŻ?+ ratings:+ - icon: material/heart+ name: Cette page mâa Ă©tĂ© utile+ data: 1+ note: Merci pour votre avisâŻ!+ - icon: material/heart-broken+ name: Cette page peut ĂȘtre amĂ©liorĂ©e+ data: 0+ note: 'Merci pour votre avisâŻ! Aidez-nous Ă amĂ©liorer cette page en <a href="https://github.com/D4Vinci/Scrapling/issues/new?template=04-docs_issue.yml" target="_blank" rel="noopener">signalant un problĂšme de documentation</a>.'+ consent:+ title: Autorisation des cookies+ description: Nous utilisons des cookies pour retenir vos prĂ©fĂ©rences et savoir si la documentation vous aide Ă trouver ce que vous cherchez. Votre accord nous aide Ă lâamĂ©liorer.+ actions:+ - accept+ - reject+ - manage