PyPI-Paket: olostep | Anforderungen: Python 3.11+

Installation

pip install olostep

Authentifizierung

Holen Sie sich Ihren API-Schlüssel vom Olostep Dashboard.

Schnellstart

Das SDK bietet zwei Client-Optionen, je nach Anwendungsfall:

Sync Client (`Olostep`)

Am besten geeignet für: Skripte und einfache Anwendungsfälle, bei denen Sie blockierende Operationen bevorzugen.

Der Sync-Client bietet eine einfachere, blockierende Schnittstelle, die einfacher zu starten ist, wenn Sie neu bei async/await sind.

Async Client (`AsyncOlostep`)

Am besten geeignet für: Produktionsanwendungen und die Handhabung vieler gleichzeitiger Anfragen.

Der Async-Client bietet nicht-blockierende Operationen und ist die empfohlene Wahl für Produktionsanwendungen, die einen hohen Durchsatz benötigen.

Sync Client (Olostep)

Der Sync-Client (Olostep) bietet eine blockierende Schnittstelle, die perfekt für Skripte und einfache Anwendungsfälle ist.

from olostep import Olostep

# Übergeben Sie den API-Schlüssel entweder über den 'api_key'-Parameter oder
# durch Setzen der Umgebungsvariable OLOSTEP_API_KEY

# Der Sync-Client verwaltet Ressourcen automatisch
# Kein explizites Schließen erforderlich - Ressourcen werden nach jeder Operation bereinigt
client = Olostep(api_key="YOUR_REAL_KEY")
scrape_result = client.scrapes.create(url_to_scrape="https://example.com")

Einfaches Web Scraping

from olostep import Olostep

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

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

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

Batch-Verarbeitung

from olostep import Olostep

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

# Mehrere URLs effizient verarbeiten
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"
    ]
)

# Auf Abschluss warten und Ergebnisse verarbeiten
for item in batch.items():
    content = item.retrieve(["html"])
    print(f"Verarbeitet {item.url}: {len(content.html_content)} Bytes")

Intelligentes Web Crawling

from olostep import Olostep

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

# Crawlen mit intelligentem Filtern
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"Gecrawlt: {page.url}")

Site Mapping

from olostep import Olostep

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

# Alle Links von einer Website extrahieren
maps = client.maps.create(url="https://example.com")

# Alle entdeckten URLs abrufen
urls = []
for url in maps.urls():
    urls.append(url)
    if len(urls) >= 10:  # Limit für Demo
        break

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

KI-gesteuerte Antworten

from olostep import Olostep

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

# Antworten von Webseiten mit KI erhalten
answer = client.answers.create(
    task="What is the main topic of https://example.com?"
)
print(f"Antwort: {answer.answer}")

Async Client (AsyncOlostep)

Der Async-Client (AsyncOlostep) ist der empfohlene Client für Hochleistungsanwendungen, Backend-Dienste und wenn Sie viele gleichzeitige Anfragen bearbeiten müssen.

from olostep import AsyncOlostep

# Übergeben Sie den API-Schlüssel entweder über den 'api_key'-Parameter oder
# durch Setzen der Umgebungsvariable OLOSTEP_API_KEY

# RESSOURCENVERWALTUNG
# ===================
# Das SDK unterstützt zwei Nutzungsmuster für die Ressourcenverwaltung:

# 1. Kontextmanager (Empfohlen für einmalige Nutzung):
#    Handhabt die Ressourcenbereinigung automatisch
async with AsyncOlostep(api_key="YOUR_REAL_KEY") as client:
    scrape_result = await client.scrapes.create(url_to_scrape="https://example.com")
# Transport wird hier automatisch geschlossen

# 2. Explizites Schließen (Für langlebige Dienste):
#    Erfordert manuelle Ressourcenbereinigung
client = AsyncOlostep(api_key="YOUR_REAL_KEY")
try:
    scrape_result = await client.scrapes.create(url_to_scrape="https://example.com")
finally:
    await client.close()  # Transport manuell schließen

Einfaches Web Scraping

import asyncio
from olostep import AsyncOlostep

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

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

asyncio.run(main())

Batch-Verarbeitung

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Mehrere URLs effizient verarbeiten
        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"
            ]
        )

        # Auf Abschluss warten und Ergebnisse verarbeiten
        async for item in batch.items():
            content = await item.retrieve(["html"])
            print(f"Verarbeitet {item.url}: {len(content.html_content)} Bytes")

asyncio.run(main())

