Struct Generation

pub struct Generation<'a> { /* private fields */ }

Implementations

impl<'a> Generation<'a>

pub fn new(client: &'a Client) -> Self

pub async fn call(&self, request: GenerationParam) -> Result<GenerationOutput>

异步调用生成服务

此函数用于当请求参数中的stream设置为false时，发送一次性生成请求 如果stream参数为true，则会返回错误，提示用户使用call_stream方法

参数

• request: 包含生成参数的请求对象

返回

返回生成输出的结果，如果请求配置了stream且为true，则返回错误

Examples found in repository

examples/text-generation.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = GenerationParamBuilder::default()
        .model("qwen-turbo".to_string())
        .input(
            InputBuilder::default()
                .messages(vec![MessageBuilder::default()
                    .role("user")
                    .content("你是谁")
                    .build()
                    .unwrap()])
                .build()?,
        )
        .parameters(
            ParametersBuilder::default()
                .result_format("message")
                .build()?,
        )
        .build()?;

    let client = Client::new();

    let response = client.generation().call(request).await?;
    dbg!(response);
    Ok(())
}

examples/qwen-mt.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = GenerationParamBuilder::default()
        .model("qwen-mt-turbo".to_string())
        .input(
            InputBuilder::default()
                .messages(vec![MessageBuilder::default()
                    .role("user")
                    .content("我看到这个视频后没有笑")
                    .build()
                    .unwrap()])
                .build()?,
        )
        .parameters(
            ParametersBuilder::default()
                .translation_options(
                    TranslationOptionsBuilder::default()
                        .source_lang("Chinese")
                        .target_lang("English")
                        .build()?,
                )
                .build()?,
        )
        .build()?;

    let client = Client::new();

    let response = client.generation().call(request).await?;
    dbg!(response);
    Ok(())
}

pub async fn call_stream( &self, request: GenerationParam, ) -> Result<GenerationOutputStream>

异步调用生成流函数

此函数用于处理文本生成的流式请求。流式请求意味着响应会随着时间的推移逐步返回， 而不是一次性返回所有内容。这对于需要实时处理生成内容的场景特别有用。

参数

• request: 一个可变的 GenerationParam 类型对象，包含了生成文本所需的参数。

返回

返回一个 Result 类型，包含一个 GenerationOutputStream 对象，用于接收生成的文本流。 如果 request 中的 stream 字段为 Some(false)，则返回一个 DashScopeError::InvalidArgument 错误， 提示用户应使用 Generation::call 函数而不是 call_stream。

错误处理

如果 request 参数中的 stream 属性为 Some(false)，表示用户不希望使用流式处理， 函数将返回一个错误，提示用户应使用非流式处理的 call 方法。

注意

该函数自动将 request 的 stream 属性设置为 Some(true)，确保总是以流式处理方式执行生成任务。

Examples found in repository

examples/text-generation-stream.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = GenerationParamBuilder::default()
        .model("qwen-turbo".to_string())
        .input(
            InputBuilder::default()
                .messages(vec![MessageBuilder::default()
                    .role("user")
                    .content("qwen 大模型系统是谁开发的?")
                    .build()
                    .unwrap()])
                .build()?,
        )
        .stream(true)
        .parameters(
            ParametersBuilder::default()
                .result_format("message")
                .incremental_output(true)
                .build()?,
        )
        .build()?;

    let client = Client::new();

    let mut stream = client.generation().call_stream(request).await?;
    while let Some(response) = stream.next().await {
        match response {
            Ok(go) => go.output.choices.iter().for_each(|c| {
                print!("{}", c.message.content);
            }),
            Err(e) => eprintln!("{}", e),
        }
    }
    Ok(())
}

examples/qwen-mt-stream.rs (line 39)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = GenerationParamBuilder::default()
        .model("qwen-mt-turbo".to_string())
        .input(
            InputBuilder::default()
                .messages(vec![MessageBuilder::default()
                    .role("user")
                    .content("我看到这个视频后没有笑")
                    .build()
                    .unwrap()])
                .build()?,
        )
        .stream(true)
        .parameters(
            ParametersBuilder::default()
                // .incremental_output(true) # Qwen-MT模型暂时不支持增量式流式输出,所以此设置无效
                .translation_options(
                    TranslationOptionsBuilder::default()
                        .source_lang("Chinese")
                        .target_lang("English")
                        .build()?,
                )
                .build()?,
        )
        .build()?;

    let client = Client::new();

    let mut stream = client.generation().call_stream(request).await?;
    while let Some(response) = stream.next().await {
        match response {
            Ok(go) => go.output.choices.iter().for_each(|c| {
                println!("{}", c.message.content);
            }),
            Err(e) => eprintln!("{}", e),
        }
    }
    Ok(())
}