diff --git a/crates/_types/enums/src/by_table/generic_inference_jobs/inference_category.rs b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_category.rs index ae69d46548..ed6e0cdf0b 100644 --- a/crates/_types/enums/src/by_table/generic_inference_jobs/inference_category.rs +++ b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_category.rs @@ -6,7 +6,7 @@ use strum::EnumCount; use strum::EnumIter; -/// Used in the `generic_inference_jobs` table in a `VARCHAR(32)` field. +/// Used in the `generic_inference_jobs` table in `VARCHAR(32)` field `inference_category`. /// /// Our "generic inference" pipeline supports a wide variety of ML models and other media. /// Each "category" of inference is identified by the following enum variants. @@ -17,11 +17,9 @@ use strum::EnumIter; #[derive(Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Deserialize, Serialize)] pub enum InferenceCategory { #[serde(rename = "text_to_speech")] - //#[sqlx(rename = "text_to_speech")] TextToSpeech, #[serde(rename = "voice_conversion")] - //#[sqlx(rename = "voice_conversion")] VoiceConversion, } diff --git a/crates/_types/enums/src/by_table/generic_inference_jobs/inference_model_type.rs b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_model_type.rs new file mode 100644 index 0000000000..56f4bae83e --- /dev/null +++ b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_model_type.rs @@ -0,0 +1,95 @@ +use std::collections::BTreeSet; + +#[cfg(test)] +use strum::EnumCount; +#[cfg(test)] +use strum::EnumIter; + + +/// Used in the `generic_inference_jobs` table in `VARCHAR(32)` field `maybe_model_type`. +/// +/// Our "generic inference" pipeline supports a wide variety of ML models and other media. +/// Each inference "model type" identified by the following enum variants, though some pipelines +/// may use multiple models or no model (and may report NULL). +/// +/// These types are present in the HTTP API and database columns as serialized here. +/// +/// DO NOT CHANGE VALUES WITHOUT A MIGRATION STRATEGY. +#[cfg_attr(test, derive(EnumIter, EnumCount))] +#[derive(Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Deserialize, Serialize)] +pub enum InferenceModelType { + #[serde(rename = "tacotron2")] + Tacotron2, + + #[serde(rename = "vits")] + Vits, +} + +// TODO(bt, 2022-12-21): This desperately needs MySQL integration tests! +impl_enum_display_and_debug_using_to_str!(InferenceModelType); +impl_mysql_enum_coders!(InferenceModelType); + +/// NB: Legacy API for older code. +impl InferenceModelType { + pub fn to_str(&self) -> &'static str { + match self { + Self::Tacotron2 => "tacotron2", + Self::Vits => "vits", + } + } + + pub fn from_str(value: &str) -> Result { + match value { + "tacotron2" => Ok(Self::Tacotron2), + "vits" => Ok(Self::Vits), + _ => Err(format!("invalid value: {:?}", value)), + } + } + + pub fn all_variants() -> BTreeSet { + // NB: BTreeSet is sorted + // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc. + BTreeSet::from([ + InferenceModelType::Tacotron2, + InferenceModelType::Vits, + ]) + } +} + +#[cfg(test)] +mod tests { + use crate::by_table::generic_inference_jobs::inference_model_type::InferenceModelType; + use crate::test_helpers::assert_serialization; + + #[test] + fn test_serialization() { + assert_serialization(InferenceModelType::Tacotron2, "tacotron2"); + assert_serialization(InferenceModelType::Vits, "vits"); + } + + #[test] + fn to_str() { + assert_eq!(InferenceModelType::Tacotron2.to_str(), "tacotron2"); + assert_eq!(InferenceModelType::Vits.to_str(), "vits"); + } + + #[test] + fn from_str() { + assert_eq!(InferenceModelType::from_str("tacotron2").unwrap(), InferenceModelType::Tacotron2); + assert_eq!(InferenceModelType::from_str("vits").unwrap(), InferenceModelType::Vits); + } + + #[test] + fn all_variants() { + // Static check + let mut variants = InferenceModelType::all_variants(); + assert_eq!(variants.len(), 2); + assert_eq!(variants.pop_first(), Some(InferenceModelType::Tacotron2)); + assert_eq!(variants.pop_first(), Some(InferenceModelType::Vits)); + assert_eq!(variants.pop_first(), None); + + // Generated check + use strum::IntoEnumIterator; + assert_eq!(InferenceModelType::all_variants().len(), InferenceModelType::iter().len()); + } +} diff --git a/crates/_types/enums/src/by_table/generic_inference_jobs/inference_result_type.rs b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_result_type.rs new file mode 100644 index 0000000000..6f2a9244e8 --- /dev/null +++ b/crates/_types/enums/src/by_table/generic_inference_jobs/inference_result_type.rs @@ -0,0 +1,94 @@ +use std::collections::BTreeSet; + +#[cfg(test)] +use strum::EnumCount; +#[cfg(test)] +use strum::EnumIter; + + +/// Used in the `generic_inference_jobs` table in `VARCHAR(32)` field `on_success_result_entity_type`. +/// +/// Our "generic inference" pipeline supports a wide variety of output types. +/// Each "result type" is identified by the following enum variants. +/// +/// These types are present in the HTTP API and database columns as serialized here. +/// +/// DO NOT CHANGE VALUES WITHOUT A MIGRATION STRATEGY. +#[cfg_attr(test, derive(EnumIter, EnumCount))] +#[derive(Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Deserialize, Serialize)] +pub enum InferenceResultType { + #[serde(rename = "text_to_speech")] + TextToSpeech, + + #[serde(rename = "voice_conversion")] + VoiceConversion, +} + +// TODO(bt, 2022-12-21): This desperately needs MySQL integration tests! +impl_enum_display_and_debug_using_to_str!(InferenceResultType); +impl_mysql_enum_coders!(InferenceResultType); + +/// NB: Legacy API for older code. +impl InferenceResultType { + pub fn to_str(&self) -> &'static str { + match self { + Self::TextToSpeech => "text_to_speech", + Self::VoiceConversion => "voice_conversion", + } + } + + pub fn from_str(value: &str) -> Result { + match value { + "text_to_speech" => Ok(Self::TextToSpeech), + "voice_conversion" => Ok(Self::VoiceConversion), + _ => Err(format!("invalid value: {:?}", value)), + } + } + + pub fn all_variants() -> BTreeSet { + // NB: BTreeSet is sorted + // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc. + BTreeSet::from([ + InferenceResultType::TextToSpeech, + InferenceResultType::VoiceConversion, + ]) + } +} + +#[cfg(test)] +mod tests { + use crate::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; + use crate::test_helpers::assert_serialization; + + #[test] + fn test_serialization() { + assert_serialization(InferenceResultType::TextToSpeech, "text_to_speech"); + assert_serialization(InferenceResultType::VoiceConversion, "voice_conversion"); + } + + #[test] + fn to_str() { + assert_eq!(InferenceResultType::TextToSpeech.to_str(), "text_to_speech"); + assert_eq!(InferenceResultType::VoiceConversion.to_str(), "voice_conversion"); + } + + #[test] + fn from_str() { + assert_eq!(InferenceResultType::from_str("text_to_speech").unwrap(), InferenceResultType::TextToSpeech); + assert_eq!(InferenceResultType::from_str("voice_conversion").unwrap(), InferenceResultType::VoiceConversion); + } + + #[test] + fn all_variants() { + // Static check + let mut variants = InferenceResultType::all_variants(); + assert_eq!(variants.len(), 2); + assert_eq!(variants.pop_first(), Some(InferenceResultType::TextToSpeech)); + assert_eq!(variants.pop_first(), Some(InferenceResultType::VoiceConversion)); + assert_eq!(variants.pop_first(), None); + + // Generated check + use strum::IntoEnumIterator; + assert_eq!(InferenceResultType::all_variants().len(), InferenceResultType::iter().len()); + } +} diff --git a/crates/_types/enums/src/by_table/generic_inference_jobs/mod.rs b/crates/_types/enums/src/by_table/generic_inference_jobs/mod.rs index b236c3f8c0..a18aabd692 100644 --- a/crates/_types/enums/src/by_table/generic_inference_jobs/mod.rs +++ b/crates/_types/enums/src/by_table/generic_inference_jobs/mod.rs @@ -1 +1,3 @@ pub mod inference_category; +pub mod inference_model_type; +pub mod inference_result_type; diff --git a/crates/lib/mysql_queries/src/queries/generic_inference/job/mark_generic_inference_job_successfully_done.rs b/crates/lib/mysql_queries/src/queries/generic_inference/job/mark_generic_inference_job_successfully_done.rs index e8dfb01e3a..5880d8e6e5 100644 --- a/crates/lib/mysql_queries/src/queries/generic_inference/job/mark_generic_inference_job_successfully_done.rs +++ b/crates/lib/mysql_queries/src/queries/generic_inference/job/mark_generic_inference_job_successfully_done.rs @@ -1,12 +1,13 @@ use anyhow::anyhow; -use errors::AnyhowResult; use crate::queries::generic_inference::job::list_available_generic_inference_jobs::AvailableInferenceJob; +use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; +use errors::AnyhowResult; use sqlx::MySqlPool; pub async fn mark_generic_inference_job_successfully_done( pool: &MySqlPool, job: &AvailableInferenceJob, - maybe_entity_type: Option<&str>, + maybe_entity_type: Option, maybe_entity_token: Option<&str>, ) -> AnyhowResult<()> { diff --git a/crates/service/job/inference_job/src/job/job_loop/job_success_result.rs b/crates/service/job/inference_job/src/job/job_loop/job_success_result.rs new file mode 100644 index 0000000000..46c63bbaa5 --- /dev/null +++ b/crates/service/job/inference_job/src/job/job_loop/job_success_result.rs @@ -0,0 +1,10 @@ +use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; + +pub struct JobSuccessResult { + pub maybe_result_entity: Option, +} + +pub struct ResultEntity { + pub entity_type: InferenceResultType, + pub entity_token: String, +} diff --git a/crates/service/job/inference_job/src/job/job_loop/mod.rs b/crates/service/job/inference_job/src/job/job_loop/mod.rs index ae5330c16f..e4503aa92b 100644 --- a/crates/service/job/inference_job/src/job/job_loop/mod.rs +++ b/crates/service/job/inference_job/src/job/job_loop/mod.rs @@ -1,4 +1,5 @@ pub mod job_stats; +pub mod job_success_result; pub mod main_loop; pub mod process_single_job; -pub mod process_single_job_error; +pub mod process_single_job_error; \ No newline at end of file diff --git a/crates/service/job/inference_job/src/job/job_loop/process_single_job.rs b/crates/service/job/inference_job/src/job/job_loop/process_single_job.rs index 5502503793..0a11f17dfb 100644 --- a/crates/service/job/inference_job/src/job/job_loop/process_single_job.rs +++ b/crates/service/job/inference_job/src/job/job_loop/process_single_job.rs @@ -6,9 +6,11 @@ use crate::job_dependencies::JobDependencies; use enums::by_table::generic_inference_jobs::inference_category::InferenceCategory; use errors::AnyhowResult; use log::{info, warn}; +use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; use mysql_queries::queries::generic_inference::job::list_available_generic_inference_jobs::AvailableInferenceJob; use mysql_queries::queries::generic_inference::job::mark_generic_inference_job_pending_and_grab_lock::mark_generic_inference_job_pending_and_grab_lock; use mysql_queries::queries::generic_inference::job::mark_generic_inference_job_successfully_done::mark_generic_inference_job_successfully_done; +use crate::job::job_loop::job_success_result::ResultEntity; pub async fn process_single_job(job_dependencies: &JobDependencies, job: &AvailableInferenceJob) -> Result<(), ProcessSingleJobError> { // TODO(bt, 2023-01-11): Restore an optional status logger @@ -38,75 +40,34 @@ pub async fn process_single_job(job_dependencies: &JobDependencies, job: &Availa // ==================== HANDLE DIFFERENT INFERENCE TYPES ==================== // - let mut entity_token : Option = None; - let mut entity_type : Option = None; + let mut maybe_result_entity : Option; - match job.inference_category { + let job_success_result = match job.inference_category { InferenceCategory::TextToSpeech => { - // TODO - entity_type = Some("todo".to_string()); // TODO - entity_token = Some("todo".to_string()); // TODO - - let _r = process_single_tts_job(job_dependencies, job).await?; + process_single_tts_job(job_dependencies, job).await? } InferenceCategory::VoiceConversion => { - // TODO - let _r = process_single_vc_job(job_dependencies, job).await?; + process_single_vc_job(job_dependencies, job).await? } -// GenericDownloadType::HifiGan => { -// let results = process_hifigan_vocoder( -// job_state, -// job, -// &temp_dir, -// &download_filename, -// &mut redis_logger, -// ).await?; -// entity_token = results.entity_token.clone(); -// entity_type = results.entity_type.clone(); -// } -// GenericDownloadType::HifiGanRocketVc => { -// let results = process_hifigan_softvc_vocoder( -// job_state, -// job, -// &temp_dir, -// &download_filename, -// &mut redis_logger, -// ).await?; -// entity_token = results.entity_token.clone(); -// entity_type = results.entity_type.clone(); -// } -// GenericDownloadType::RocketVc => { -// let results = process_softvc_model( -// job_state, -// job, -// &temp_dir, -// &download_filename, -// &mut redis_logger, -// ).await?; -// entity_token = results.entity_token.clone(); -// entity_type = results.entity_type.clone(); -// } -// GenericDownloadType::Tacotron2 => { -// let results = process_tacotron_model( -// job_state, -// job, -// &temp_dir, -// &download_filename, -// &mut redis_logger, -// ).await?; -// entity_token = results.entity_token.clone(); -// entity_type = results.entity_type.clone(); -// } - } + }; + + let maybe_entity_type = job_success_result.maybe_result_entity + .as_ref() + .map(|result_entity| result_entity.entity_type); + + let maybe_entity_token = job_success_result.maybe_result_entity + .as_ref() + .map(|result_entity| result_entity.entity_token.as_str()); // ===================================================== info!("Marking job complete..."); + mark_generic_inference_job_successfully_done( &job_dependencies.mysql_pool, job, - entity_type.as_deref(), - entity_token.as_deref(), + maybe_entity_type, + maybe_entity_token, ).await .map_err(|err| ProcessSingleJobError::Other(anyhow!("database error: {:?}", err)))?; diff --git a/crates/service/job/inference_job/src/job/job_types/tts/process_single_tts_job.rs b/crates/service/job/inference_job/src/job/job_types/tts/process_single_tts_job.rs index f3ddd1c271..c4ee696a84 100644 --- a/crates/service/job/inference_job/src/job/job_types/tts/process_single_tts_job.rs +++ b/crates/service/job/inference_job/src/job/job_types/tts/process_single_tts_job.rs @@ -9,8 +9,9 @@ use errors::AnyhowResult; use mysql_queries::queries::generic_inference::job::list_available_generic_inference_jobs::AvailableInferenceJob; use mysql_queries::queries::tts::tts_models::get_tts_model_for_inference_improved::{get_tts_model_for_inference_improved, TtsModelForInferenceRecord}; use tokens::tokens::tts_models::TtsModelToken; +use crate::job::job_loop::job_success_result::JobSuccessResult; -pub async fn process_single_tts_job(job_dependencies: &JobDependencies, job: &AvailableInferenceJob) -> Result<(), ProcessSingleJobError> { +pub async fn process_single_tts_job(job_dependencies: &JobDependencies, job: &AvailableInferenceJob) -> Result { let tts_model_token = match job.maybe_model_token.as_deref() { None => return Err(ProcessSingleJobError::Other(anyhow!("no model token on job"))), @@ -60,25 +61,25 @@ pub async fn process_single_tts_job(job_dependencies: &JobDependencies, job: &Av Some(model) => model, }; - match tts_model.tts_model_type { + let job_success_result = match tts_model.tts_model_type { TtsModelType::Tacotron2 => { - let _r = tacotron2_v2_early_fakeyou::process_job::process_job(ProcessJobArgs { + tacotron2_v2_early_fakeyou::process_job::process_job(ProcessJobArgs { job_dependencies, job, tts_model: &tts_model, raw_inference_text, - }).await?; + }).await? } TtsModelType::Vits => { - let _r = vits::process_job::process_job(VitsProcessJobArgs { + vits::process_job::process_job(VitsProcessJobArgs { job_dependencies, job, tts_model: &tts_model, raw_inference_text, - }).await?; + }).await? } - } + }; - Ok(()) + Ok(job_success_result) } diff --git a/crates/service/job/inference_job/src/job/job_types/tts/tacotron2_v2_early_fakeyou/process_job.rs b/crates/service/job/inference_job/src/job/job_types/tts/tacotron2_v2_early_fakeyou/process_job.rs index 226ac1c373..09fbfca6cb 100644 --- a/crates/service/job/inference_job/src/job/job_types/tts/tacotron2_v2_early_fakeyou/process_job.rs +++ b/crates/service/job/inference_job/src/job/job_types/tts/tacotron2_v2_early_fakeyou/process_job.rs @@ -2,6 +2,7 @@ use anyhow::anyhow; use container_common::filesystem::check_file_exists::check_file_exists; use container_common::filesystem::safe_delete_temp_directory::safe_delete_temp_directory; use container_common::filesystem::safe_delete_temp_file::safe_delete_temp_file; +use crate::job::job_loop::job_success_result::{JobSuccessResult, ResultEntity}; use crate::job::job_loop::process_single_job_error::ProcessSingleJobError; use crate::job::job_types::tts::tacotron2_v2_early_fakeyou::seconds_to_decoder_steps::seconds_to_decoder_steps; use crate::job::job_types::tts::tacotron2_v2_early_fakeyou::tacotron2_inference_command::{InferenceArgs, MelMultiplyFactor, Tacotron2InferenceCommand, VocoderForInferenceOption}; @@ -20,6 +21,7 @@ use std::io::Read; use std::path::PathBuf; use subprocess_common::docker_options::{DockerFilesystemMount, DockerGpu, DockerOptions}; use tempdir::TempDir; +use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; use tts_common::clean_symbols::clean_symbols; use tts_common::text_pipelines::guess_pipeline::guess_text_pipeline_heuristic; use tts_common::text_pipelines::text_pipeline_type::TextPipelineType; @@ -36,7 +38,7 @@ pub struct ProcessJobArgs<'a> { pub raw_inference_text: &'a str, } -pub async fn process_job(args: ProcessJobArgs<'_>) -> Result<(), ProcessSingleJobError> { +pub async fn process_job(args: ProcessJobArgs<'_>) -> Result { let job = args.job; let tts_model = args.tts_model; let raw_inference_text = args.raw_inference_text; @@ -390,7 +392,12 @@ pub async fn process_job(args: ProcessJobArgs<'_>) -> Result<(), ProcessSingleJo info!("Job {:?} complete success! Downloaded, ran inference, and uploaded. Saved model record: {}, Result Token: {}", job.id, id, &inference_result_token); - Ok(()) + Ok(JobSuccessResult { + maybe_result_entity: Some(ResultEntity { + entity_type: InferenceResultType::TextToSpeech, + entity_token: inference_result_token + }), + }) } #[derive(Deserialize, Default)] diff --git a/crates/service/job/inference_job/src/job/job_types/tts/vits/process_job.rs b/crates/service/job/inference_job/src/job/job_types/tts/vits/process_job.rs index 371f26ec6d..e2a20e0650 100644 --- a/crates/service/job/inference_job/src/job/job_types/tts/vits/process_job.rs +++ b/crates/service/job/inference_job/src/job/job_types/tts/vits/process_job.rs @@ -22,9 +22,11 @@ use std::io::Read; use std::path::{Path, PathBuf}; use subprocess_common::docker_options::{DockerFilesystemMount, DockerGpu, DockerOptions}; use tempdir::TempDir; +use enums::by_table::generic_inference_jobs::inference_result_type::InferenceResultType; use tts_common::clean_symbols::clean_symbols; use tts_common::text_pipelines::guess_pipeline::guess_text_pipeline_heuristic; use tts_common::text_pipelines::text_pipeline_type::TextPipelineType; +use crate::job::job_loop::job_success_result::{JobSuccessResult, ResultEntity}; /// Text starting with this will be treated as a test request. /// This allows the request to bypass the model cache and query the latest TTS model. @@ -38,7 +40,7 @@ pub struct VitsProcessJobArgs<'a> { pub raw_inference_text: &'a str, } -pub async fn process_job(args: VitsProcessJobArgs<'_>) -> Result<(), ProcessSingleJobError> { +pub async fn process_job(args: VitsProcessJobArgs<'_>) -> Result { let job = args.job; let tts_model = args.tts_model; let raw_inference_text = args.raw_inference_text; @@ -245,7 +247,12 @@ pub async fn process_job(args: VitsProcessJobArgs<'_>) -> Result<(), ProcessSing info!("Job {:?} complete success! Downloaded, ran inference, and uploaded. Saved model record: {}, Result Token: {}", job.id, id, &inference_result_token); - Ok(()) + Ok(JobSuccessResult { + maybe_result_entity: Some(ResultEntity { + entity_type: InferenceResultType::TextToSpeech, + entity_token: inference_result_token + }), + }) } #[derive(Deserialize, Default)] diff --git a/crates/service/job/inference_job/src/job/job_types/vc/process_single_vc_job.rs b/crates/service/job/inference_job/src/job/job_types/vc/process_single_vc_job.rs index f99480dfde..7c8eec24cb 100644 --- a/crates/service/job/inference_job/src/job/job_types/vc/process_single_vc_job.rs +++ b/crates/service/job/inference_job/src/job/job_types/vc/process_single_vc_job.rs @@ -2,8 +2,11 @@ use crate::job::job_loop::process_single_job_error::ProcessSingleJobError; use crate::job_dependencies::JobDependencies; use errors::AnyhowResult; use mysql_queries::queries::generic_inference::job::list_available_generic_inference_jobs::AvailableInferenceJob; +use crate::job::job_loop::job_success_result::JobSuccessResult; -pub async fn process_single_vc_job(job_dependencies: &JobDependencies, job: &AvailableInferenceJob) -> Result<(), ProcessSingleJobError> { - Ok(()) +pub async fn process_single_vc_job(job_dependencies: &JobDependencies, job: &AvailableInferenceJob) -> Result { + Ok(JobSuccessResult { + maybe_result_entity: None, + }) } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/inference_job/get_inference_job_status.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/inference_job/get_inference_job_status.rs index 298b0b3234..e0341f9682 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/inference_job/get_inference_job_status.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/inference_job/get_inference_job_status.rs @@ -35,6 +35,12 @@ pub struct GetInferenceJobStatusPathInfo { token: InferenceJobToken, } +#[derive(Serialize)] +pub struct GetInferenceJobStatusSuccessResponse { + pub success: bool, + pub state: InferenceJobStatusResponsePayload, +} + #[derive(Serialize)] pub struct InferenceJobStatusResponsePayload { pub job_token: InferenceJobToken, @@ -49,7 +55,6 @@ pub struct InferenceJobStatusResponsePayload { #[derive(Serialize)] pub struct RequestDetailsResponse { - // TODO: Rename this inference_category (!!!) and add model_type. pub inference_category: InferenceCategory, pub maybe_model_type: Option, pub maybe_model_token: Option, @@ -78,13 +83,7 @@ pub struct ResultDetailsResponse { pub entity_token: String, /// NB: This is only for audio- or video- type results. - pub maybe_public_bucket_wav_media_path: Option, -} - -#[derive(Serialize)] -pub struct GetInferenceJobStatusSuccessResponse { - pub success: bool, - pub state: InferenceJobStatusResponsePayload, + pub maybe_public_bucket_media_path: Option, } #[derive(Debug)] @@ -180,7 +179,7 @@ pub async fn get_inference_job_status_handler( ResultDetailsResponse { entity_type: result_details.entity_type, entity_token: result_details.entity_token, - maybe_public_bucket_wav_media_path: None, // TODO: This will require a new field + maybe_public_bucket_media_path: None, // TODO: This will require a new field } }), created_at: record.created_at,