Rust

Esta página é uma tradução do inglês. Se as duas diferirem, a página em inglês é a correta. Ler a página em inglês

A biblioteca Rust é o crate lingara no crates.io. Requer Rust 1.87 ou posterior e corre sobre o runtime Tokio. O TLS vem do rustls por predefinição, ou do TLS nativo da plataforma através de uma feature.

Como se utiliza

Cada chamada é uma async fn que devolve um Result. Para cancelar uma chamada, descarte o seu future; para cancelar um stream, descarte o stream.
Um stream chega assim que chegam os cabeçalhos da resposta, como um Stream de resultados. Leia-o com .next().await.
Os erros são um único enum Error com quatro variantes. Error::retry_after devolve a espera indicada pela API, quando existiu.
Construa um cliente com Client::builder(). Para partilhar um pool de ligações, entregue-lhe o seu próprio reqwest::Client, mas não dê a esse cliente um tempo limite total, ou ele cortará os streams longos antes do fim. Para um prazo numa única chamada, envolva-a em tokio::time::timeout.

Os exemplos abaixo instalam o crate, criam um cliente, recebem em stream uma lista de vocabulário e tratam um erro.

Rust

cargo add lingara@0.1.0-alpha.6
cargo add tokio --features macros,rt-multi-thread

Rust

use lingara::Client;

let client = Client::builder()
    .client_credentials(std::env::var("LINGARA_CLIENT_ID")?, std::env::var("LINGARA_CLIENT_SECRET")?)
    .build()?;

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

Rust

use lingara::Error;

let result = client.get_usage().await;
if let Some(wait) = result.as_ref().err().and_then(Error::retry_after) {
    eprintln!("the API asks you to retry after {wait:?}");
}
match result {
    Ok(usage) => println!("{} allowance rows", usage.allowance.len()),
    // A refusal from the API: status, code (stable) and message (localised).
    Err(Error::Api(e)) => eprintln!("{} {} {}", e.status, e.code, e.message),
    // The token endpoint refused the credentials or the scopes.
    Err(Error::OAuth(e)) => eprintln!("{} {} {}", e.status, e.error, e.description.unwrap_or_default()),
    Err(Error::Maintenance(_)) => eprintln!("the API is under maintenance"),
    // No usable answer: connect, tls, reset, timeout, and so on.
    Err(Error::Transport(e)) => eprintln!("transport: {}", e.kind),
    Err(other) => return Err(other.into()),
}

Rust

Como se utiliza

O que esta página encapsula