Skip to content

đŸ•·ïž 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

docs: Add French docs for the website

Karim shoaird7182358bae6
diff --git a/docs/README_FR.md b/docs/README_FR.md
index 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>
&middot;
- <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>
&middot;
- <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>
&middot;
- <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>
&middot;
- <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>
&middot;
- <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 :
```python
from 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 :
```python
from 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
```python
from 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 :
```python
from 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 :
```python
from scrapling.spiders import Spider, Request, Response
from 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 :
```python
QuotesSpider(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 :
```python
from 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
```python
from scrapling.fetchers import Fetcher
@@ -420,15 +426,15 @@ parent_container = first_quote.parent
similar_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 :
```python
from scrapling.parser import Selector
page = 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
```python
import asyncio
from 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 :
[![asciicast](https://asciinema.org/a/736339.svg)](https://asciinema.org/a/736339)
-Lancer le shell interactif de Web Scraping
+Lancez le shell interactif de web scraping :
```bash
pip 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 :
```bash
pip 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 :
```bash
pip install "scrapling[fetchers]"
@@ -520,9 +526,9 @@ pip install scrapling
scrapling 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 :
```python
from scrapling.cli import install
@@ -530,47 +536,47 @@ pip install scrapling
install(["--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 :
```bash
pip 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) :
```bash
pip install "scrapling[rag]"
```
- - Installer les fonctionnalités shell (shell de Web Scraping et la commande `extract`) :
+ - Installer le shell interactif et la commande `extract` :
```bash
pip install "scrapling[shell]"
```
- - Tout installer :
+ - Tout installer :
```bash
pip 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 :
```bash
docker pull pyd4vinci/scrapling
```
-Ou téléchargez-la depuis le registre GitHub :
+Ou la télécharger depuis le registre GitHub :
```bash
docker 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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/assets
new file mode 120000
index 0000000..41aef43
--- /dev/null
+++ b/docs/locales/fr/assets
@@ -0,0 +1 @@
+../../assets
\ No newline at end of file
diff --git a/docs/locales/fr/benchmarks.md b/docs/locales/fr/benchmarks.md
new file mode 100644
index 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.md
new file mode 100644
index 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&param2=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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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 file
diff --git a/docs/locales/fr/fetching/choosing.md b/docs/locales/fr/fetching/choosing.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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 file
diff --git a/docs/locales/fr/parsing/main_classes.md b/docs/locales/fr/parsing/main_classes.md
new file mode 100644
index 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 file
diff --git a/docs/locales/fr/parsing/selection.md b/docs/locales/fr/parsing/selection.md
new file mode 100644
index 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 file
diff --git a/docs/locales/fr/spiders/advanced.md b/docs/locales/fr/spiders/advanced.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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/stylesheets
new file mode 120000
index 0000000..02c6ba6
--- /dev/null
+++ b/docs/locales/fr/stylesheets
@@ -0,0 +1 @@
+../../stylesheets
\ No newline at end of file
diff --git a/docs/locales/fr/tutorials/migrating_from_beautifulsoup.md b/docs/locales/fr/tutorials/migrating_from_beautifulsoup.md
new file mode 100644
index 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.md
new file mode 100644
index 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.jinja
new file mode 100644
index 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.jinja
new file mode 100644
index 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 &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</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 &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</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-&gt;value</code> pairs to be passed for the storage class.\nIf empty, default values will be used.</p>": "<p>Dictionnaire de paires <code>argument-&gt;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>&lt;body&gt;</code> tag.</p>": "<p>Convertit uniquement le contenu de la balise <code>&lt;body&gt;</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 &lt;token&gt;</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 &lt;token&gt;</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.yml
index 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: fr
watch:
- zensical-base.yml
- docs/assets
diff --git a/zensical.fr.yml b/zensical.fr.yml
new file mode 100644
index 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 &copy; 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