Package PyPI: olostep | Exigences: Python 3.11+

Installation

pip install olostep

pip3 install olostep

poetry add olostep

uv pip install olostep

Authentification

Obtenez votre clé API depuis le Tableau de bord Olostep.

Démarrage rapide

Le SDK propose deux options de client selon votre cas d’utilisation :

Client Sync (`Olostep`)

Idéal pour : Scripts et cas d’utilisation simples où vous préférez des opérations bloquantes.

Le client sync offre une interface plus simple et bloquante, plus facile à utiliser si vous êtes nouveau dans l’async/await.

Client Async (`AsyncOlostep`)

Idéal pour : Applications en production et gestion de nombreuses requêtes simultanées.

Le client async offre des opérations non bloquantes et est le choix recommandé pour les applications en production nécessitant un débit élevé.

Client Sync (Olostep)

Le client sync (Olostep) offre une interface bloquante parfaite pour les scripts et les cas d’utilisation simples.

from olostep import Olostep

# Fournissez la clé API soit en passant le paramètre 'api_key'
# soit en définissant la variable d'environnement OLOSTEP_API_KEY

# Le client sync gère automatiquement la gestion des ressources
# Pas besoin de fermeture explicite - les ressources sont nettoyées après chaque opération
client = Olostep(api_key="YOUR_REAL_KEY")
scrape_result = client.scrapes.create(url_to_scrape="https://example.com")

Scraping Web de base

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Scraping simple
result = client.scrapes.create(url_to_scrape="https://example.com")
print(f"Scraped {len(result.html_content)} characters")

# Formats multiples
result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["html", "markdown"]
)
print(f"HTML: {len(result.html_content)} chars")
print(f"Markdown: {len(result.markdown_content)} chars")

Traitement par lot

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Traitez plusieurs URL efficacement
batch = client.batches.create(
    urls=[
        "https://www.google.com/search?q=python",
        "https://www.google.com/search?q=javascript",
        "https://www.google.com/search?q=typescript"
    ]
)

# Attendez la fin et traitez les résultats
for item in batch.items():
    content = item.retrieve(["html"])
    print(f"Processed {item.url}: {len(content.html_content)} bytes")

Crawling Web intelligent

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Crawl avec filtrage intelligent
crawl = client.crawls.create(
    start_url="https://www.bbc.com",
    max_pages=100,
    include_urls=["/articles/**", "/blog/**"],
    exclude_urls=["/admin/**"]
)

for page in crawl.pages():
    content = page.retrieve(["html"])
    print(f"Crawled: {page.url}")

Cartographie du site

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Extraire tous les liens d'un site web
maps = client.maps.create(url="https://example.com")

# Obtenez toutes les URL découvertes
urls = []
for url in maps.urls():
    urls.append(url)
    if len(urls) >= 10:  # Limite pour la démo
        break

print(f"Found {len(urls)} URLs")

Réponses alimentées par l’IA

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Obtenez des réponses à partir de pages web en utilisant l'IA
answer = client.answers.create(
    task="What is the main topic of https://example.com?"
)
print(f"Answer: {answer.answer}")

Client Async (AsyncOlostep)

Le client async (AsyncOlostep) est le client recommandé pour les applications à haute performance, les services backend, et lorsque vous devez gérer de nombreuses requêtes simultanées.

from olostep import AsyncOlostep

# Fournissez la clé API soit en passant le paramètre 'api_key'
# soit en définissant la variable d'environnement OLOSTEP_API_KEY

# GESTION DES RESSOURCES
# ======================
# Le SDK prend en charge deux modèles d'utilisation pour la gestion des ressources :

# 1. Gestionnaire de contexte (Recommandé pour un usage unique) :
#    Gère automatiquement le nettoyage des ressources
async with AsyncOlostep(api_key="YOUR_REAL_KEY") as client:
    scrape_result = await client.scrapes.create(url_to_scrape="https://example.com")
# Le transport est automatiquement fermé ici

# 2. Fermeture explicite (Pour les services de longue durée) :
#    Nécessite un nettoyage manuel des ressources
client = AsyncOlostep(api_key="YOUR_REAL_KEY")
try:
    scrape_result = await client.scrapes.create(url_to_scrape="https://example.com")
finally:
    await client.close()  # Fermez manuellement le transport

