openai-interface 0.10.0

//! GET request functionality for OpenAI interface
//!
//! This module provides HTTP GET request functionality for making requests to OpenAI-compatible APIs.
//! Unlike POST requests, GET requests typically don't require serialization of request bodies,
//! but may include query parameters.

use std::{future::Future, str::FromStr};

use serde::de::DeserializeOwned;

use crate::errors::OapiError;

/// Base trait for GET requests
pub trait Get {
    /// Returns the URL with query parameters if needed
    ///
    /// # Example
    ///
    /// ```rust
    /// use openai_interface::rest::get::Get;
    /// use openai_interface::errors::OapiError;
    ///
    /// struct MyRequest {
    ///     id: String,
    ///     limit: Option<u32>,
    /// }
    ///
    /// impl Get for MyRequest {
    ///     fn build_url(&self, base_url: &str) -> Result<String, OapiError> {
    ///         let mut url = format!("{}/{}", base_url, self.id);
    ///         if let Some(limit) = self.limit {
    ///             url.push_str(&format!("?limit={}", limit));
    ///         }
    ///         Ok(url)
    ///     }
    /// }
    /// ```
    fn build_url(&self, base_url: &str) -> Result<String, OapiError>;
}

/// Trait for non-streaming GET requests
pub trait GetNoStream: Get + Sync + Send {
    type Response: DeserializeOwned + FromStr<Err = OapiError> + Send + Sync;

    /// Sends a GET request and returns the raw response body.
    ///
    /// The `client` is supplied by the caller; see [`crate::rest::default_client`]
    /// for a sensible default.
    fn get_response_string(
        &self,
        client: &reqwest::Client,
        base_url: &str,
        key: &str,
    ) -> impl Future<Output = Result<String, OapiError>> + Send + Sync {
        async move {
            let url = self.build_url(base_url)?;
            let response = client
                .get(&url)
                .header("Accept", "application/json")
                .bearer_auth(key)
                .send()
                .await?;

            crate::rest::response_text_checked(response).await
        }
    }

    /// Sends a GET request and deserializes the response
    fn get_response(
        &self,
        client: &reqwest::Client,
        base_url: &str,
        key: &str,
    ) -> impl Future<Output = Result<Self::Response, OapiError>> + Send + Sync {
        async move {
            let text = self.get_response_string(client, base_url, key).await?;
            let result = Self::Response::from_str(&text)?;
            Ok(result)
        }
    }
}

/// Trait for GET requests whose response body is binary rather than JSON.
///
/// Endpoints such as `GET /files/{file_id}/content` return the raw file
/// contents instead of a JSON object, so the body is returned as raw bytes.
pub trait GetBinary: Get + Sync + Send {
    /// Sends a GET request and returns the raw response body bytes.
    fn get_response_bytes(
        &self,
        client: &reqwest::Client,
        base_url: &str,
        key: &str,
    ) -> impl Future<Output = Result<Vec<u8>, OapiError>> + Send + Sync {
        async move {
            let url = self.build_url(base_url)?;
            let response = client
                .get(&url)
                .header("Accept", "*/*")
                .bearer_auth(key)
                .send()
                .await?;

            crate::rest::response_bytes_checked(response).await
        }
    }
}