PyPI-Paket: olostep | Anforderungen: Python 3.11+

Installation

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 Bearbeitung vieler gleichzeitiger Anfragen.

Der Async-Client bietet nicht-blockierende Operationen und ist die empfohlene Wahl für Produktionsanwendungen, die eine hohe Durchsatzrate 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
# indem du die Umgebungsvariable OLOSTEP_API_KEY setzt

# 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 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 'api_key'-Parameter an oder
# indem du die Umgebungsvariable OLOSTEP_API_KEY setzt

# 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")
# Der 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 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 dieselbe saubere, pythonische Schnittstelle, die in logische Namensräume organisiert ist:

Namensraum	Zweck	Wichtige Methoden
`scrapes`	Einzel-URL-Extraktion	`create()`, `get()`
`batches`	Multi-URL-Verarbeitung	`create()`, `info()`, `items()`
`crawls`	Website-Durchquerung	`create()`, `info()`, `pages()`
`maps`	Link-Extraktion	`create()`, `urls()`
`answers`	KI-gestützte Extraktion	`create()`, `get()`
`retrieve`	Inhaltserfassung	`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 bewährte Praktiken zur Wiederholungsstrategie 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: 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
)

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 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 erweiterten 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 relevante URLs: {len(urls)}")

Antwortabruf

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

Inhaltserfassung

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 Levels: 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 vorübergehende Netzwerkprobleme, Ratenbeschränkungen und Serverüberlastungen 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 (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% Mindestjitter
    jitter_max=0.8,  # 80% Maximaljitter
)

# 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ü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: Behandelt netzwerkbezogene Verbindungsfehler (DNS, Timeouts, etc.)
Anruferschicht: Behandelt 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 die Wiederholungsstrategie für verschiedene Anwendungsfälle konfiguriert werden kann.

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 Feedback bei Fehlern
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

Beste Praktiken

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 der DEBUG-Ebene:

DEBUG: Vorübergehendes Problem, erneuter Versuch in 2,34s
DEBUG: Kein Ergebnis in der Antwort, erneuter Versuch 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"Nach allen Wiederholungen fehlgeschlagen: {e}")
    # Dauerhaften Fehler behandeln

Leistungsüberlegungen

Speicher: Jeder Wiederholungsversuch verwendet zusätzlichen Speicher für Anforderungs-/Antwortobjekte
Zeit: Die gesamte Operationszeit 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 - 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 sich um netzwerkbezogene Fehler handelt, 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 die Basisausnahme ab und drucke 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 ausreichend beschreibend, 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("Guthaben 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`	Anforderungs-Timeout (Sek.)	`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

​Batch-Verarbeitung mit benutzerdefinierten IDs

​Intelligentes Crawling

​Site-Mapping mit Filtern

​Antwortabruf

​Inhaltserfassung

​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

​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

Batch-Verarbeitung mit benutzerdefinierten IDs

Intelligentes Crawling

Site-Mapping mit Filtern

Antwortabruf

Inhaltserfassung

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

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