Scraping Web de base

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Scraping simple
        result = await client.scrapes.create(url_to_scrape="https://example.com")
        print(f"Scraped {len(result.html_content)} characters")

        # Formats multiples
        result = await client.scrapes.create(
            url_to_scrape="https://example.com",
            formats=["html", "markdown"]
        )
        print(f"HTML: {len(result.html_content)} chars")
        print(f"Markdown: {len(result.markdown_content)} chars")

asyncio.run(main())

Traitement par lot

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Traitez plusieurs URL efficacement
        batch = await client.batches.create(
            urls=[
                "https://www.google.com/search?q=python",
                "https://www.google.com/search?q=javascript",
                "https://www.google.com/search?q=typescript"
            ]
        )

        # Attendez la fin et traitez les résultats
        async for item in batch.items():
            content = await item.retrieve(["html"])
            print(f"Processed {item.url}: {len(content.html_content)} bytes")

asyncio.run(main())

Crawling Web intelligent

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Crawl avec filtrage intelligent
        crawl = await client.crawls.create(
            start_url="https://www.bbc.com",
            max_pages=100,
            include_urls=["/articles/**", "/blog/**"],
            exclude_urls=["/admin/**"]
        )

        async for page in crawl.pages():
            content = await page.retrieve(["html"])
            print(f"Crawled: {page.url}")

asyncio.run(main())

Cartographie du site

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Extraire tous les liens d'un site web
        maps = await client.maps.create(url="https://example.com")

        # Obtenez toutes les URL découvertes
        urls = []
        async for url in maps.urls():
            urls.append(url)
            if len(urls) >= 10:  # Limite pour la démo
                break

        print(f"Found {len(urls)} URLs")

asyncio.run(main())

Réponses alimentées par l’IA

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Obtenez des réponses à partir de pages web en utilisant l'IA
        answer = await client.answers.create(
            task="What is the main topic of https://example.com?"
        )
        print(f"Answer: {answer.answer}")

asyncio.run(main())

Référence SDK

Structure des méthodes

Les deux clients SDK offrent la même interface claire et pythonique organisée en espaces de noms logiques :

Espace de noms	Objectif	Méthodes clés
`scrapes`	Extraction d’URL unique	`create()`, `get()`
`batches`	Traitement multi-URL	`create()`, `info()`, `items()`
`crawls`	Parcours de site web	`create()`, `info()`, `pages()`
`maps`	Extraction de liens	`create()`, `urls()`
`answers`	Extraction alimentée par l’IA	`create()`, `get()`
`retrieve`	Récupération de contenu	`get()`

Chaque opération retourne des objets avec état et des méthodes ergonomiques pour les opérations de suivi.

Gestion des erreurs

Capturez toutes les erreurs SDK en utilisant la classe d’exception de base :

from olostep import Olostep, Olostep_BaseError

client = Olostep(api_key="your-api-key")

try:
    result = client.scrapes.create(url_to_scrape="https://example.com")
except Olostep_BaseError as e:
    print(f"Error has occurred: {type(e).__name__}")
    print(f"Error message: {e}")

Pour des informations détaillées sur la gestion des erreurs, y compris la hiérarchie complète des exceptions et les options de gestion des erreurs granulaires, voir Gestion des erreurs détaillée.

Reprises automatiques

Le SDK réessaie automatiquement en cas d’erreurs transitoires (problèmes de réseau, problèmes temporaires du serveur) en fonction de la configuration RetryStrategy. Vous pouvez personnaliser le comportement de reprise en passant une instance RetryStrategy lors de la création du client :

from olostep import Olostep, RetryStrategy

retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,
    jitter_max=0.8
)

client = Olostep(api_key="your-api-key", retry_strategy=retry_strategy)
result = client.scrapes.create("https://example.com")

Pour des options de configuration détaillées de la reprise et des meilleures pratiques, voir Stratégie de reprise.

Fonctionnalités avancées

Coercition intelligente des entrées

Le SDK gère intelligemment divers formats d’entrée pour un maximum de commodité :

from olostep import Olostep, Country

client = Olostep(api_key="your-api-key")

# Formats : chaîne, liste ou enum
client.scrapes.create(url_to_scrape="https://example.com", formats="html")
client.scrapes.create(url_to_scrape="https://example.com", formats=["html", "markdown"])

# Pays : chaînes insensibles à la casse ou enums
client.scrapes.create(url_to_scrape="https://example.com", country="us")
client.scrapes.create(url_to_scrape="https://example.com", country=Country.US)

