0%

Wenn etwas schiefgeht · Übung

Jeden Aufruf begrenzen

Die Demonstration in Lektion 1 hat zwei Arten gezeigt, wie ein Aufruf ohne sinnvolles Ende weiterlaufen kann: eine Antwort, die zu lange dauert, und eine Antwort, die länger wird, als du bezahlen willst. Ein Programm, das ein Modell aufruft, sollte beides begrenzen, bevor es etwas sendet. In dieser Lektion schreibst du call_once, einen einzelnen Versuch mit beiden Grenzen, den jede spätere Funktion im Kapitel verwendet.

Eine Grenze für die Zeit

Kapitel 5 hat jedem Client eine timeout-Zahl gegeben, CLIENT_TIMEOUT = 10.0 in client_calls.py. Der Client verwendet sie für jede Wartezeit: beim Öffnen der Verbindung, beim Senden der Anfrage und bei jedem Lesen vom Server. Dauert eine Wartezeit länger, gibt der Client auf und löst openai.APITimeoutError aus, eine Art von openai.APIConnectionError.

Diese Grenze sitzt schon auf jedem Client, den der Kurs baut, deshalb setzt call_once sie nicht noch einmal. Wer für eine Aufgabe eine andere Grenze braucht, macht mit with_options eine Kopie des Clients, so wie die Demonstration dieser Lektion:

impatient = scenario_client("slow:1500").with_options(timeout=0.5)

slow:1500 lässt das geskriptete Modell 1.5 Sekunden warten, bevor es antwortet. Mit einem Timeout von 0.5 Sekunden hört der Client nach etwa einer halben Sekunde auf zu warten.

Eine Grenze für die Länge

max_tokens begrenzt, wie viele Tokens die Antwort haben darf (Kapitel 2, Lektion 4). Ohne diese Grenze entscheidet ein Anbieter, wie lang eine Antwort werden darf, und du bezahlst jedes Token davon. Ab jetzt enthält jede Anfrage, die dieses Kapitel sendet, max_tokens: den eigenen Wert der Anfrage, falls sie einen hat, sonst DEFAULT_MAX_TOKENS, also 800.

Das geskriptete Modell nimmt max_tokens an und ignoriert es, deshalb siehst du in seinen Antworten keinen Unterschied. pl-live senkt jeden Wert über 1000 auf 1000 und verbraucht einen Teil dieses Limits für Reasoning, bevor es die sichtbare Antwort schreibt. 800 lässt Platz für ein Quiz mit mehreren Fragen plus dieses Reasoning.

Eine Antwort, die das Limit erreicht, hört dort auf, mit finish_reason "length". Darum kümmert sich Lektion 5.

Eine Anfrage als Dictionary

Ab dieser Lektion ist eine Anfrage ein einzelnes Dictionary, das einen Aufruf beschreibt. Es hat immer model und messages und kann tools, response_format und max_tokens haben:

question = {"model": MODEL, "messages": [{"role": "user", "content": "What is a Python list?"}]}

Ein Dictionary lässt sich leicht weitergeben, unverändert erneut versuchen und vor dem Senden prüfen, was Lektion 6 tut. call_once(request, *, client) macht daraus einen create-Aufruf:

client.chat.completions.create(
    model=request["model"],
    messages=request["messages"],
    tools=request.get("tools", openai.omit),
    response_format=request.get("response_format", openai.omit),
    max_tokens=request.get("max_tokens", DEFAULT_MAX_TOKENS),
)

openai.omit ist ein besonderer Wert aus dem openai-Paket, der „lass diesen Schlüssel aus der Anfrage weg“ bedeutet. Eine Anfrage für eine einfache Antwort hat keinen tools-Schlüssel, also liefert request.get("tools", openai.omit) den Wert openai.omit, und der Body, den der Client sendet, enthält überhaupt kein tools. Würdest du stattdessen None übergeben, würde "tools": null gesendet, und das ist nicht dasselbe wie Weglassen: Das geskriptete Modell akzeptiert es, andere Dienste können es aber ablehnen.

Jeder Schlüssel wird mit Namen übergeben, sodass jemand, der call_once liest, genau sieht, was eine Anfrage senden kann. call_once gibt die Antwort zurück, die create zurückgegeben hat, und fängt nichts ab: Ein Fehler aus create erreicht den Aufrufer, und Lektion 7 entscheidet, was damit geschieht.

Ausführen

Wenn call_once geschrieben ist, führe python chapter9_demo.py aus:

One bounded call:
  A list is an ordered, changeable collection of values. You write one with square brackets, like [1, 2, 3], and you can add, remove and change items after creating it.
The same call through a client that waits at most 0.5 seconds for a slow reply:
  APITimeoutError: Request timed out.
Worth another attempt?
Run stopped at the next function to build: should_retry is built in Lesson 3.

Der erste Aufruf ist eine gewöhnliche Antwort. Der zweite zeigt die Zeitgrenze: Die Demonstration fängt openai.APITimeoutError ab und gibt nach etwa einer halben Sekunde seinen Text aus, Request timed out., eine Sekunde bevor das geskriptete Modell geantwortet hätte.

MODEL_SERVICE.md erklärt, wie du den Body siehst, der wirklich gesendet wurde: last_request() in client_calls.py gibt ihn zurück. Um ihn selbst zu sehen, öffne das , starte python und tippe:

>>> from reliable import call_once
>>> from client_calls import MODEL, make_client, last_request
>>> response = call_once({"model": MODEL, "messages": [{"role": "user", "content": "What is a Python list?"}]}, client=make_client())
>>> "tools" in last_request()
False

Eine Anfrage hat keinen tools-Schlüssel. Warum übergibt call_once request.get("tools", openai.omit) und nicht request.get("tools")?

Eine Aufgabe soll höchstens eine halbe Sekunde auf eine Antwort warten. Wohin gehört diese Grenze?

Aufgabe

Schreib in reliable.py die Funktion call_once(request, *, client). Mach genau einen client.chat.completions.create-Aufruf mit diesen Schlüsselwortargumenten, die jeweils aus der Anfrage gelesen werden:

  • model=request["model"] und messages=request["messages"]

  • tools=request.get("tools", openai.omit) und response_format=request.get("response_format", openai.omit), sodass eine Anfrage ohne diese Schlüssel keinen von beiden sendet

  • max_tokens=request.get("max_tokens", DEFAULT_MAX_TOKENS), wobei du die Konstante mit ihrem Namen verwendest

Gib die Antwort zurück. Ändere das Anfrage-Dictionary nicht und fang keine Fehler ab: Sie müssen den Aufrufer erreichen. Führe python chapter9_demo.py aus, um einen begrenzten Aufruf und einen Timeout zu sehen, und prüfe dann deine Arbeit.