Intelligentes Web Crawling

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Crawlen mit intelligentem Filtern
        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"Gecrawlt: {page.url}")

asyncio.run(main())

Site Mapping

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Alle Links von einer Website extrahieren
        maps = await client.maps.create(url="https://example.com")

        # Alle entdeckten URLs abrufen
        urls = []
        async for url in maps.urls():
            urls.append(url)
            if len(urls) >= 10:  # Limit für Demo
                break

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

asyncio.run(main())

KI-gesteuerte Antworten

import asyncio
from olostep import AsyncOlostep

async def main():
    async with AsyncOlostep(api_key="your-api-key") as client:
        # Antworten von Webseiten mit KI erhalten
        answer = await client.answers.create(
            task="What is the main topic of https://example.com?"
        )
        print(f"Antwort: {answer.answer}")

asyncio.run(main())

SDK-Referenz

Methodensystematik

Beide SDK-Clients bieten die gleiche saubere, pythonische Schnittstelle, die in logische Namensräume organisiert ist:

Namensraum	Zweck	Schlüsselmethoden
`scrapes`	Einzel-URL-Extraktion	`create()`, `get()`
`batches`	Multi-URL-Verarbeitung	`create()`, `info()`, `items()`
`crawls`	Website-Durchlauf	`create()`, `info()`, `pages()`
`maps`	Link-Extraktion	`create()`, `urls()`
`answers`	KI-gesteuerte Extraktion	`create()`, `get()`
`retrieve`	Inhaltsabruf	`get()`

Jede Operation gibt zustandsbehaftete Objekte mit ergonomischen Methoden für Folgeoperationen zurück.

Fehlerbehandlung

Fangen Sie alle SDK-Fehler mit der Basisklasse der Ausnahmen ab:

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"Ein Fehler ist aufgetreten: {type(e).__name__}")
    print(f"Fehlermeldung: {e}")

Für detaillierte Informationen zur Fehlerbehandlung, einschließlich der vollständigen Ausnahmehierarchie und granularer Fehlerbehandlungsoptionen, siehe Detaillierte Fehlerbehandlung.

Automatische Wiederholungen

Das SDK wiederholt automatisch bei vorübergehenden Fehlern (Netzwerkprobleme, temporäre Serverprobleme) basierend auf der RetryStrategy-Konfiguration. Sie können das Wiederholungsverhalten anpassen, indem Sie eine RetryStrategy-Instanz beim Erstellen des Clients übergeben:

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

Für detaillierte Konfigurationsoptionen und Best Practices zur Wiederholungsstrategie siehe Retry Strategy.

Erweiterte Funktionen

Intelligente Eingabekonvertierung

Das SDK verarbeitet verschiedene Eingabeformate intelligent für maximalen Komfort:

from olostep import Olostep, Country

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

# Formate: String, Liste oder Enum
client.scrapes.create(url_to_scrape="https://example.com", formats="html")
client.scrapes.create(url_to_scrape="https://example.com", formats=["html", "markdown"])

# Länder: Groß-/Kleinschreibung ignorierende Strings oder Enums
client.scrapes.create(url_to_scrape="https://example.com", country="us")
client.scrapes.create(url_to_scrape="https://example.com", country=Country.US)

# Listen: Einzelwerte oder Listen
client.batches.create(urls="https://example.com")    # Einzel-URL
client.batches.create(urls=["https://a.com", "https://b.com"])  # Mehrere URLs

Erweiterte Scraping-Optionen

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

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

# Volle Kontrolle über das Scraping-Verhalten
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
)

Batch-Verarbeitung mit benutzerdefinierten IDs

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

# Ergebnisse nach benutzerdefinierter ID verarbeiten
# Beim Verwenden eines Parsers JSON-Inhalte anstelle von HTML abrufen
for item in batch.items():
    if item.custom_id == "search_2":
        content = item.retrieve(["json"])
        print(f"Suchergebnis: {content.json_content}")

Intelligentes Crawling

from olostep import Olostep

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

# Crawlen mit intelligentem Filtern
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"Gecrawlt: {page.url}")

Site Mapping mit Filtern

from olostep import Olostep

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

# Alle Links mit erweitertem Filtern extrahieren
maps = client.maps.create(
    url="https://www.bbc.com",
    include_subdomain=True,
    include_urls=["/articles/**", "/news/**"],
    exclude_urls=["/ads/**", "/tracking/**"]
)

# Gefilterte URLs abrufen
urls = []
for url in maps.urls():
    urls.append(url)

print(f"Gefundene {len(urls)} relevante URLs")