# Listes : valeurs uniques ou listes
client.batches.create(urls="https://example.com")    # URL unique
client.batches.create(urls=["https://a.com", "https://b.com"])  # Plusieurs URL

Options de scraping avancées

from olostep import Olostep, Format, Country, WaitAction, FillInputAction

client = Olostep(api_key="your-api-key")

# Contrôle total sur le comportement de scraping
result = client.scrapes.create(
    url_to_scrape="https://news.google.com/",
    wait_before_scraping=3000,
    formats=[Format.HTML, Format.MARKDOWN],
    remove_css_selectors=["script", ".popup"],
    actions=[
        WaitAction(milliseconds=1500),
        FillInputAction(selector="searchbox", value="olostep")
    ],
    parser="@olostep/google-news",
    country=Country.US,
    remove_images=True
)

Mise en cache

Par défaut, chaque requête de scraping récupère la page fraîche (max_age=0). Passez max_age pour réutiliser un résultat récent avec les mêmes paramètres et améliorer le temps de réponse. La valeur est en secondes ; le maximum est de 7 jours (604800). Voir Mise en cache pour les détails.

# Optez pour la mise en cache : acceptez des résultats jusqu'à 1 jour (86400 secondes) anciens
result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["markdown"],
    max_age=86400
)

Traitement par lot avec IDs personnalisés

from olostep import Olostep, Country

client = Olostep(api_key="your-api-key")

batch = client.batches.create([
    {"url": "https://www.google.com/search?q=python", "custom_id": "search_1"},
    {"url": "https://www.google.com/search?q=javascript", "custom_id": "search_2"},
    {"url": "https://www.google.com/search?q=typescript", "custom_id": "search_3"}
],
country=Country.US,
parser="@olostep/google-search"
)

# Traitez les résultats par ID personnalisé
# Lors de l'utilisation d'un parser, récupérez le contenu JSON au lieu de HTML
for item in batch.items():
    if item.custom_id == "search_2":
        content = item.retrieve(["json"])
        print(f"Search result: {content.json_content}")

Crawling intelligent

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Crawl avec filtrage intelligent
crawl = client.crawls.create(
    start_url="https://www.bbc.com",
    max_pages=1000,
    max_depth=3,
    include_urls=["/articles/**", "/news/**"],
    exclude_urls=["/ads/**", "/tracking/**"],
    include_external=False,
    include_subdomain=True,
)

for page in crawl.pages():
    content = page.retrieve(["html"])
    print(f"Crawled: {page.url}")

Cartographie du site avec filtres

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Extraire tous les liens avec filtrage avancé
maps = client.maps.create(
    url="https://www.bbc.com",
    include_subdomain=True,
    include_urls=["/articles/**", "/news/**"],
    exclude_urls=["/ads/**", "/tracking/**"]
)

# Obtenez les URL filtrées
urls = []
for url in maps.urls():
    urls.append(url)

print(f"Found {len(urls)} relevant URLs")

Récupération des réponses

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Créez d'abord une réponse
created_answer = client.answers.create(
    task="What is the main topic of https://example.com?"
)

# Puis récupérez-la en utilisant l'ID
answer = client.answers.get(answer_id=created_answer.id)
print(f"Answer: {answer.answer}")

Récupération de contenu

from olostep import Olostep

client = Olostep(api_key="your-api-key")

# Obtenez le contenu par ID de récupération
result = client.retrieve.get(retrieve_id="ret_123")

# Obtenez plusieurs formats
result = client.retrieve.get(retrieve_id="ret_123", formats=["html", "markdown", "text", "json"])

Journalisation

Activez la journalisation pour déboguer les problèmes :

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("olostep")
logger.setLevel(logging.INFO)  # Utilisez DEBUG pour une sortie détaillée

Niveaux de journalisation : INFO (recommandé), DEBUG (détaillé), WARNING, ERROR

Configuration de la stratégie de reprise

La classe RetryStrategy contrôle comment le SDK Olostep gère les erreurs API transitoires via des reprises automatiques avec backoff exponentiel et jitter. Cela aide à assurer une opération fiable dans les environnements de production où des problèmes de réseau temporaires, des limites de taux et une surcharge du serveur peuvent causer des échecs intermittents.

Comportement par défaut

Par défaut, le SDK utilise la configuration de reprise suivante :

Reprises max : 5 tentatives
Délai initial : 2 secondes
Backoff : Exponentiel (2^tentative)
Jitter : 10-90% du délai (aléatoire)

