Paquet PyPI: olostep | Exigences: Python 3.11+

Installation

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 synchrone offre une interface plus simple et bloquante, plus facile à utiliser si vous débutez avec async/await.

Client Async (`AsyncOlostep`)

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

Le client asynchrone 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 synchrone (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 synchrone 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")

Extraction Web de base

from olostep import Olostep

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

# Extraction 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 lots

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")

Exploration Web intelligente

from olostep import Olostep

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

# Exploration 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 asynchrone (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 une utilisation ponctuelle) :
#    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

Extraction Web de base

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Extraction 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 lots

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())

Exploration Web intelligente

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Exploration 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 renvoie des objets avec état dotés de méthodes ergonomiques pour les opérations de suivi.

Gestion des erreurs

Interceptez toutes les erreurs du 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 détaillée des erreurs.

Réessais 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 réessai en passant une instance de 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 de réessai détaillées et des meilleures pratiques, voir Stratégie de réessai.

Fonctionnalités avancées

Coercition intelligente des entrées

Le SDK gère intelligemment divers formats d’entrée pour une commodité maximale :

from olostep import Olostep, Country

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

# Formats : chaîne, liste ou énumération
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 énumérations
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 avancées d’extraction

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

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

# Contrôle total sur le comportement d'extraction
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
)

Traitement par lots avec ID 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 analyseur, 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}")

Exploration intelligente

from olostep import Olostep

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

# Exploration 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 réessai

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

Comportement par défaut

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

Réessais 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 tous les réessais (cas le plus défavorable)

Configuration personnalisée

from olostep import AsyncOlostep, RetryStrategy

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

# 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 réessais se produisent

Le SDK réessaie automatiquement en cas de :

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

D’autres erreurs (authentification, validation, ressource non trouvée, etc.) échouent immédiatement sans réessai.

Réessais de transport vs appelant

Le SDK a deux couches de réessai :

Couche de transport : Gère les échecs de connexion au niveau du 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 réessai pour différents cas d’utilisation.

Stratégie conservatrice

# Moins de réessais, 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 réessais pour les opérations critiques
retry_strategy = RetryStrategy(
    max_retries=10,
    initial_delay=0.5
)
# Durée max : ~969.75s

Pas de réessais (échec rapide)

# Désactivez les réessais 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 “thundering herd” 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 lots

# Stratégie conservatrice pour les gros travaux par lots
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 réessai 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 réessai :

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

Gestion des erreurs

Lorsque tous les réessais sont épuisés, l’erreur originale 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 réessai 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 réessais activés
Limites API : Les réessais comptent contre vos limites d’utilisation de l’API
Réseau : Plus de trafic réseau en raison des tentatives de réessai

Choisissez votre stratégie de réessai en fonction des exigences de votre application en matière de fiabilité vs performance.

Gestion détaillée des erreurs

Hiérarchie des exceptions

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

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

Pourquoi les erreurs de connexion sont séparées

Olostep_APIConnectionError est séparé des erreurs serveur car il représente des échecs au niveau du 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 API et sont classés comme des erreurs 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, interceptez l’erreur de base et affichez 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 intercepte toutes les erreurs du SDK et fournit des informations claires sur ce qui a mal tourné. 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, interceptez directement les types d’erreurs spécifiques. Évitez d’utiliser OlostepServerError_BaseError ou OlostepClientError_BaseError - ces classes de base indiquent seulement qui a soulevé l’erreur (serveur vs client), pas qui est responsable de la corriger. C’est un détail d’implémentation qui n’aide pas à la logique de gestion des erreurs. Au lieu de cela, interceptez 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	Par 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 requête (secondes)	`150`

SDKs

​Installation

​Authentification

​Démarrage rapide

Client Sync (`Olostep`)

Client Async (`AsyncOlostep`)

​Client Sync (Olostep)

​Extraction Web de base

​Traitement par lots

​Exploration Web intelligente

​Cartographie du site

​Réponses alimentées par l’IA

​Client Async (AsyncOlostep)

​Extraction Web de base

​Traitement par lots

​Exploration Web intelligente

​Cartographie du site

​Réponses alimentées par l’IA

​Référence SDK

​Structure des méthodes

​Gestion des erreurs

​Réessais automatiques

​Fonctionnalités avancées

​Coercition intelligente des entrées

​Options avancées d’extraction

​Traitement par lots avec ID personnalisés

​Exploration intelligente

​Cartographie du site avec filtres

​Récupération des réponses

​Récupération de contenu

​Journalisation

​Configuration de la stratégie de réessai

​Comportement par défaut

​Configuration personnalisée

​Quand les réessais se produisent

​Réessais de transport vs appelant

​Calcul de la durée maximale

​Exemples de configuration

​Stratégie conservatrice

​Stratégie agressive

​Pas de réessais (é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 lots

​Surveillance et débogage

​Gestion des erreurs

​Considérations sur les performances

​Gestion détaillée des erreurs

​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

Paquet PyPI

Obtenir une clé API

Installation

Authentification

Démarrage rapide

Client Sync (Olostep)

Extraction Web de base

Traitement par lots

Exploration Web intelligente

Cartographie du site

Réponses alimentées par l’IA

Client Async (AsyncOlostep)

Extraction Web de base

Traitement par lots

Exploration Web intelligente

Cartographie du site

Réponses alimentées par l’IA

Référence SDK

Structure des méthodes

Gestion des erreurs

Réessais automatiques

Fonctionnalités avancées

Coercition intelligente des entrées

Options avancées d’extraction

Traitement par lots avec ID personnalisés

Exploration intelligente

Cartographie du site avec filtres

Récupération des réponses

Récupération de contenu

Journalisation

Configuration de la stratégie de réessai

Comportement par défaut

Configuration personnalisée

Quand les réessais se produisent

Réessais de transport vs appelant

Calcul de la durée maximale

Exemples de configuration

Stratégie conservatrice

Stratégie agressive

Pas de réessais (é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 lots

Surveillance et débogage

Gestion des erreurs

Considérations sur les performances

Gestion détaillée des erreurs

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