impls and forms for each type mods

Author: 64bit

async-openai/src/types/assistants/impls.rs

@@ -0,0 +1,19 @@
+use crate::types::assistants::CreateMessageRequestContent;
+
+impl From<String> for CreateMessageRequestContent {
+    fn from(value: String) -> Self {
+        Self::Content(value)
+    }
+}
+
+impl From<&str> for CreateMessageRequestContent {
+    fn from(value: &str) -> Self {
+        Self::Content(value.to_string())
+    }
+}
+
+impl Default for CreateMessageRequestContent {
+    fn default() -> Self {
+        Self::Content("".into())
+    }
+}

async-openai/src/types/assistants/mod.rs

@@ -2,6 +2,7 @@ mod api;
 mod assistant;
 mod assistant_impls;
 mod assistant_stream;
+mod impls;
 mod message;
 mod run;
 mod step;

async-openai/src/types/audio/form.rs

@@ -0,0 +1,105 @@
+use crate::{
+    error::OpenAIError,
+    traits::AsyncTryFrom,
+    types::audio::{
+        CreateTranscriptionRequest, CreateTranslationRequest, TranscriptionChunkingStrategy,
+    },
+    util::create_file_part,
+};
+
+impl AsyncTryFrom<CreateTranscriptionRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateTranscriptionRequest) -> Result<Self, Self::Error> {
+        let audio_part = create_file_part(request.file.source).await?;
+
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", audio_part)
+            .text("model", request.model);
+
+        if let Some(language) = request.language {
+            form = form.text("language", language);
+        }
+
+        if let Some(prompt) = request.prompt {
+            form = form.text("prompt", prompt);
+        }
+
+        if let Some(response_format) = request.response_format {
+            form = form.text("response_format", response_format.to_string())
+        }
+
+        if let Some(temperature) = request.temperature {
+            form = form.text("temperature", temperature.to_string())
+        }
+
+        if let Some(include) = request.include {
+            for inc in include {
+                form = form.text("include[]", inc.to_string());
+            }
+        }
+
+        if let Some(timestamp_granularities) = request.timestamp_granularities {
+            for tg in timestamp_granularities {
+                form = form.text("timestamp_granularities[]", tg.to_string());
+            }
+        }
+
+        if let Some(stream) = request.stream {
+            form = form.text("stream", stream.to_string());
+        }
+
+        if let Some(chunking_strategy) = request.chunking_strategy {
+            match chunking_strategy {
+                TranscriptionChunkingStrategy::Auto => {
+                    form = form.text("chunking_strategy", "auto");
+                }
+                TranscriptionChunkingStrategy::ServerVad(vad_config) => {
+                    form = form.text(
+                        "chunking_strategy",
+                        serde_json::to_string(&vad_config).unwrap().to_string(),
+                    );
+                }
+            }
+        }
+
+        if let Some(known_speaker_names) = request.known_speaker_names {
+            for kn in known_speaker_names {
+                form = form.text("known_speaker_names[]", kn.to_string());
+            }
+        }
+
+        if let Some(known_speaker_references) = request.known_speaker_references {
+            for kn in known_speaker_references {
+                form = form.text("known_speaker_references[]", kn.to_string());
+            }
+        }
+
+        Ok(form)
+    }
+}
+
+impl AsyncTryFrom<CreateTranslationRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateTranslationRequest) -> Result<Self, Self::Error> {
+        let audio_part = create_file_part(request.file.source).await?;
+
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", audio_part)
+            .text("model", request.model);
+
+        if let Some(prompt) = request.prompt {
+            form = form.text("prompt", prompt);
+        }
+
+        if let Some(response_format) = request.response_format {
+            form = form.text("response_format", response_format.to_string())
+        }
+
+        if let Some(temperature) = request.temperature {
+            form = form.text("temperature", temperature.to_string())
+        }
+        Ok(form)
+    }
+}

async-openai/src/types/audio/impls.rs