Antworten abrufen

from olostep import Olostep

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

# Zuerst eine Antwort erstellen
created_answer = client.answers.create(
    task="What is the main topic of https://example.com?"
)

# Dann mit der ID abrufen
answer = client.answers.get(answer_id=created_answer.id)
print(f"Antwort: {answer.answer}")

Inhaltsabruf

from olostep import Olostep

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

# Inhalte mit Abruf-ID abrufen
result = client.retrieve.get(retrieve_id="ret_123")

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

Protokollierung

Aktivieren Sie die Protokollierung, um Probleme zu debuggen:

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("olostep")
logger.setLevel(logging.INFO)  # Verwenden Sie DEBUG für ausführliche Ausgabe

Protokollstufen: INFO (empfohlen), DEBUG (ausführlich), WARNING, ERROR

Konfiguration der Wiederholungsstrategie

Die RetryStrategy-Klasse steuert, wie das Olostep SDK vorübergehende API-Fehler durch automatische Wiederholungen mit exponentiellem Backoff und Jitter behandelt. Dies hilft, einen zuverlässigen Betrieb in Produktionsumgebungen sicherzustellen, in denen temporäre Netzwerkprobleme, Ratenbeschränkungen und Serverüberlastungen zu intermittierenden Fehlern führen können.

Standardverhalten

Standardmäßig verwendet das SDK die folgende Wiederholungskonfiguration:

Maximale Wiederholungen: 5 Versuche
Anfängliche Verzögerung: 2 Sekunden
Backoff: Exponentiell (2^Versuch)
Jitter: 10-90% der Verzögerung (zufällig)

Das bedeutet:

Versuch 1: Sofort
Versuch 2: ~2-3,6s Verzögerung
Versuch 3: ~4-7,2s Verzögerung
Versuch 4: ~8-14,4s Verzögerung
Versuch 5: ~16-28,8s Verzögerung

Maximale Dauer: ~57 Sekunden für alle Wiederholungen (schlechtester Fall)

Benutzerdefinierte Konfiguration

from olostep import AsyncOlostep, RetryStrategy

# Benutzerdefinierte Wiederholungsstrategie erstellen
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,  # 20% Mindest-Jitter
    jitter_max=0.8,  # 80% Maximal-Jitter
)

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

Wann Wiederholungen auftreten

Das SDK wiederholt automatisch bei:

Vorübergehenden Serverproblemen (OlostepServerError_TemporaryIssue)
Timeout-Antworten (OlostepServerError_NoResultInResponse)

Andere Fehler (Authentifizierung, Validierung, Ressource nicht gefunden, etc.) schlagen sofort fehl, ohne Wiederholung.

Transport- vs. Anrufer-Wiederholungen

Das SDK hat zwei Wiederholungsebenen:

Transportebene: Handhabt netzwerkbezogene Verbindungsfehler (DNS, Timeouts, etc.)
Anruferebene: Handhabt API-bezogene vorübergehende Fehler (gesteuert durch RetryStrategy)

Beide Ebenen sind unabhängig und haben separate Konfigurationen. Die maximale Gesamtdauer ist die Summe beider Ebenen.

Berechnung der maximalen Dauer

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

Konfigurationsbeispiele

Hier sind einige Beispiele, wie Sie die Wiederholungsstrategie für verschiedene Anwendungsfälle konfigurieren können.

Konservative Strategie

# Weniger Wiederholungen, kürzere Verzögerungen
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,
    jitter_max=0.8
)
# Maximale Dauer: ~12,6s

Aggressive Strategie

# Mehr Wiederholungen für kritische Operationen
retry_strategy = RetryStrategy(
    max_retries=10,
    initial_delay=0.5
)
# Maximale Dauer: ~969,75s

Keine Wiederholungen (Schnelles Scheitern)

# Wiederholungen deaktivieren für sofortiges Fehler-Feedback
retry_strategy = RetryStrategy(max_retries=0)

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

Hochdurchsatzstrategie

# Optimiert für hochvolumige Operationen
retry_strategy = RetryStrategy(
    max_retries=2,
    initial_delay=0.5,
    jitter_min=0.1,
    jitter_max=0.3  # Niedrigerer Jitter für vorhersehbarere Zeiten
)
# Maximale Dauer: ~1,95s

Verständnis von Jitter

Jitter fügt eine Zufälligkeit hinzu, um “thundering herd”-Probleme zu verhindern, wenn viele Clients gleichzeitig wiederholen. Der Jitter wird wie folgt berechnet:

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

