use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use crate::error::Error;
use crate::models::ModelList;
use crate::request::Request;
use crate::response::Response;
pub trait Transport: Send + Sync {
fn evaluate(
&self,
request: &Request,
) -> impl Future<Output = Result<Reply<Response>, Error>> + Send;
fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send;
}
impl<T: Transport + ?Sized> Transport for &T {
fn evaluate(
&self,
request: &Request,
) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
(**self).evaluate(request)
}
fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
(**self).list_models()
}
}
impl<T: Transport + ?Sized> Transport for Arc<T> {
fn evaluate(
&self,
request: &Request,
) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
(**self).evaluate(request)
}
fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
(**self).list_models()
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Reply<T> {
pub body: T,
pub meta: ReplyMeta,
pub raw_body: Option<String>,
}
impl<T> Reply<T> {
#[must_use]
pub const fn new(body: T, meta: ReplyMeta) -> Self {
Self {
body,
meta,
raw_body: None,
}
}
#[must_use]
pub fn with_raw_body(mut self, raw_body: impl Into<String>) -> Self {
self.raw_body = Some(raw_body.into());
self
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct ReplyMeta {
pub request_id: Option<String>,
pub latency: Duration,
pub attempts: u32,
}
impl ReplyMeta {
#[must_use]
pub const fn new(request_id: Option<String>, latency: Duration, attempts: u32) -> Self {
Self {
request_id,
latency,
attempts,
}
}
}
#[cfg(test)]
mod tests {
use std::future::{Future, ready};
use std::sync::Arc;
use std::time::Duration;
use indexmap::IndexMap;
use super::{Reply, ReplyMeta, Transport};
use crate::{Error, ModelCard, ModelList, Request, Response, Usage};
struct Canned;
impl Transport for Canned {
fn evaluate(
&self,
request: &Request,
) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
let body = Response::new(request.model.clone(), IndexMap::new(), Usage::new(1, 0));
let meta = ReplyMeta::new(Some("req_fake".into()), Duration::ZERO, 1);
ready(Ok(Reply::new(body, meta)))
}
fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
let models = ModelList::new(vec![ModelCard::new("jev-latest")]);
ready(Ok(Reply::new(models, ReplyMeta::default())))
}
}
async fn model_names(transport: impl Transport) -> Vec<String> {
let reply = transport.list_models().await.unwrap();
reply
.body
.models
.into_iter()
.map(|model| model.name)
.collect()
}
fn assert_send<T: Send>(value: T) -> T {
value
}
#[tokio::test]
async fn a_fake_a_reference_and_an_arc_are_all_transports() {
let shared = Arc::new(Canned);
assert_eq!(model_names(Canned).await, ["jev-latest"]);
assert_eq!(model_names(&Canned).await, ["jev-latest"]);
assert_eq!(model_names(Arc::clone(&shared)).await, ["jev-latest"]);
let request = Request::new("s", "jev-1.13.0");
let reply = assert_send(shared.evaluate(&request)).await.unwrap();
assert_eq!(reply.body.model, "jev-1.13.0");
assert_eq!(reply.meta.request_id.as_deref(), Some("req_fake"));
}
}