Struct Client

Source

pub struct Client<P: Provider, H: HttpClient> { /* private fields */ }

Implementations§

Source §

pub fn with_auth( base_url: impl Into<String>, api_key: Option<SecretString>, ) -> Self

Source §

impl Client<RawProvider, DefaultHttpClient<OpenAIConfig>>

Source

pub fn raw() -> Self

Source

pub fn with_auth_raw( base_url: impl Into<String>, api_key: Option<SecretString>, ) -> Self

Examples found in repository ?

examples/generate.rs (lines 205-208)

fn create_client(
    env_base_url: &str,
    env_api_key: &str,
) -> Option<Client<RawProvider, DefaultHttpClient<OpenAIConfig>>> {
    match std::env::var(env_api_key) {
        Err(e) => {
            tracing::error!("Error: {e} - {env_api_key}");
            None
        }
        Ok(api_key) => match std::env::var(env_base_url) {
            Ok(base_url) => Some(Client::with_auth_raw(
                base_url,
                Some(SecretString::new(api_key.into())),
            )),
            Err(e) => {
                tracing::error!("Error: {e} - {env_base_url}");
                None
            }
        },
    }
}

Source §

impl<P: Provider, H: HttpClient> Client<P, H>

Source

pub fn completions(&self) -> Completions<'_, P, H>

Source

pub fn chat(&self) -> Chat<'_, P, H>

Examples found in repository ?

examples/generate.rs (line 139)

async fn generate<H: HttpClient>(
    client: &Option<Client<RawProvider, H>>,
    provider_name: impl Into<String>,
    model_name: impl Into<String>,
    test_name: impl Into<String>,
    prompt: impl Into<String>,
) -> Result<(), Error> {
    let test_name: String = test_name.into();
    let provider_name: String = provider_name.into();
    let model_name: String = model_name.into();
    match client {
        None => tracing::debug!(
            "Skip {}/{}/{} because client is None",
            provider_name,
            model_name,
            test_name
        ),
        Some(client) => {
            let request = ChatRequest::new(&model_name, vec![ChatMessage::user(prompt)]);
            let request = serde_json::to_value(request)?;
            tracing::debug!("Sending request: {:?}", request);
            let response = client.chat().create(request.clone()).await?;

            let provider_model_name =
                format!("{}_{}", provider_name, sanitize_folder_name(&model_name));

            let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
            d.push("data");
            d.push(&test_name);
            d.push(&provider_model_name);
            let output_path = d
                .to_str()
                .map(ToString::to_string)
                .ok_or(Error::InvalidArgument(format!(
                    "Failed to get path for data/{}/{}",
                    test_name, provider_model_name
                )))?;
            match fs::create_dir_all(&output_path) {
                Err(e) => tracing::error!("Failed to create folder: {:?}", e),
                Ok(_) => {
                    tracing::info!("Successfully created folder: {:?}", output_path);
                    // info.json
                    let mut info_path = PathBuf::from_str(&output_path).unwrap();
                    info_path.push("info.json");
                    let info = json!({
                        "provider_name": provider_name,
                        "test_name": test_name,
                        "model_name": model_name
                    });
                    match save_json_to_file(&info, &info_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", info_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }

                    // request.json
                    let mut request_path = PathBuf::from_str(&output_path).unwrap();
                    request_path.push("request.json");
                    match save_json_to_file(&request, &request_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", request_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }

                    // response.json
                    let mut response_path = PathBuf::from_str(&output_path).unwrap();
                    response_path.push("response.json");
                    match save_json_to_file(&response, &response_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", response_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }
                }
            }
        }
    }

    Ok(())
}