Zum Beispiel mit initial_delay=2.0, jitter_min=0.1, jitter_max=0.9:

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

Best Practices

Für Produktionsanwendungen

# Ausgewogene Herangehensweise für die Produktion
retry_strategy = RetryStrategy(
    max_retries=5,
    initial_delay=2.0,
    jitter_min=0.1,
    jitter_max=0.9
)

Für Entwicklung/Test

# Schnelles Feedback für die Entwicklung
retry_strategy = RetryStrategy(
    max_retries=2,
    initial_delay=0.5,
    jitter_min=0.1,
    jitter_max=0.3
)

Für Batch-Operationen

# Konservativ für große Batch-Jobs
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,
    jitter_max=0.8
)

Überwachung und Debugging

Das SDK protokolliert Wiederholungsinformationen auf DEBUG-Ebene:

DEBUG: Temporäres Problem, erneuter Versuch in 2.34s
DEBUG: Kein Ergebnis in Antwort, erneuter Versuch in 4.67s

Aktivieren Sie die Debug-Protokollierung, um das Wiederholungsverhalten zu überwachen:

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

Fehlerbehandlung

Wenn alle Wiederholungen erschöpft sind, wird der ursprüngliche Fehler ausgelöst:

try:
    result = await client.scrapes.create("https://example.com")
except OlostepServerError_TemporaryIssue as e:
    print(f"Fehlgeschlagen nach allen Wiederholungen: {e}")
    # Dauerhaftes Scheitern behandeln

Leistungsüberlegungen

Speicher: Jeder Wiederholungsversuch verwendet zusätzlichen Speicher für Anforderungs-/Antwortobjekte
Zeit: Die Gesamtbetriebszeit kann mit aktivierten Wiederholungen erheblich länger sein
API-Limits: Wiederholungen zählen gegen Ihre API-Nutzungslimits
Netzwerk: Mehr Netzwerkverkehr aufgrund von Wiederholungsversuchen

Wählen Sie Ihre Wiederholungsstrategie basierend auf den Anforderungen Ihrer Anwendung an Zuverlässigkeit vs. Leistung.

Detaillierte Fehlerbehandlung

Ausnahmehierarchie

Das Olostep SDK bietet eine umfassende Ausnahmehierarchie für verschiedene Fehlerszenarien. Alle Ausnahmen erben von Olostep_BaseError. Es gibt drei Hauptfehlertypen, die direkt von Olostep_BaseError erben:

Olostep_APIConnectionError - Netzwerkebene Verbindungsfehler
OlostepServerError_BaseError - Fehler, die (irgendwie) vom API-Server ausgelöst werden
OlostepClientError_BaseError - Fehler, die vom Client-SDK ausgelöst werden

Warum Verbindungsfehler separat sind

Olostep_APIConnectionError ist von Serverfehlern getrennt, da es netzwerkbezogene Fehler darstellt, die auftreten, bevor die API die Anfrage verarbeiten kann. Dies sind Transportebenenprobleme (DNS- oder HTTP-Fehler, Timeouts, Verbindung verweigert usw.) und keine API-Ebene-Fehler. HTTP-Statuscodes (4xx, 5xx) werden als API-Antworten betrachtet und als Serverfehler kategorisiert, auch wenn sie Probleme anzeigen.

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

Empfohlene Fehlerbehandlung

Für die meisten Anwendungsfälle fangen Sie den Basisfehler ab und drucken den Fehlernamen:

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"Ein Fehler ist aufgetreten: {type(e).__name__}")
    print(f"Fehlermeldung: {e}")

Dieser Ansatz fängt alle SDK-Fehler ab und liefert klare Informationen darüber, was schiefgelaufen ist. Der Fehlername (z.B. OlostepServerError_AuthFailed) ist beschreibend genug, um das Problem zu verstehen.

Granulare Fehlerbehandlung

Wenn Sie eine spezifischere Fehlerbehandlung benötigen, fangen Sie die spezifischen Fehlertypen direkt ab. Vermeiden Sie die Verwendung von OlostepServerError_BaseError oder OlostepClientError_BaseError - diese Basisklassen zeigen nur an, wer den Fehler ausgelöst hat (Server vs. Client), nicht wer für die Behebung verantwortlich ist. Dies ist ein Implementierungsdetail, das bei der Fehlerbehandlungslogik nicht hilft. Stattdessen fangen Sie spezifische Fehlertypen ab, die das tatsächliche Problem anzeigen:

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"Netzwerkfehler: {type(e).__name__}")
except OlostepServerError_AuthFailed:
    print("Ungültiger API-Schlüssel")
