0%

Streamen · oefening

Als een stream halverwege afbreekt

Aan het eind van les 6 vroeg de demonstratie het gescripte model een stream af te kappen, en je stream_reply drukte drie delen af voordat requests een fout opwierp. Dat los je in deze les op. Een stream is een verbinding die het hele antwoord lang open blijft, en verbindingen breken: een netwerk valt weg, een dienst herstart, een proxy geeft het op. Je lezer moet dat merken, en het duidelijk melden.

Het gevaar is een antwoord dat er af uitziet

Stel dat een stream afbreekt na A list is an ordered collection that can hold . De tekst staat al op het scherm. Als stream_reply die teruggaf zoals elk ander antwoord, zou de aanroeper hem op geen enkele manier van een compleet antwoord kunnen onderscheiden. Een chat zou hem in de geschiedenis opslaan als wat het model zei, en een programma dat op het antwoord handelt, zou op de helft ervan handelen. Hier is de halve zin duidelijk afgekapt, maar de breuk kan net zo goed na een hele zin vallen, waar het ontbrekende deel onzichtbaar is.

Dus de regel voor deze les: stream_reply geeft alleen een compleet antwoord terug. Dit hoofdstuk gebruikt daar een strikte regel voor: een antwoord telt alleen als compleet als "[DONE]" is binnengekomen. Het slotstukje laat zien dat het model stopte met schrijven, maar [DONE] is het enige signaal dat de dienst alles heeft verstuurd. Een lezer die daarop staat, kan een afgekapte stream nooit voor een afgeronde aanzien. Al het andere is een fout.

Twee manieren waarop een stream te vroeg eindigt

De verbinding breekt. De dienst had meer data beloofd en de verbinding ging dicht zonder die data. requests merkt dit terwijl je regels leest en werpt requests.exceptions.ChunkedEncodingError op vanuit de for-lus over response.iter_lines(). Dat liet de demonstratie in les 6 zien. ChunkedEncodingError hoort bij de familie requests.RequestException die je in Python in de praktijk afving. De naam van de fout komt uit HTTP, niet uit de JSON-stukjes van de stream. Een gestreamde response wordt verstuurd in blokken die eindigen met een afsluitend blok, en requests werpt deze fout op als de verbinding sluit voordat dat afsluitende blok binnenkomt. Het woord “chunked” gaat hier over blokken van de HTTP-response, niet over je data:-documenten.

De regels raken op. De verbinding sluit netjes, maar [DONE] kwam nooit, dus de lus eindigt gewoon. requests ziet niets mis, want voor de verbinding is de response voorbij. Alleen jouw code weet dat het streamformaat een eindmarkering beloofde.

Het gescripte model kan het eerste geval bewust veroorzaken, met de requestheader X-Scripted-Scenario: broken-stream. Het tweede kan het niet, dus de demonstratie laat dat zien met een opgeslagen stream, die hieronder wordt beschreven.

De fout om op te werpen: StreamBroken

errors.py levert hiervoor een exception:

from errors import StreamBroken

Je maakt hem aan met de tekst die wel binnenkwam, raise StreamBroken(text), en de code die hem afvangt, leest die tekst terug uit het attribuut partial_text van de exception:

try:
    reply = stream_reply(response)
except StreamBroken as error:
    print(f"StreamBroken. The partial text was {error.partial_text!r}")

Zo las je in Python in de praktijk attributen van bestaande exceptions. Je hoeft errors.py niet te lezen of te veranderen: je werpt alleen de exception op en leest het attribuut. Door de gedeeltelijke tekst mee te geven kan een aanroeper beslissen wat hij ermee doet, bijvoorbeeld hem als onvolledig gemarkeerd tonen of hem loggen, zonder dat iemand hem voor een heel antwoord aanziet.

Verander stream_reply

Houd alles uit les 6 en voeg twee dingen toe:

  1. Onthoud of "[DONE]" is binnengekomen. Zet finished = False voor de lus en zet het op True vlak voor de break bij "[DONE]". Is finished na de lus nog False, dan raakten de regels te vroeg op: druk één newline af en werp StreamBroken("".join(pieces)) op.

  2. Maak van een verbroken verbinding dezelfde fout. Zet de for-lus in een try-blok en voeg except requests.exceptions.ChunkedEncodingError: toe, dat één newline afdrukt en StreamBroken("".join(pieces)) opwerpt.

