Stream

Questa pagina è tradotta dall'inglese. Se le due versioni differiscono, fa fede la pagina in inglese. Leggi la pagina in inglese

Quattro operazioni trasmettono i loro risultati come eventi inviati dal server: generare vocabolario, inviare un messaggio al tutor, creare un piano di lezione e seguirne uno. Ogni libreria trasforma lo stream di eventi nell’iteratore tipico del linguaggio e ti consegna ogni evento già decodificato in un valore tipizzato.

Come termina uno stream

Quando il lavoro è finito. L’iterazione si ferma da sola all’evento finale dello stream. Per un piano di lezione, quell’evento finale contiene il risultato, quindi lo ricevi prima che il ciclo termini.
Quando l’API segnala un errore. Un errore che arriva all’interno dello stream viene sollevato come errore dell’API, dello stesso tipo di uno che arriva prima.
Quando la connessione cade. Uno stream che termina prima del suo evento finale, o che non invia assolutamente nulla per 120 secondi, viene sollevato come errore di trasporto.
Quando ti fermi. Annulla la chiamata nel modo abituale del tuo linguaggio, oppure smetti di leggere, e la connessione si chiude subito.

I commenti di keepalive e i tipi di evento che una libreria non conosce ancora vengono ignorati, quindi un’API più recente non rompe mai una libreria più vecchia.

Mai ripetuto

Uno stream che ha consegnato anche un solo evento non viene mai ritentato dalla libreria, perché ripeterlo potrebbe consumare due volte la tua quota. Se lo stream di un piano di lezione si interrompe dopo essere iniziato, segui lo stesso piano con streamLessonPlan e il plan_id del suo primo evento.

TypeScriptRustGoJavaKotlinRubyPHP

TypeScript

const stream = client.generateVocabulary({ level: 2, source_lang: "en", target_lang: "zh", count: 8 });
for await (const ev of stream) {
  if (ev.event === "item") console.log(ev.data.word, ev.data.translation);
}

Rust

use lingara::models::{GenerateVocabularyEvent, VocabRequest};
use std::num::NonZeroU8;

let request = VocabRequest { level: 2, source_lang: "en".into(), target_lang: "zh".into(), count: NonZeroU8::new(8) };
let mut stream = client.generate_vocabulary(&request).await?;
while let Some(event) = stream.next().await {
    if let GenerateVocabularyEvent::Item(item) = event? {
        println!("{} {}", item.word, item.translation);
    }
}

count := uint8(8)
s, err := client.GenerateVocabulary(ctx, lingara.VocabRequest{Level: 2, SourceLang: "en", TargetLang: "zh", Count: &count})
if err != nil {
	return err
}
defer s.Close()
for ev, err := range s.Events() {
	if err != nil {
		return err
	}
	if item, ok := ev.(lingara.GenerateVocabularyEventItem); ok {
		fmt.Println(item.Data.Word, item.Data.Translation)
	}
}

Java

import com.getlingara.client.model.GenerateVocabularyEvent;
import com.getlingara.client.model.VocabRequest;

VocabRequest request = new VocabRequest().level(2).sourceLang("en").targetLang("zh").count(8);
try (EventStream<GenerateVocabularyEvent> stream = client.generateVocabulary(request)) {
  for (GenerateVocabularyEvent event : stream) {
    if (event instanceof GenerateVocabularyEvent.Item item) {
      System.out.println(item.data().getWord() + " " + item.data().getTranslation());
    }
  }
}

Kotlin

import com.getlingara.kotlin.LingaraClient
import com.getlingara.kotlin.model.GenerateVocabularyEvent
import com.getlingara.kotlin.model.VocabRequest

val request = VocabRequest(level = 2, sourceLang = "en", targetLang = "zh", count = 8)
// The request is sent here; collect the stream once, inside use {}.
client.generateVocabulary(request).use { stream ->
    stream.collect { event ->
        when (event) {
            is GenerateVocabularyEvent.Item -> println("${event.data.word} ${event.data.translation}")
            is GenerateVocabularyEvent.Started -> Unit
        }
    }
}

Ruby

client.generate_vocabulary(level: 2, source_lang: "en", target_lang: "zh", count: 8) do |event|
  case event
  in Lingara::GenerateVocabularyEventItem => item then puts "#{item.data.word}: #{item.data.translation}"
  else nil
  end
end

PHP

use Lingara\Model\VocabRequest;
use Lingara\Stream\GenerateVocabularyEvent;

$request = new VocabRequest(['level' => 2, 'source_lang' => 'en', 'target_lang' => 'zh', 'count' => 8]);
foreach ($client->generateVocabulary($request) as $event) {
    if ($event instanceof GenerateVocabularyEvent\Item) {
        echo $event->data->getWord(), ': ', $event->data->getTranslation(), "\n";
    }
}

Stream

Come termina uno stream

Mai ripetuto

Cosa incapsula questa pagina