Cela signifie :

Tentative 1 : Immédiate
Tentative 2 : ~2-3.6s de délai
Tentative 3 : ~4-7.2s de délai
Tentative 4 : ~8-14.4s de délai
Tentative 5 : ~16-28.8s de délai

Durée maximale : ~57 secondes pour toutes les reprises (cas le pire)

Configuration personnalisée

from olostep import AsyncOlostep, RetryStrategy

# Créez une stratégie de reprise personnalisée
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,  # Jitter minimum de 20%
    jitter_max=0.8,  # Jitter maximum de 80%
)

# Utilisez avec le client
async with AsyncOlostep(
    api_key="your-api-key",
    retry_strategy=retry_strategy
) as client:
    result = await client.scrapes.create("https://example.com")

Quand les reprises se produisent

Le SDK réessaie automatiquement en cas de :

Problèmes temporaires du serveur (OlostepServerError_TemporaryIssue)
Réponses de timeout (OlostepServerError_NoResultInResponse)

Les autres erreurs (authentification, validation, ressource non trouvée, etc.) échouent immédiatement sans reprise.

Reprises de transport vs de l’appelant

Le SDK a deux couches de reprise :

Couche de transport : Gère les échecs de connexion au niveau réseau (DNS, timeouts, etc.)
Couche de l’appelant : Gère les erreurs transitoires au niveau de l’API (contrôlées par RetryStrategy)

Les deux couches sont indépendantes et ont une configuration séparée. La durée maximale totale est la somme des deux couches.

Calcul de la durée maximale

retry_strategy = RetryStrategy(max_retries=5, initial_delay=2.0)
max_duration = retry_strategy.max_duration()
print(f"Max call duration: {max_duration:.2f}s")

Exemples de configuration

Voici quelques exemples de configuration de la stratégie de reprise pour différents cas d’utilisation.

Stratégie conservatrice

# Moins de reprises, délais plus courts
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,
    jitter_max=0.8
)
# Durée max : ~12.6s

Stratégie agressive

# Plus de reprises pour les opérations critiques
retry_strategy = RetryStrategy(
    max_retries=10,
    initial_delay=0.5
)
# Durée max : ~969.75s

Pas de reprises (échec rapide)

# Désactivez les reprises pour un retour d'échec immédiat
retry_strategy = RetryStrategy(max_retries=0)

client = AsyncOlostep(api_key="your-api-key", retry_strategy=retry_strategy)

Stratégie à haut débit

# Optimisé pour les opérations à haut volume
retry_strategy = RetryStrategy(
    max_retries=2,
    initial_delay=0.5,
    jitter_min=0.1,
    jitter_max=0.3  # Jitter plus faible pour un timing plus prévisible
)
# Durée max : ~1.95s

Comprendre le jitter

Le jitter ajoute une randomisation pour éviter les problèmes de “troupeau tonitruant” lorsque de nombreux clients réessaient simultanément. Le jitter est calculé comme suit :

base_delay = initial_delay * (2 ** attempt)
jitter_range = base_delay * (jitter_max - jitter_min)
jitter = random.uniform(base_delay * jitter_min, base_delay * jitter_min + jitter_range)
final_delay = base_delay + jitter

Par exemple, avec initial_delay=2.0, jitter_min=0.1, jitter_max=0.9 :

Tentative 0 : base=2.0s, jitter=0.2-1.8s, final=2.2-3.8s
Tentative 1 : base=4.0s, jitter=0.4-3.6s, final=4.4-7.6s
Tentative 2 : base=8.0s, jitter=0.8-7.2s, final=8.8-15.2s

Meilleures pratiques

Pour les applications en production

# Approche équilibrée pour la production
retry_strategy = RetryStrategy(
    max_retries=5,
    initial_delay=2.0,
    jitter_min=0.1,
    jitter_max=0.9
)

Pour le développement/test

# Retour rapide pour le développement
retry_strategy = RetryStrategy(
    max_retries=2,
    initial_delay=0.5,
    jitter_min=0.1,
    jitter_max=0.3
)

Pour les opérations par lot

# Conservateur pour les gros travaux par lot
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,
    jitter_max=0.8
)

Surveillance et débogage

Le SDK journalise les informations de reprise au niveau DEBUG :

DEBUG: Temporary issue, retrying in 2.34s
DEBUG: No result in response, retrying in 4.67s

