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: Produktionsanwendungen und die Verarbeitung vieler gleichzeitiger Anfragen.

Der Async-Client bietet nicht-blockierende Operationen und ist die empfohlene Wahl für Produktionsanwendungen, die hohe Durchsätze benötigen.

Sync Client (Olostep)

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

from olostep import Olostep

# Gib den API-Schlüssel entweder über den 'api_key'-Parameter an oder
# setze die Umgebungsvariable OLOSTEP_API_KEY

# Der Sync-Client verwaltet Ressourcen automatisch
# Kein explizites Schließen nötig - 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")

# Verarbeite mehrere URLs effizient
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"
    ]
)

# Warte auf Abschluss und verarbeite Ergebnisse
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")

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

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

# Hole alle entdeckten URLs
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")

# Hole Antworten von Webseiten mit KI
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 verarbeiten musst.

from olostep import AsyncOlostep

# Gib den API-Schlüssel entweder über den 'api_key'-Parameter an oder
# setze die Umgebungsvariable OLOSTEP_API_KEY

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

# 1. Kontext-Manager (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:
        # Verarbeite mehrere URLs effizient
        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"
            ]
        )

        # Warte auf Abschluss und verarbeite Ergebnisse
        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:
        # Crawle 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:
        # Extrahiere alle Links von einer Website
        maps = await client.maps.create(url="https://example.com")

        # Hole alle entdeckten URLs
        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:
        # Hole Antworten von Webseiten mit KI
        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:

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-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 Basisklasse der Ausnahmen:

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 Optionen zur Wiederholungskonfiguration und bewährte Praktiken siehe Retry Strategy.

Erweiterte Funktionen

Intelligente Eingabekonvertierung

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: nicht case-sensitive 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 bis zu 1 Tag (86400 Sekunden) alt
result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["markdown"],
    max_age=86400
)

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

# Verarbeite Ergebnisse nach benutzerdefinierter ID
# Beim Verwenden eines Parsers, hole JSON-Inhalt statt HTML
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")

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

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

# Hole gefilterte URLs
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")

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

# Dann rufe sie mit der ID ab
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")

# Hole Inhalt nach Abruf-ID
result = client.retrieve.get(retrieve_id="ret_123")

# Hole mehrere Formate
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, Ratenlimits 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

# Erstelle benutzerdefinierte Wiederholungsstrategie
retry_strategy = RetryStrategy(
    max_retries=3,
    initial_delay=1.0,
    jitter_min=0.2,  # 20% minimale Jitter
    jitter_max=0.8,  # 80% maximale Jitter
)

# Verwende mit Client
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übergehenden Serverproblemen (OlostepServerError_TemporaryIssue)
Timeout-Antworten (OlostepServerError_NoResultInResponse)

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

Transport- vs. Anrufer-Wiederholungen

Das SDK hat zwei Wiederholungsebenen:

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

Beide Ebenen sind unabhängig und haben separate Konfigurationen. Die gesamte maximale Dauer 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 Aufrufdauer: {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 Feedback bei Fehlern
retry_strategy = RetryStrategy(max_retries=0)

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

Strategie für hohen Durchsatz

# 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, End=2.2-3.8s
Versuch 1: Basis=4.0s, Jitter=0.4-3.6s, End=4.4-7.6s
Versuch 2: Basis=8.0s, Jitter=0.8-7.2s, End=8.8-15.2s

Beste Praktiken

Für Produktionsanwendungen

# 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/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: Vorübergehendes Problem, Wiederholung in 2,34s
DEBUG: Kein Ergebnis in Antwort, Wiederholung in 4,67s

Aktiviere 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"Fehlgeschlagen nach allen Wiederholungen: {e}")
    # Behandle das dauerhafte Scheitern

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 Hauptfehlerarten, die direkt von Olostep_BaseError erben:

Olostep_APIConnectionError - Netzwerkbezogene 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, etc.) 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 den Basisfehler 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 angegeben")
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`	Anforderungszeitlimit (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 Eingabekonvertierung

​Erweiterte Scraping-Optionen

​Caching

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

​Strategie für hohen Durchsatz

​Verständnis von Jitter

​Beste Praktiken

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

Erweiterte Scraping-Optionen

Caching

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)

Strategie für hohen Durchsatz

Verständnis von Jitter

Beste Praktiken

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