Een complete stream drukt nog steeds zijn newline af en geeft de samengevoegde delen terug, zoals eerst. De newline voor elke raise sluit de half afgedrukte regel af, zodat wat de aanroeper daarna afdrukt op een nieuwe regel begint.

Vang alleen ChunkedEncodingError af. Het try-blok omvat ook json.loads en je eigen functies, en een fout daarin, zoals een stukje dat geen geldige JSON is of een typefout in een sleutel, is geen verbroken verbinding. Als except Exception: die in StreamBroken veranderde, zou een bug in je code als netwerkprobleem worden gemeld, en zou de echte fout verborgen blijven. Smalle except-clausules, zoals in Python in de praktijk, laten al het andere ongewijzigd bij de aanroeper aankomen.

Een stream die halverwege langer stil blijft dan de lees-time-out, werpt een andere fout op, requests.exceptions.ConnectionError, en niet ChunkedEncodingError. stream_reply vangt die niet af, dus die bereikt de aanroeper zonder de gedeeltelijke tekst. Dat afhandelen komt later, met nieuwe pogingen (retries).

Voer het uit

Voer python streaming.py uit. De afgebroken stream komt eerst. De demonstratie stuurt Explain Python lists in detail. met de scenarioheader:

response = open_stream(long_body, headers={"X-Scripted-Scenario": "broken-stream"})

Het gescripte model stuurt het commentaar, het eerste stukje en drie delen, en sluit dan de verbinding. Deze keer maakt stream_reply daar StreamBroken van, en de demonstratie vangt die af en drukt de gedeeltelijke tekst af met !r, zodat je de spatie aan het eind ziet:

A stream that breaks halfway:
A list is an ordered collection that can hold 
StreamBroken. The partial text was 'A list is an ordered collection that can hold '
A stream that ends without [DONE]:
Lists keep their order, 
StreamBroken. The partial text was 'Lists keep their order, '
The streaming study chat:
You: What does len() return?
Run stopped at the next function to build: chat_turn is built in Lesson 8.

Het tweede geval is de opgeslagen stream. De demonstratie bouwt een response uit twee data:-regels die ze zelf heeft uitgeschreven, zonder [DONE] erna:

saved = requests.Response()
saved.raw = io.BytesIO(
    b'data: {"choices": [{"index": 0, "delta": {"content": "Lists keep "}}]}\n\n'
    b'data: {"choices": [{"index": 0, "delta": {"content": "their order, "}}]}\n\n'
)

requests.Response() maakt een leeg responseobject, en door de raw ervan op die bytes te zetten krijgt iter_lines() iets om te lezen, precies alsof een dienst ze had gestuurd en daarna de verbinding netjes had gesloten. Je stream_reply leest beide delen, komt zonder regels te zitten en werpt StreamBroken op, omdat finished nog False is.

Een stream breekt af na de helft van het antwoord. Waarom moet stream_reply StreamBroken opwerpen in plaats van de ontvangen helft terug te geven?

Een stream stuurt zijn delen, het slotstukje en het usage-stukje, en daarna sluit de verbinding netjes zonder data: [DONE]. Wat moet je stream_reply volgens de regel van dit hoofdstuk doen?

stream_reply vangt requests.exceptions.ChunkedEncodingError af en verder niets. Eén stukje in een stream is geen geldige JSON, dus json.loads werpt een fout op. Wat gebeurt er?

Opdracht

Verander stream_reply(response) in streaming.py zodat het nooit een deel van een antwoord teruggeeft alsof het compleet is.

  • Als requests.exceptions.ChunkedEncodingError wordt opgeworpen terwijl je de regels leest, druk dan één newline af en werp StreamBroken("".join(pieces)) op.

  • Als de regels opraken voordat "[DONE]" binnenkomt, doe dan hetzelfde.

  • Een stream die "[DONE]" bereikt, drukt nog steeds de delen af, daarna één newline, en geeft het hele antwoord terug.

  • Vang geen andere exceptions af: andere fouten moeten de aanroeper ongewijzigd bereiken.

StreamBroken is al geïmporteerd uit errors.py. Voer python streaming.py uit om beide soorten afgebroken streams gemeld te zien, en controleer daarna je werk.