Activez la journalisation de débogage pour surveiller le comportement de reprise :

import logging
logging.getLogger("olostep").setLevel(logging.DEBUG)

Gestion des erreurs

Lorsque toutes les reprises sont épuisées, l’erreur d’origine est levée :

try:
    result = await client.scrapes.create("https://example.com")
except OlostepServerError_TemporaryIssue as e:
    print(f"Failed after all retries: {e}")
    # Gérez l'échec permanent

Considérations sur les performances

Mémoire : Chaque tentative de reprise utilise de la mémoire supplémentaire pour les objets de requête/réponse
Temps : Le temps total de l’opération peut être significativement plus long avec les reprises activées
Limites API : Les reprises comptent contre vos limites d’utilisation de l’API
Réseau : Plus de trafic réseau en raison des tentatives de reprise

Choisissez votre stratégie de reprise en fonction des exigences de votre application en matière de fiabilité par rapport aux performances.

Gestion des erreurs détaillée

Hiérarchie des exceptions

Le SDK Olostep fournit une hiérarchie d’exceptions complète pour différents scénarios d’échec. Toutes les exceptions héritent de Olostep_BaseError. Il y a trois principaux types d’erreurs qui héritent directement de Olostep_BaseError :

Olostep_APIConnectionError - Échecs de connexion au niveau réseau
OlostepServerError_BaseError - Erreurs levées (en quelque sorte) par le serveur API
OlostepClientError_BaseError - Erreurs levées par le SDK client

Pourquoi les erreurs de connexion sont séparées

Olostep_APIConnectionError est séparé des erreurs de serveur car il représente des échecs au niveau réseau qui se produisent avant que l’API puisse traiter la requête. Ce sont des problèmes de couche de transport (échecs DNS ou HTTP, timeouts, connexion refusée, etc.) plutôt que des erreurs au niveau de l’API. Les codes d’état HTTP (4xx, 5xx) sont considérés comme des réponses de l’API et sont catégorisés comme des erreurs de serveur, même s’ils indiquent des problèmes.

Olostep_BaseError
├── Olostep_APIConnectionError
├── OlostepServerError_BaseError
│   ├── OlostepServerError_TemporaryIssue
│   │   ├── OlostepServerError_NetworkBusy
│   │   └── OlostepServerError_InternalNetworkIssue
│   ├── OlostepServerError_RequestUnprocessable
│   │   ├── OlostepServerError_ParserNotFound
│   │   └── OlostepServerError_OutOfResources
│   ├── OlostepServerError_BlacklistedDomain
│   ├── OlostepServerError_FeatureApprovalRequired
│   ├── OlostepServerError_AuthFailed
│   ├── OlostepServerError_CreditsExhausted
│   ├── OlostepServerError_InvalidEndpointCalled
│   ├── OlostepServerError_ResourceNotFound
│   ├── OlostepServerError_NoResultInResponse
│   └── OlostepServerError_UnknownIssue
└── OlostepClientError_BaseError
    ├── OlostepClientError_RequestValidationFailed
    ├── OlostepClientError_ResponseValidationFailed
    ├── OlostepClientError_NoAPIKey
    ├── OlostepClientError_AsyncContext
    ├── OlostepClientError_BetaFeatureAccessRequired
    └── OlostepClientError_Timeout

Gestion des erreurs recommandée

Pour la plupart des cas d’utilisation, capturez l’erreur de base et imprimez le nom de l’erreur :

from olostep import AsyncOlostep, Olostep_BaseError

try:
    result = await client.scrapes.create(url_to_scrape="https://example.com")
except Olostep_BaseError as e:
    print(f"Error has occurred: {type(e).__name__}")
    print(f"Error message: {e}")

Cette approche capture toutes les erreurs SDK et fournit des informations claires sur ce qui s’est mal passé. Le nom de l’erreur (par exemple, OlostepServerError_AuthFailed) est suffisamment descriptif pour comprendre le problème.

Gestion des erreurs granulaires

Si vous avez besoin d’une gestion des erreurs plus spécifique, capturez directement les types d’erreurs spécifiques. Évitez d’utiliser OlostepServerError_BaseError ou OlostepClientError_BaseError - ces classes de base n’indiquent que qui a levé l’erreur (serveur vs client), pas qui est responsable de la corriger. C’est un détail d’implémentation qui n’aide pas avec la logique de gestion des erreurs. Au lieu de cela, capturez les types d’erreurs spécifiques qui indiquent le problème réel :

