fmt

litellm-rust/crates/core/src/audio_transcription/handler.rs

@@ -1,10 +1,9 @@
 use serde_json::Value;
 
 use super::Error;
-use crate::http_utils::{http_request, truncate_error_body};
-
 use super::client::http_client;
 use super::types::ProviderAudioTranscriptionRequest;
+use crate::http_utils::{http_request, truncate_error_body};
 
 pub async fn execute_audio_transcription_provider_call(
     request: ProviderAudioTranscriptionRequest,

litellm-rust/crates/core/src/audio_transcription/mod.rs

@@ -6,10 +6,9 @@ mod prepare;
 pub mod transformation;
 pub mod types;
 
-use serde_json::Value;
-
 pub use handler::execute_audio_transcription_provider_call;
 pub use prepare::prepare_audio_transcription_provider_call;
+use serde_json::Value;
 pub use types::{AudioTranscriptionRequest, ProviderAudioTranscriptionRequest};
 
 pub async fn audio_transcription(request: AudioTranscriptionRequest<'_>) -> Result<Value, Error> {

litellm-rust/crates/core/src/audio_transcription/prepare.rs

@@ -1,11 +1,10 @@
 use super::Error;
+use super::transformation::{AudioTranscriptionAuth, AudioTranscriptionProviderConfig};
+use super::types::{AudioTranscriptionRequest, ProviderAudioTranscriptionRequest};
 use crate::http_utils::{has_header, string_headers};
 use crate::providers::bedrock::audio_transcription::BEDROCK_AUDIO_TRANSCRIPTION_CONFIG;
 use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
 
-use super::transformation::{AudioTranscriptionAuth, AudioTranscriptionProviderConfig};
-use super::types::{AudioTranscriptionRequest, ProviderAudioTranscriptionRequest};
-
 fn provider_config(provider: &str) -> Option<&'static dyn AudioTranscriptionProviderConfig> {
     if provider == "bedrock" {
         return Some(&BEDROCK_AUDIO_TRANSCRIPTION_CONFIG);

litellm-rust/crates/core/src/audio_transcription/transformation.rs

@@ -1,6 +1,6 @@
-use super::Error;
 use serde_json::{Map, Value};
 
+use super::Error;
 use super::types::{AudioTranscriptionRequestData, AudioTranscriptionResponseData};
 
 #[derive(Clone, Debug, PartialEq, Eq)]

litellm-rust/crates/core/src/call_arguments.rs

@@ -381,9 +381,10 @@ impl IntoIterator for CallArguments {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     #[test]
     fn composition_preserves_extensions_and_applies_shallow_explicit_overrides() {
         let original = json!({

litellm-rust/crates/core/src/call_lifecycle/mod.rs

@@ -228,10 +228,11 @@ fn epoch_seconds() -> f64 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::pin::Pin;
     use std::sync::Mutex;
 
+    use super::*;
+
     type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
 
     #[derive(Default)]

litellm-rust/crates/core/src/chat_completions/common_utils.rs

@@ -1,9 +1,9 @@
-use super::Error;
-use crate::http_utils::string_headers as shared_string_headers;
-use crate::providers::anthropic::chat_completions::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG;
 use serde_json::{Map, Value};
 
+use super::Error;
 use super::transformation::ChatCompletionsProviderConfig;
+use crate::http_utils::string_headers as shared_string_headers;
+use crate::providers::anthropic::chat_completions::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG;
 
 const HEADER_CONTEXT: &str = "chat completions";
 

litellm-rust/crates/core/src/chat_completions/conversation.rs

@@ -10,9 +10,8 @@
 //! `_bedrock_converse_messages_pt` for the text-only surface this route
 //! accepts; anything richer is declined upstream by the capability gate.
 
-use crate::constants::EMPTY_TEXT_PLACEHOLDER;
-
 use super::types::{ChatMessage, ChatMessageContent};
+use crate::constants::EMPTY_TEXT_PLACEHOLDER;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum TurnRole {
@@ -132,9 +131,10 @@ pub fn build_conversation(messages: &[ChatMessage]) -> Conversation {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     fn messages(value: serde_json::Value) -> Vec<ChatMessage> {
         serde_json::from_value(value).expect("valid messages")
     }

litellm-rust/crates/core/src/chat_completions/handler.rs

@@ -1,8 +1,6 @@
 use serde_json::Value;
 
 use super::Error;
-use crate::http_utils::{http_request, truncate_error_body};
-
 use super::client::http_client;
 use super::prepare::prepare_provider_request;
 use super::transformation::ChatCompletionsAuth;
@@ -10,6 +8,7 @@ use super::types::{
     ChatCompletionsResponse, ProviderChatCompletionsRequest, ProviderChatResponseData,
     ResolvedChatCompletionsRequest,
 };
+use crate::http_utils::{http_request, truncate_error_body};
 
 pub(super) async fn execute_chat_completions_provider_call(
     request: ResolvedChatCompletionsRequest<'_>,

litellm-rust/crates/core/src/chat_completions/mod.rs

@@ -17,10 +17,9 @@ pub mod response_utils;
 pub mod transformation;
 pub mod types;
 
-use serde_json::{Map, Value};
-
 use handler::execute_chat_completions_provider_call;
 use prepare::{parse_messages, resolve_provider_config, resolve_request};
+use serde_json::{Map, Value};
 use types::{ChatCompletionsRequest, ChatCompletionsResponse};
 
 pub async fn chat_completions(

litellm-rust/crates/core/src/chat_completions/prepare.rs

@@ -1,15 +1,14 @@
 use serde_json::Value;
 
 use super::Error;
-use crate::http_utils::has_header;
-use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
-
 use super::common_utils::{chat_completions_provider_config, string_headers};
 use super::transformation::{ChatCompletionsAuth, ChatCompletionsProviderConfig};
 use super::types::{
     ChatCompletionsRequest, ChatMessage, ProviderChatCompletionsRequest,
     ResolvedChatCompletionsRequest,
 };
+use crate::http_utils::has_header;
+use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
 
 pub(super) fn resolve_provider_config<'a>(
     model: &'a str,

litellm-rust/crates/core/src/chat_completions/tests.rs

@@ -1,7 +1,6 @@
 use serde_json::{Map, Value, json};
 
 use super::Error;
-
 use super::prepare::{prepare_provider_request, resolve_request};
 use super::transformation::ChatCompletionsAuth;
 use super::types::{ChatCompletionsRequest, ProviderChatCompletionsRequest};
@@ -588,10 +587,10 @@ fn the_gate_agrees_with_prepare_on_every_case_it_accepts() {
 }
 
 mod round_trip {
-    use super::*;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::net::{TcpListener, TcpStream};
 
+    use super::*;
     use crate::chat_completions::chat_completions;
 
     async fn read_http_request(socket: &mut TcpStream) -> String {

litellm-rust/crates/core/src/chat_completions/transformation.rs

@@ -1,6 +1,6 @@
-use super::Error;
 use serde_json::{Map, Value};
 
+use super::Error;
 use super::types::{
     ChatCompletionsResponse, ChatMessage, ChatMessageContent, ProviderChatRequestData,
     ProviderChatResponseData,

litellm-rust/crates/core/src/http_utils.rs

@@ -131,9 +131,10 @@ pub fn json_type_name(value: &serde_json::Value) -> &'static str {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     #[rstest::rstest]
     #[case(HeaderPolicy::All, true, true)]
     #[case(HeaderPolicy::Only(&["authorization"]), true, false)]

litellm-rust/crates/core/src/llms/azure_ai/ocr/cohere_parse_transformation.rs

@@ -1,3 +1,5 @@
+use serde_json::Value;
+
 use crate::call_arguments::CallArguments;
 use crate::llms::base_llm::ocr::transformation::{BaseOcrConfig, OcrRequestContext};
 use crate::llms::cohere::ocr::transformation::{CohereParseConfig, CohereRequest};
@@ -6,7 +8,6 @@ use crate::ocr::OcrClient;
 use crate::ocr::document::{inline_remote_document, validate_inline_document};
 use crate::ocr::types::{LiteLLMOcrResponse, OcrDocument, PreparedOcrRequest};
 use crate::url_utils::ApiUrl;
-use serde_json::Value;
 
 #[derive(Default)]
 pub(crate) struct AzureAICohereParseConfig;

litellm-rust/crates/core/src/llms/azure_ai/ocr/common_utils.rs

@@ -1,9 +1,10 @@
 use std::sync::OnceLock;
 
-use crate::ocr::types::OcrConnection;
 use litellm_auth::{InputSource, Sourced};
 use litellm_auth_azure::{AzureAuthInputs, AzureAuthService};
 
+use crate::ocr::types::OcrConnection;
+
 pub(super) async fn resolve_entra(
     config: &AzureAuthInputs,
     env_lookup: &(dyn Fn(&str) -> Option<String> + Sync),

litellm-rust/crates/core/src/llms/azure_ai/ocr/document_intelligence/transformation.rs

@@ -3,15 +3,14 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use base64::{Engine, engine::general_purpose::STANDARD};
+use litellm_auth::{InputSource, Sourced};
+use litellm_auth_azure::AzureAuthInputs;
 use reqwest::Url;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Map, Value};
 use serde_with::serde_as;
 use tokio::time::Instant;
 
-use litellm_auth::{InputSource, Sourced};
-use litellm_auth_azure::AzureAuthInputs;
-
 use crate::call_arguments::CallArguments;
 use crate::constants::{
     AZURE_DI_API_VERSION, AZURE_DI_DEFAULT_DPI, AZURE_DI_DEFAULT_HEIGHT, AZURE_DI_DEFAULT_WIDTH,
@@ -632,10 +631,11 @@ fn nonblank(value: Option<String>) -> Option<String> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use rstest::rstest;
     use serde_json::{Value, json};
 
+    use super::*;
+
     fn map(value: Value) -> Result<DocumentIntelligenceParams, crate::ocr::Error> {
         let arguments = serde_json::from_value(value).unwrap();
         AzureDocumentIntelligenceOCRConfig.map_ocr_params(&arguments, "model")
@@ -1220,9 +1220,10 @@ mod tests {
 
     #[tokio::test]
     async fn pre_call_guardrail_receives_caller_pages_before_mapping() {
-        use crate::ocr::hooks::{OcrHookFuture, OcrHooks, OcrPreCallRequest};
         use std::sync::Arc;
 
+        use crate::ocr::hooks::{OcrHookFuture, OcrHooks, OcrPreCallRequest};
+
         struct RewritePages;
         impl OcrHooks for RewritePages {
             fn intercepts_requests(&self) -> bool {

litellm-rust/crates/core/src/llms/azure_ai/ocr/transformation.rs

@@ -1,3 +1,7 @@
+use litellm_auth::{InputSource, Sourced};
+use litellm_auth_azure::AzureAuthInputs;
+use serde_json::Value;
+
 use crate::call_arguments::CallArguments;
 use crate::constants::AZURE_AI_OCR_PATH;
 use crate::llms::base_llm::ocr::transformation::{BaseOcrConfig, OcrRequestContext};
@@ -8,9 +12,6 @@ use crate::ocr::prepare::credential_env;
 use crate::ocr::types::{LiteLLMOcrResponse, OcrConnection, OcrDocument, PreparedOcrRequest};
 use crate::params::OpaqueParams;
 use crate::url_utils::ApiUrl;
-use litellm_auth::{InputSource, Sourced};
-use litellm_auth_azure::AzureAuthInputs;
-use serde_json::Value;
 
 const AZURE_AI_API_KEY_ENV: &str = "AZURE_AI_API_KEY";
 const AZURE_AI_API_BASE_ENV: &str = "AZURE_AI_API_BASE";

litellm-rust/crates/core/src/llms/cohere/ocr/transformation.rs

@@ -344,9 +344,10 @@ fn invalid_api_base() -> crate::ocr::Error {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     #[tokio::test]
     async fn composed_body_preserves_native_document_fields_and_untyped_overrides() {
         let request = crate::ocr::test_support::wire_request(

litellm-rust/crates/core/src/llms/mistral/ocr/transformation.rs

@@ -202,10 +202,11 @@ impl MistralOCRConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use rstest::rstest;
     use serde_json::{Value, json};
 
+    use super::*;
+
     #[test]
     fn explicit_null_model_does_not_use_the_missing_model_default() {
         let response = serde_json::from_value(json!({"model":null})).unwrap();

litellm-rust/crates/core/src/llms/vertex_ai/ocr/common_utils.rs

@@ -1,6 +1,7 @@
-use crate::ocr::types::OcrConnection;
 use litellm_auth::InputSource;
 
+use crate::ocr::types::OcrConnection;
+
 pub(super) fn validate_destination(connection: &OcrConnection) -> Result<(), crate::ocr::Error> {
     if connection.api_base.is_some() && connection.api_base_source == InputSource::Request {
         return Err(litellm_auth::Error::RequestVertexCredentialDestination.into());

litellm-rust/crates/core/src/llms/vertex_ai/ocr/deepseek_transformation.rs

@@ -1,8 +1,7 @@
+use litellm_auth_gcp::{self as vertex, VertexConfig};
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
-use litellm_auth_gcp::{self as vertex, VertexConfig};
-
 use super::transformation::VertexAIOCRConfig;
 use crate::call_arguments::CallArguments;
 use crate::llms::base_llm::ocr::transformation::{BaseOcrConfig, OcrRequestContext};
@@ -410,17 +409,19 @@ impl VertexAIDeepSeekOCRConfig {
 
 #[cfg(test)]
 mod tests {
+    use serde_json::{Value, json};
+
     use super::{
         DeepSeekOcrParams, DeepSeekOcrResponse, VertexAIDeepSeekOCRConfig, normalize_response,
         provider_model,
     };
-    use serde_json::{Value, json};
 
     #[test]
     fn unconsumed_options_remain_available_for_body_composition() {
-        use crate::llms::base_llm::ocr::transformation::BaseOcrConfig;
         use serde_json::json;
 
+        use crate::llms::base_llm::ocr::transformation::BaseOcrConfig;
+
         let arguments =
             serde_json::from_value(json!({"temperature":0.5,"extension":null})).unwrap();
         assert_eq!(
@@ -615,9 +616,10 @@ mod tests {
         }
     }
 
-    use crate::ocr::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
     use litellm_auth::InputSource;
 
+    use crate::ocr::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
+
     fn request_body(request: &str) -> Value {
         serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()
     }

litellm-rust/crates/core/src/llms/vertex_ai/ocr/transformation.rs

@@ -215,10 +215,10 @@ mod tests {
         );
     }
 
+    use litellm_auth::InputSource;
     use serde_json::{Value, json};
 
     use crate::ocr::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
-    use litellm_auth::InputSource;
 
     fn request_body(request: &str) -> Value {
         serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()

litellm-rust/crates/core/src/media.rs

@@ -279,11 +279,13 @@ impl Resolve for PublicDnsResolver {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::collections::HashSet;
+
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::net::TcpListener;
 
+    use super::*;
+
     async fn serve(response: &'static [u8]) -> (Url, tokio::task::JoinHandle<()>) {
         let listener = TcpListener::bind("127.0.0.1:0")
             .await

litellm-rust/crates/core/src/messages/common_utils.rs

@@ -1,12 +1,11 @@
-use super::Error;
-use crate::http_utils::string_headers as shared_string_headers;
-use crate::providers::anthropic::messages::transformation::ANTHROPIC_MESSAGES_CONFIG;
-use crate::providers::azure_ai::messages::transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG;
 use serde_json::{Map, Value};
 
+use super::Error;
 use super::transformation::AnthropicMessagesProviderConfig;
-
+use crate::http_utils::string_headers as shared_string_headers;
 pub(super) use crate::http_utils::{has_bearer_auth, has_header, truncate_error_body};
+use crate::providers::anthropic::messages::transformation::ANTHROPIC_MESSAGES_CONFIG;
+use crate::providers::azure_ai::messages::transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG;
 
 const HEADER_CONTEXT: &str = "messages";
 

litellm-rust/crates/core/src/messages/handler.rs

@@ -1,11 +1,10 @@
 use super::Error;
-use crate::constants::ANTHROPIC_MESSAGES_PROVIDER;
-use crate::http_utils::http_request;
-
 use super::client::http_client;
 use super::common_utils::truncate_error_body;
 use super::prepare::prepare_provider_request;
 use super::types::{AnthropicMessagesResponse, MessagesRequest};
+use crate::constants::ANTHROPIC_MESSAGES_PROVIDER;
+use crate::http_utils::http_request;
 
 pub(super) async fn execute_messages_provider_call(
     request: MessagesRequest<'_>,

litellm-rust/crates/core/src/messages/prepare.rs

@@ -1,10 +1,10 @@
-use super::Error;
-use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
+use serde_json::{Map, Value};
 
+use super::Error;
 use super::common_utils::{has_bearer_auth, has_header, messages_provider_config, string_headers};
 use super::transformation::{AnthropicMessagesProviderConfig, MessagesAuthStrategy};
 use super::types::{MessagesRequest, ProviderMessagesRequest};
-use serde_json::{Map, Value};
+use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
 
 pub(super) fn prepare_provider_request(
     request: MessagesRequest<'_>,

litellm-rust/crates/core/src/messages/tests.rs

@@ -5,7 +5,6 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
 
 use super::Error;
-
 use super::common_utils::{
     has_bearer_auth, has_header, messages_provider_config, string_headers, truncate_error_body,
 };

litellm-rust/crates/core/src/ocr/arguments.rs

@@ -1,6 +1,5 @@
-use crate::call_arguments::ArgumentSpec;
-
 use super::provider_config::{OcrConfigKind, resolve_provider_config};
+use crate::call_arguments::ArgumentSpec;
 
 const COMMON_OPTION_FIELDS: &[&str] = &["req_format", "extra_body", "max_response_bytes"];
 const AZURE_AUTH_OPTION_FIELDS: &[&str] = &[

litellm-rust/crates/core/src/ocr/client.rs

@@ -2,13 +2,13 @@ use std::sync::OnceLock;
 use std::time::Duration;
 
 use bytes::{Bytes, BytesMut};
+use litellm_auth_gcp::VertexAuth;
 use serde::de::DeserializeOwned;
 
 use super::json::{DecodedOcrResponse, decode_response};
 use super::types::{LiteLLMOcrRequest, LiteLLMOcrResponse};
 use crate::constants::OCR_CONNECT_TIMEOUT_SECS;
 use crate::media::MediaFetcher;
-use litellm_auth_gcp::VertexAuth;
 
 #[derive(Clone)]
 pub struct OcrClient {

litellm-rust/crates/core/src/ocr/document.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeMap as Map;
 use std::io::Read;
 use std::path::Path;
 
@@ -5,7 +6,6 @@ use base64::{Engine, engine::general_purpose::STANDARD};
 use data_url::mime::Mime;
 use data_url::{DataUrl, DataUrlError, forgiving_base64::DecodeError};
 use reqwest::Url;
-use std::collections::BTreeMap as Map;
 
 use super::Error as OcrError;
 use super::Error as OcrRequestError;
@@ -216,9 +216,10 @@ fn map_media_error(error: MediaError) -> OcrError {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::collections::BTreeMap as Map;
 
+    use super::*;
+
     fn document(source: &str) -> OcrDocument {
         OcrDocument::DocumentUrl {
             document_url: source.into(),

litellm-rust/crates/core/src/ocr/hooks.rs

@@ -2,11 +2,12 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
+use serde::Serialize;
+use serde_json::Value;
+
 use super::types::{LiteLLMOcrRequest, LiteLLMOcrResponse, OcrDocument, ResolvedOcrRequest};
 use crate::call_lifecycle::{CallLifecycleContext, CallLifecycleHooks, CallLifecycleTiming};
 use crate::ocr::Error;
-use serde::Serialize;
-use serde_json::Value;
 
 pub type OcrHookFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'a>>;
 pub type OcrLogFuture<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;

litellm-rust/crates/core/src/ocr/lifecycle.rs

@@ -2,6 +2,8 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
+use litellm_auth::Error as AuthError;
+use litellm_auth::{ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
 use tokio::sync::{mpsc, oneshot};
 
 use super::handler::perform_ocr_request;
@@ -16,8 +18,6 @@ use crate::call_lifecycle::host::{
 };
 use crate::call_lifecycle::{CallLifecycleContext, CallLifecycleTiming};
 use crate::ocr::Error;
-use litellm_auth::Error as AuthError;
-use litellm_auth::{ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
 
 pub type NativeResult<T> = Result<NativeOutcome<T>, Error>;
 

litellm-rust/crates/core/src/ocr/prepare.rs

@@ -165,9 +165,10 @@ pub(crate) fn prepare_request(request: ResolvedOcrRequest) -> PreparedOcrRequest
 
 #[cfg(test)]
 mod tests {
-    use crate::call_arguments::{CallArguments, compose_body, parse_options};
     use serde_json::json;
 
+    use crate::call_arguments::{CallArguments, compose_body, parse_options};
+
     #[derive(serde::Deserialize)]
     struct KnownParams {
         pages: Option<Vec<i64>>,

litellm-rust/crates/core/src/ocr/provider_config.rs

@@ -1,3 +1,5 @@
+use strum::{EnumString, IntoStaticStr};
+
 use super::OcrClient;
 use super::types::{
     LiteLLMOcrResponse, OcrCredentialInputs, OcrDocument, PreparedOcrRequest,
@@ -13,7 +15,6 @@ use crate::llms::reducto::ocr::transformation::{ReductoParseLegacyConfig, Reduct
 use crate::llms::vertex_ai::ocr::deepseek_transformation::VertexAIDeepSeekOCRConfig;
 use crate::llms::vertex_ai::ocr::transformation::VertexAIOCRConfig;
 use crate::providers::custom_llm_provider::{CustomLlmProvider, get_custom_llm_provider};
-use strum::{EnumString, IntoStaticStr};
 
 macro_rules! dispatch_config {
     ($config:expr, $method:ident($($argument:expr),* $(,)?)) => {
@@ -185,10 +186,11 @@ fn is_document_intelligence_model(model: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use litellm_auth::{InputSource, Sourced};
     use rstest::rstest;
 
+    use super::*;
+
     #[rstest]
     #[case("cohere")]
     #[case("mistral")]

litellm-rust/crates/core/src/ocr/types.rs

@@ -4,12 +4,11 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use bytes::Bytes;
+use litellm_auth::{InputSource, Sourced, TokenProviderHandle};
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use serde_with::serde_as;
 
-use litellm_auth::{InputSource, Sourced, TokenProviderHandle};
-
 use super::hooks::{NoopOcrHooks, OcrHooks};
 use super::provider_config::{OcrConfigKind, resolve_provider_config};
 use crate::call_arguments::CallArguments;
@@ -583,9 +582,10 @@ fn ocr_object() -> String {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     fn document() -> OcrDocument {
         OcrDocument::try_from(
             json!({"type":"document_url","document_url":"data:application/pdf;base64,YWJj"}),

litellm-rust/crates/core/src/providers/anthropic/chat_completions/tests.rs

@@ -1,6 +1,7 @@
+use serde_json::json;
+
 use super::*;
 use crate::chat_completions::Error;
-use serde_json::json;
 
 fn messages(value: Value) -> Vec<ChatMessage> {
     serde_json::from_value(value).expect("valid messages")

litellm-rust/crates/core/src/providers/anthropic/chat_completions/transformation.rs

@@ -2,6 +2,7 @@ use serde_json::{Map, Value, json};
 
 use crate::chat_completions::Error;
 use crate::chat_completions::conversation::{Conversation, build_conversation};
+use crate::chat_completions::response_utils::{finish_reason_for, unix_now, usage_from_parts};
 use crate::chat_completions::transformation::{
     ChatCompletionsAuth, ChatCompletionsProviderConfig, Unsupported, unsupported_message,
     unsupported_param,
@@ -15,8 +16,6 @@ use crate::providers::anthropic::messages::transformation::{
     complete_anthropic_url, resolve_anthropic_api_key,
 };
 
-use crate::chat_completions::response_utils::{finish_reason_for, unix_now, usage_from_parts};
-
 /// Anthropic parameter names, post `map_openai_params`, that the Rust path can
 /// place verbatim in the Messages body.
 ///

litellm-rust/crates/core/src/providers/azure_ai/messages/transformation.rs

@@ -1,3 +1,5 @@
+use serde_json::{Map, Value};
+
 use crate::messages::Error;
 use crate::messages::transformation::{AnthropicMessagesProviderConfig, MessagesAuthStrategy};
 use crate::messages::types::{
@@ -7,7 +9,6 @@ use crate::messages::types::{
 use crate::providers::anthropic::messages::transformation::{
     ANTHROPIC_MESSAGES_CONFIG, AnthropicMessagesConfig, non_empty,
 };
-use serde_json::{Map, Value};
 
 const AZURE_API_KEY_ENV: &str = "AZURE_API_KEY";
 const AZURE_API_BASE_ENV: &str = "AZURE_API_BASE";
@@ -191,9 +192,10 @@ impl AnthropicMessagesProviderConfig for AzureAnthropicMessagesConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use super::*;
+
     fn request_from(value: serde_json::Value) -> AnthropicMessagesRequest {
         serde_json::from_value(value).expect("valid request")
     }

litellm-rust/crates/core/src/providers/bedrock/audio_transcription.rs

@@ -1,5 +1,7 @@
 use serde_json::{Map, Value, json};
 
+pub use super::aws_base::{aws_auth_config, bedrock_model_id_and_region, resolve_bedrock_region};
+use super::constants::{BEDROCK_RUNTIME_ENDPOINT_TEMPLATE, BEDROCK_SERVICE};
 use crate::audio_transcription::Error;
 use crate::audio_transcription::transformation::{
     AudioTranscriptionAuth, AudioTranscriptionProviderConfig,
@@ -9,9 +11,6 @@ use crate::audio_transcription::types::{
 };
 use crate::http_utils::json_type_name;
 
-pub use super::aws_base::{aws_auth_config, bedrock_model_id_and_region, resolve_bedrock_region};
-use super::constants::{BEDROCK_RUNTIME_ENDPOINT_TEMPLATE, BEDROCK_SERVICE};
-
 const SUPPORTED_PARAMS: &[&str] = &["language", "prompt", "temperature", "response_format"];
 
 pub static BEDROCK_AUDIO_TRANSCRIPTION_CONFIG: BedrockAudioTranscriptionConfig =

litellm-rust/crates/core/src/providers/bedrock/chat_completions/tests.rs

@@ -1,6 +1,7 @@
+use serde_json::json;
+
 use super::*;
 use crate::chat_completions::Error;
-use serde_json::json;
 
 fn messages(value: Value) -> Vec<ChatMessage> {
     serde_json::from_value(value).expect("valid messages")

litellm-rust/crates/core/src/providers/bedrock/chat_completions/transformation.rs

@@ -1,5 +1,7 @@
 use serde_json::{Map, Value, json};
 
+use super::super::aws_base::{bedrock_model_id_and_region, resolve_bedrock_region};
+use super::super::constants::{AWS_BEARER_TOKEN_BEDROCK, BEDROCK_RUNTIME_ENDPOINT_TEMPLATE};
 use crate::chat_completions::Error;
 use crate::chat_completions::conversation::{Conversation, TurnRole, build_conversation};
 use crate::chat_completions::response_utils::{finish_reason_for, unix_now, usage_from_parts};
@@ -13,9 +15,6 @@ use crate::chat_completions::types::{
     ProviderChatResponseData,
 };
 
-use super::super::aws_base::{bedrock_model_id_and_region, resolve_bedrock_region};
-use super::super::constants::{AWS_BEARER_TOKEN_BEDROCK, BEDROCK_RUNTIME_ENDPOINT_TEMPLATE};
-
 /// Converse parameter names, post `map_openai_params`, that the Rust path can
 /// place verbatim in `inferenceConfig`.
 ///

litellm-rust/crates/core/src/serde_compat.rs

@@ -66,11 +66,12 @@ fn integral_float(value: f64) -> Option<i64> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde::Serialize;
     use serde_json::json;
     use serde_with::serde_as;
 
+    use super::*;
+
     #[serde_as]
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct Numbers {

litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs

@@ -1,6 +1,7 @@
-use serde_json::{Value, json};
 use std::sync::{Arc, Mutex};
 
+use serde_json::{Value, json};
+
 use super::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
 use super::wire::{OcrWireRequest, decode_request};
 
@@ -421,9 +422,10 @@ async fn model_id_is_encoded_and_dot_segments_are_rejected() {
 
 #[tokio::test]
 async fn pre_call_guardrail_receives_caller_pages_before_mapping() {
-    use crate::ocr::hooks::{OcrHookFuture, OcrHooks, OcrPreCallRequest};
     use std::sync::Arc;
 
+    use crate::ocr::hooks::{OcrHookFuture, OcrHooks, OcrPreCallRequest};
+
     struct RewritePages;
     impl OcrHooks for RewritePages {
         fn intercepts_requests(&self) -> bool {

litellm-rust/crates/core/tests/ocr.rs

@@ -906,11 +906,12 @@ impl litellm_auth::TokenProvider for PendingToken {
 
 #[tokio::test]
 async fn cancellation_waits_for_provider_capture_drop_even_when_acknowledgement_is_cancelled() {
-    use crate::call_lifecycle::host::HostFailure;
     use std::future::Future;
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::task::Poll;
 
+    use crate::call_lifecycle::host::HostFailure;
+
     for interrupt_acknowledgement in [false, true] {
         let entered = Arc::new(tokio::sync::Notify::new());
         let dropped = Arc::new(AtomicBool::new(false));

litellm-rust/crates/core/tests/vertex_ai_deepseek_ocr.rs

@@ -1,7 +1,7 @@
+use litellm_auth::InputSource;
 use serde_json::{Value, json};
 
 use super::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
-use litellm_auth::InputSource;
 
 fn request_body(request: &str) -> Value {
     serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()

litellm-rust/crates/core/tests/vertex_ai_ocr.rs

@@ -1,7 +1,7 @@
+use litellm_auth::InputSource;
 use serde_json::{Value, json};
 
 use super::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
-use litellm_auth::InputSource;
 
 fn request_body(request: &str) -> Value {
     serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()