@@ -0,0 +1,63 @@
+use std::fmt::Display;
+
+use crate::types::audio::{
+    AudioResponseFormat, TimestampGranularity, TranscriptionInclude, TranslationResponseFormat,
+};
+
+impl Display for AudioResponseFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                AudioResponseFormat::Json => "json",
+                AudioResponseFormat::Srt => "srt",
+                AudioResponseFormat::Text => "text",
+                AudioResponseFormat::VerboseJson => "verbose_json",
+                AudioResponseFormat::Vtt => "vtt",
+                AudioResponseFormat::DiarizedJson => "diarized_json",
+            }
+        )
+    }
+}
+
+impl Display for TranslationResponseFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TranslationResponseFormat::Json => "json",
+                TranslationResponseFormat::Srt => "srt",
+                TranslationResponseFormat::Text => "text",
+                TranslationResponseFormat::VerboseJson => "verbose_json",
+                TranslationResponseFormat::Vtt => "vtt",
+            }
+        )
+    }
+}
+
+impl Display for TimestampGranularity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TimestampGranularity::Word => "word",
+                TimestampGranularity::Segment => "segment",
+            }
+        )
+    }
+}
+
+impl Display for TranscriptionInclude {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TranscriptionInclude::Logprobs => "logprobs",
+            }
+        )
+    }
+}

async-openai/src/types/audio/mod.rs

@@ -1,4 +1,6 @@
 mod audio_types;
+mod form;
+mod impls;
 mod stream;
 
 pub use audio_types::*;

async-openai/src/types/chat/impls.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use crate::types::chat::{
     ChatCompletionFunctionCall, ChatCompletionNamedToolChoice,
     ChatCompletionRequestAssistantMessage, ChatCompletionRequestAssistantMessageContent,
@@ -8,7 +10,7 @@ use crate::types::chat::{
     ChatCompletionRequestSystemMessageContent, ChatCompletionRequestToolMessage,
     ChatCompletionRequestToolMessageContent, ChatCompletionRequestUserMessage,
     ChatCompletionRequestUserMessageContent, ChatCompletionRequestUserMessageContentPart,
-    FunctionName, ImageUrl,
+    FunctionName, ImageUrl, Role,
 };
 
 impl From<ChatCompletionRequestUserMessage> for ChatCompletionRequestMessage {
@@ -314,3 +316,19 @@ impl From<String> for ImageUrl {
         }
     }
 }
+
+impl Display for Role {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Role::User => "user",
+                Role::System => "system",
+                Role::Assistant => "assistant",
+                Role::Function => "function",
+                Role::Tool => "tool",
+            }
+        )
+    }
+}

async-openai/src/types/containers/form.rs

@@ -0,0 +1,22 @@
+use crate::{
+    error::OpenAIError, traits::AsyncTryFrom, types::containers::CreateContainerFileRequest,
+    util::create_file_part,
+};
+
+impl AsyncTryFrom<CreateContainerFileRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateContainerFileRequest) -> Result<Self, Self::Error> {
+        let mut form = reqwest::multipart::Form::new();
+
+        // Either file or file_id should be provided
+        if let Some(file_source) = request.file {
+            let file_part = create_file_part(file_source).await?;
+            form = form.part("file", file_part);
+        } else if let Some(file_id) = request.file_id {
+            form = form.text("file_id", file_id);
+        }
+
+        Ok(form)
+    }
+}

async-openai/src/types/containers/mod.rs

@@ -1,5 +1,6 @@
 mod api;
 mod container;
+mod form;
 
 pub use api::*;
 pub use container::*;

async-openai/src/types/files/form.rs

@@ -0,0 +1,22 @@
+use crate::{
+    error::OpenAIError, traits::AsyncTryFrom, types::files::CreateFileRequest,
+    util::create_file_part,
+};
+
+impl AsyncTryFrom<CreateFileRequest> for reqwest::multipart::Form {
+    type Error = OpenAIError;
+
+    async fn try_from(request: CreateFileRequest) -> Result<Self, Self::Error> {
+        let file_part = create_file_part(request.file.source).await?;
+        let mut form = reqwest::multipart::Form::new()
+            .part("file", file_part)
+            .text("purpose", request.purpose.to_string());
+
+        if let Some(expires_after) = request.expires_after {
+            form = form
+                .text("expires_after[anchor]", expires_after.anchor.to_string())
+                .text("expires_after[seconds]", expires_after.seconds.to_string());
+        }
+        Ok(form)
+    }
+}

async-openai/src/types/files/impls.rs

@@ -0,0 +1,32 @@
+use std::fmt::Display;
+
+use crate::types::files::{FileExpirationAfterAnchor, FilePurpose};
+
+impl Display for FilePurpose {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Assistants => "assistants",
+                Self::Batch => "batch",
+                Self::FineTune => "fine-tune",
+                Self::Vision => "vision",
+                Self::UserData => "user_data",
+                Self::Evals => "evals",
+            }
+        )
+    }
+}
+
+impl Display for FileExpirationAfterAnchor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::CreatedAt => "created_at",
+            }
+        )
+    }
+}