PyPI-Paket: olostep | Anforderungen: Python 3.11+

Installation

pip install olostep

pip3 install olostep

poetry add olostep

uv pip install olostep

Authentifizierung

Hole dir deinen 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 du blockierende Operationen bevorzugst.

Der Sync-Client bietet eine einfachere, blockierende Schnittstelle, die leichter zu verwenden ist, wenn du neu bei async/await bist.

Async Client (`AsyncOlostep`)

Am besten geeignet für: Produktivanwendungen und die Bearbeitung vieler gleichzeitiger Anfragen.

Der Async-Client bietet nicht-blockierende Operationen und ist die empfohlene Wahl für Produktivanwendungen, die 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

# Gib den API-Schlüssel entweder über den Parameter 'api_key' an oder
# setze die 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")

# Effiziente Verarbeitung mehrerer URLs
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 intelligenter Filterung
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 URLs: {len(urls)}")

KI-gestützte 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 du viele gleichzeitige Anfragen bearbeiten musst.

from olostep import AsyncOlostep

# Gib den API-Schlüssel entweder über den Parameter 'api_key' an oder
# setze die 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:
        # Effiziente Verarbeitung mehrerer URLs
        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 intelligenter Filterung
        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 URLs: {len(urls)}")

asyncio.run(main())

KI-gestützte 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

Methodenstruktur

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

Namespace	Zweck	Wichtige Methoden
`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-gestützte Extraktion	`create()`, `get()`
`retrieve`	Inhaltsabruf	`get()`

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

Fehlerbehandlung

Fange alle SDK-Fehler mit der Basisausnahmeklasse 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. Du kannst das Wiederholungsverhalten anpassen, indem du eine RetryStrategy-Instanz beim Erstellen des Clients übergibst:

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 Wiederholungsstrategie.

Erweiterte Funktionen

Intelligente Eingabekoerzierung

Das SDK verarbeitet intelligent verschiedene Eingabeformate 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")    # Einzelne 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
)

Caching

Standardmäßig holt jede Scrape-Anfrage die Seite frisch ab (max_age=0). Gib max_age an, um ein kürzliches Ergebnis mit denselben Parametern wiederzuverwenden und die Antwortzeit zu verbessern. Der Wert ist in Sekunden; das Maximum beträgt 7 Tage (604800). Siehe Caching für Details.

# Opt-in für Caching: Akzeptiere Ergebnisse, die bis zu 1 Tag (86400 Sekunden) alt sind
result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["markdown"],
    max_age=86400
)

Speicherung

Standardmäßig wird ein Scrape-Ergebnis etwa 7 Tage lang aufbewahrt. Gib storage mit expires_in an, um es länger zu behalten: 10d, 30d, 60d, 90d, 180d, 365d oder never. Siehe Speicherung für Details.

result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["markdown"],
    storage={"expires_in": "90d"}
)

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-Inhalt statt 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 intelligenter Filterung
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 erweiterter Filterung 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 relevante URLs: {len(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")

# Inhalt 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"])

Logging

Aktiviere Logging, um Probleme zu debuggen:

import logging

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

Log-Level: 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überlastung zu intermittierenden Ausfällen 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 (schlimmster 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 stattfinden

Das SDK wiederholt automatisch bei:

Vorübergehende Serverprobleme (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: Behandelt netzwerkbezogene Verbindungsfehler (DNS, Timeouts, etc.)
Anrufer-Ebene: Behandelt API-bezogene vorübergehende Fehler (gesteuert durch RetryStrategy)

Beide Ebenen sind unabhängig und haben separate Konfiguration. 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 du die Wiederholungsstrategie für verschiedene Anwendungsfälle konfigurieren kannst.

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)

# Deaktiviere Wiederholungen 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 vermeiden, wenn viele Clients gleichzeitig wiederholen. Der Jitter wird berechnet als:

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: base=2.0s, jitter=0.2-1.8s, final=2.2-3.8s
Versuch 1: base=4.0s, jitter=0.4-3.6s, final=4.4-7.6s
Versuch 2: base=8.0s, jitter=0.8-7.2s, final=8.8-15.2s

Best Practices

Für Produktivanwendungen

# Ausgewogener Ansatz 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/Testen

# 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 der Antwort, erneuter Versuch in 4.67s

Aktiviere das Debug-Logging, 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"Nach allen Wiederholungen fehlgeschlagen: {e}")
    # Den dauerhaften Fehler behandeln

Leistungsüberlegungen

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

Wähle deine Wiederholungsstrategie basierend auf den Anforderungen deiner 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 fange die Basisausnahme ab und gib den Fehlernamen aus:

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 aussagekräftig genug, um das Problem zu verstehen.

Granulare Fehlerbehandlung

Wenn du eine spezifischere Fehlerbehandlung benötigst, fange die spezifischen Fehlertypen direkt ab. Vermeide 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 fange 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`	Dein API-Schlüssel	Erforderlich
`OLOSTEP_BASE_API_URL`	API-Basis-URL	`https://api.olostep.com/v1`
`OLOSTEP_API_TIMEOUT`	Anforderungs-Timeout (Sekunden)	`150`

​Installation

​Authentifizierung

​Schnellstart

Sync Client (Olostep)

Async Client (AsyncOlostep)

​Sync Client (Olostep)

​Einfaches Web Scraping

​Batch-Verarbeitung

​Intelligentes Web Crawling

​Site Mapping

​KI-gestützte Antworten

​Async Client (AsyncOlostep)

​Einfaches Web Scraping

​Batch-Verarbeitung

​Intelligentes Web Crawling

​Site Mapping

​KI-gestützte Antworten

​SDK-Referenz

​Methodenstruktur

​Fehlerbehandlung

​Automatische Wiederholungen

​Erweiterte Funktionen

​Intelligente Eingabekoerzierung

​Erweiterte Scraping-Optionen

​Caching

​Speicherung

​Batch-Verarbeitung mit benutzerdefinierten IDs

​Intelligentes Crawling

​Site Mapping mit Filtern

​Antworten abrufen

​Inhaltsabruf

​Logging

​Konfiguration der Wiederholungsstrategie

​Standardverhalten

​Benutzerdefinierte Konfiguration

​Wann Wiederholungen stattfinden

​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 Produktivanwendungen

​Für Entwicklung/Testen

​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`)

Async Client (`AsyncOlostep`)

Sync Client (Olostep)

Einfaches Web Scraping

Batch-Verarbeitung

Intelligentes Web Crawling

Site Mapping

KI-gestützte Antworten

Async Client (AsyncOlostep)

Einfaches Web Scraping

Batch-Verarbeitung

Intelligentes Web Crawling

Site Mapping

KI-gestützte Antworten

SDK-Referenz

Methodenstruktur

Fehlerbehandlung

Automatische Wiederholungen

Erweiterte Funktionen

Intelligente Eingabekoerzierung

Erweiterte Scraping-Optionen

Caching

Speicherung

Batch-Verarbeitung mit benutzerdefinierten IDs

Intelligentes Crawling

Site Mapping mit Filtern

Antworten abrufen

Inhaltsabruf

Logging

Konfiguration der Wiederholungsstrategie

Standardverhalten

Benutzerdefinierte Konfiguration

Wann Wiederholungen stattfinden

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 Produktivanwendungen

Für Entwicklung/Testen

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