except OlostepServerError_CreditsExhausted:
    print("Credits erschöpft")
except OlostepClientError_NoAPIKey:
    print("API-Schlüssel nicht bereitgestellt")
except Olostep_BaseError as e:
    print(f"Ein Fehler ist aufgetreten: {type(e).__name__}")

Konfiguration

Umgebungsvariablen

Variable	Beschreibung	Standard
`OLOSTEP_API_KEY`	Ihr API-Schlüssel	Erforderlich
`OLOSTEP_BASE_API_URL`	API-Basis-URL	`https://api.olostep.com/v1`
`OLOSTEP_API_TIMEOUT`	Anforderungs-Timeout (Sekunden)	`150`

SDKs

Documentation Index

​Installation

​Authentifizierung

​Schnellstart

Sync Client (`Olostep`)

Async Client (`AsyncOlostep`)

​Sync Client (Olostep)

​Einfaches Web Scraping

​Batch-Verarbeitung

​Intelligentes Web Crawling

​Site Mapping

​KI-gesteuerte Antworten

​Async Client (AsyncOlostep)

​Einfaches Web Scraping

​Batch-Verarbeitung

​Intelligentes Web Crawling

​Site Mapping

​KI-gesteuerte Antworten

​SDK-Referenz

​Methodensystematik

​Fehlerbehandlung

​Automatische Wiederholungen

​Erweiterte Funktionen

​Intelligente Eingabekonvertierung

​Erweiterte Scraping-Optionen

​Batch-Verarbeitung mit benutzerdefinierten IDs

​Intelligentes Crawling

​Site Mapping mit Filtern

​Antworten abrufen

​Inhaltsabruf

​Protokollierung

​Konfiguration der Wiederholungsstrategie

​Standardverhalten

​Benutzerdefinierte Konfiguration

​Wann Wiederholungen auftreten

​Transport- vs. Anrufer-Wiederholungen

​Berechnung der maximalen Dauer

​Konfigurationsbeispiele

​Konservative Strategie

​Aggressive Strategie

​Keine Wiederholungen (Schnelles Scheitern)

​Hochdurchsatzstrategie

​Verständnis von Jitter

​Best Practices

​Für Produktionsanwendungen

​Für Entwicklung/Test

​Für Batch-Operationen

​Überwachung und Debugging

​Fehlerbehandlung

​Leistungsüberlegungen

​Detaillierte Fehlerbehandlung

​Ausnahmehierarchie

​Warum Verbindungsfehler separat sind

​Empfohlene Fehlerbehandlung

​Granulare Fehlerbehandlung

​Konfiguration

​Umgebungsvariablen

​Hilfe erhalten

​Ressourcen

PyPI-Paket

API-Schlüssel erhalten

Installation

Authentifizierung

Schnellstart

Sync Client (Olostep)

Einfaches Web Scraping

Batch-Verarbeitung

Intelligentes Web Crawling

Site Mapping

KI-gesteuerte Antworten

Async Client (AsyncOlostep)

Einfaches Web Scraping

Batch-Verarbeitung

Intelligentes Web Crawling

Site Mapping

KI-gesteuerte Antworten

SDK-Referenz

Methodensystematik

Fehlerbehandlung

Automatische Wiederholungen

Erweiterte Funktionen

Intelligente Eingabekonvertierung

Erweiterte Scraping-Optionen

Batch-Verarbeitung mit benutzerdefinierten IDs

Intelligentes Crawling

Site Mapping mit Filtern

Antworten abrufen

Inhaltsabruf

Protokollierung

Konfiguration der Wiederholungsstrategie

Standardverhalten

Benutzerdefinierte Konfiguration

Wann Wiederholungen auftreten

Transport- vs. Anrufer-Wiederholungen

Berechnung der maximalen Dauer

Konfigurationsbeispiele

Konservative Strategie

Aggressive Strategie

Keine Wiederholungen (Schnelles Scheitern)

Hochdurchsatzstrategie

Verständnis von Jitter

Best Practices

Für Produktionsanwendungen

Für Entwicklung/Test

Für Batch-Operationen

Überwachung und Debugging

Fehlerbehandlung

Leistungsüberlegungen

Detaillierte Fehlerbehandlung

Ausnahmehierarchie

Warum Verbindungsfehler separat sind

Empfohlene Fehlerbehandlung

Granulare Fehlerbehandlung

Konfiguration

Umgebungsvariablen

Hilfe erhalten

Ressourcen