Struct Client

Source

pub struct Client {
    pub api_key: String,
    /* private fields */
}

Expand description

The Client for interacting with the Latitude API.

The Client provides methods to execute documents and handle real-time responses via the Latitude API. It is configured using the ClientBuilder, which allows for flexible and customizable initialization.

§Usage Example

use latitude_sdk::Client;

let client = Client::builder("your_api_key".into())
    .project_id(123)
    .version_id("version-uuid".to_string())
    .base_url("https://custom.url/api".to_string())
    .build();

Fields§

§api_key: String

The API key for authentication.

Implementations§

Source §

impl Client

Source

pub fn new( api_key: String, project_id: Option<u64>, version_id: Option<String>, base_url: Option<String>, ) -> Self

Creates a new Client with the provided API key.

§Arguments

api_key - The API key for authenticating with the Latitude API.
project_id - The default project ID used in requests.
version_id - The default version UUID used in requests.
base_url - The base URL for API requests. Defaults to the Latitude API endpoint.

§Examples

use latitude_sdk::Client;

let client = Client::new("your_api_key".into(), None, None, None);

Source

pub fn builder(api_key: String) -> ClientBuilder

Creates a new ClientBuilder with the required API key.

The ClientBuilder enables optional configuration of project_id, version_id, and base_url. This approach allows for flexible client initialization, where only the API key is required.

§Arguments

api_key - The API key for authenticating requests with the Latitude API.

§Example

use latitude_sdk::Client;

let client_builder = Client::builder("your_api_key".into());

Source

pub async fn run<T>(&self, document: RunDocument<T>) -> Result<Response, Error>
where T: Serialize + Debug,

Runs a document with the specified path and user-defined parameters, with an option for streaming responses.

§Arguments

document - The RunDocument struct containing the path, parameters, and an option to enable streaming.

§Returns

Response - The response from the Latitude API, either as JSON or a stream of events (LatitudeEvent or ProviderEvent).

§Examples

Running a document with a JSON response:

use latitude_sdk::{Client, models::document::RunDocument};
use latitude_sdk::models::response::Response;
use serde::Serialize;

#[derive(Serialize, Debug, Default)]
struct Params {
    user_message: String,
}

#[tokio::main]
async fn main() {
let client = Client::builder("your_api_key".into())
    .project_id(123)
    .version_id("version-uuid".to_string())
    .base_url("https://custom.url/api".to_string())
    .build();

    let params = Params {
        user_message: "Hello, world!".to_owned(),
    };

    let document = RunDocument {
        path: "Workers/EmotionAnalyzer".to_owned(),
        parameters: Some(params),
        stream: false,
        options: None
    };

    match client.run(document).await {
        Ok(Response::Json(response)) => println!("JSON Response: {:?}", response),
        _ => println!("Received a streaming response"),
        Err(e) => eprintln!("Error: {:?}", e),
    }
}

Running a document with a streaming response:

use latitude_sdk::{Client, models::document::RunDocument};
use latitude_sdk::models::event::Event;
use serde::Serialize;
use tokio_stream::StreamExt;
use latitude_sdk::models::response::Response;

#[derive(Serialize, Debug, Default)]
struct Params {
    user_message: String,
}

#[tokio::main]
async fn main() {
let client = Client::builder("your_api_key".into())
    .project_id(123)
    .version_id("version-uuid".to_string())
    .base_url("https://custom.url/api".to_string())
    .build();

    let params = Params {
        user_message: "Hello, world!".to_owned(),
    };

    let document = RunDocument {
        path: "Workers/EmotionAnalyzer".to_owned(),
        parameters: Some(params),
        stream: true,
        options: None
    };

    match client.run(document).await {
        Ok(Response::Stream(mut event_stream)) => {
            while let Some(event) = event_stream.recv().await {
                match event {
                    Event::LatitudeEvent(data) => println!("Latitude Event: {:?}", data),
                    Event::ProviderEvent(data) => println!("Provider Event: {:?}", data),
                    Event::UnknownEvent => println!("Unknown Event"),
                }
            }
        },
       _ => println!("Received a JSON response"),
        Err(e) => eprintln!("Error: {:?}", e),
    }
}