from olostep import (
    AsyncOlostep,
    Olostep_BaseError,
    Olostep_APIConnectionError,
    OlostepServerError_AuthFailed,
    OlostepServerError_CreditsExhausted,
    OlostepClientError_NoAPIKey,
)

try:
    result = await client.scrapes.create(url_to_scrape="https://example.com")
except Olostep_APIConnectionError as e:
    print(f"Network error: {type(e).__name__}")
except OlostepServerError_AuthFailed:
    print("Invalid API key")
except OlostepServerError_CreditsExhausted:
    print("Credits exhausted")
except OlostepClientError_NoAPIKey:
    print("API key not provided")
except Olostep_BaseError as e:
    print(f"Error has occurred: {type(e).__name__}")

Configuration

Variables d’environnement

Variable	Description	Défaut
`OLOSTEP_API_KEY`	Votre clé API	Requis
`OLOSTEP_BASE_API_URL`	URL de base de l’API	`https://api.olostep.com/v1`
`OLOSTEP_API_TIMEOUT`	Timeout de la requête (secondes)	`150`

​Installation

​Authentification

​Démarrage rapide

Client Sync (`Olostep`)

Client Async (`AsyncOlostep`)

​Client Sync (Olostep)

​Scraping Web de base

​Traitement par lot

​Crawling Web intelligent

​Cartographie du site

​Réponses alimentées par l’IA

​Client Async (AsyncOlostep)

​Scraping Web de base

​Traitement par lot

​Crawling Web intelligent

​Cartographie du site

​Réponses alimentées par l’IA

​Référence SDK

​Structure des méthodes

​Gestion des erreurs

​Reprises automatiques

​Fonctionnalités avancées

​Coercition intelligente des entrées

​Options de scraping avancées

​Mise en cache

​Traitement par lot avec IDs personnalisés

​Crawling intelligent

​Cartographie du site avec filtres

​Récupération des réponses

​Récupération de contenu

​Journalisation

​Configuration de la stratégie de reprise

​Comportement par défaut

​Configuration personnalisée

​Quand les reprises se produisent

​Reprises de transport vs de l’appelant

​Calcul de la durée maximale

​Exemples de configuration

​Stratégie conservatrice

​Stratégie agressive

​Pas de reprises (échec rapide)

​Stratégie à haut débit

​Comprendre le jitter

​Meilleures pratiques

​Pour les applications en production

​Pour le développement/test

​Pour les opérations par lot

​Surveillance et débogage

​Gestion des erreurs

​Considérations sur les performances

​Gestion des erreurs détaillée

​Hiérarchie des exceptions

​Pourquoi les erreurs de connexion sont séparées

​Gestion des erreurs recommandée

​Gestion des erreurs granulaires

​Configuration

​Variables d’environnement

​Obtenir de l’aide

​Ressources

Package PyPI

Obtenir une clé API

Installation

Authentification

Démarrage rapide

Client Sync (Olostep)

Scraping Web de base

Traitement par lot

Crawling Web intelligent

Cartographie du site

Réponses alimentées par l’IA

Client Async (AsyncOlostep)

Scraping Web de base

Traitement par lot

Crawling Web intelligent

Cartographie du site

Réponses alimentées par l’IA

Référence SDK

Structure des méthodes

Gestion des erreurs

Reprises automatiques

Fonctionnalités avancées

Coercition intelligente des entrées

Options de scraping avancées

Mise en cache

Traitement par lot avec IDs personnalisés

Crawling intelligent

Cartographie du site avec filtres

Récupération des réponses

Récupération de contenu

Journalisation

Configuration de la stratégie de reprise

Comportement par défaut

Configuration personnalisée

Quand les reprises se produisent

Reprises de transport vs de l’appelant

Calcul de la durée maximale

Exemples de configuration

Stratégie conservatrice

Stratégie agressive

Pas de reprises (échec rapide)

Stratégie à haut débit

Comprendre le jitter

Meilleures pratiques

Pour les applications en production

Pour le développement/test

Pour les opérations par lot

Surveillance et débogage

Gestion des erreurs

Considérations sur les performances

Gestion des erreurs détaillée

Hiérarchie des exceptions

Pourquoi les erreurs de connexion sont séparées

Gestion des erreurs recommandée

Gestion des erreurs granulaires

Configuration

Variables d’environnement

Obtenir de l’aide

Ressources