From 43ec1ae5d70749df7fcdab94a6bbf778bb06424f Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sat, 21 Feb 2026 09:54:41 +0700 Subject: [PATCH] shouldn't be impacting --- .../frontend_failure_category.rs | 14 +++++++++++++- .../generic_inference_jobs/inference_category.rs | 1 + .../inference_job_external_third_party.rs | 14 ++++++++++++-- .../inference_job_product_category.rs | 13 ++++++++++++- .../generic_inference_jobs/inference_job_type.rs | 14 ++++++++++++-- .../media_files/media_file_origin_model_type.rs | 2 +- .../media_file_origin_product_category.rs | 12 +++++++++++- .../public/enums/src/common/job_status_plus.rs | 2 +- .../schema/public/enums/src/common/model_type.rs | 11 ++++++++++- .../enums/src/tauri/tasks/task_model_type.rs | 11 ++++++++++- 10 files changed, 83 insertions(+), 11 deletions(-) diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs index 44d3494651..d47840952f 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/frontend_failure_category.rs @@ -42,6 +42,11 @@ pub enum FrontendFailureCategory { /// exactly what happened. We'll retry their workload in any case. #[serde(rename = "retryable_worker_error")] RetryableWorkerError, + + /// Model content rules were violated + /// Eg. Seedance 2 will report: "your input text violates platform rules. please modify and try again" + #[serde(rename = "model_rules_violation")] + ModelRulesViolation, } // TODO(bt, 2022-12-21): This desperately needs MySQL integration tests! @@ -56,6 +61,7 @@ impl FrontendFailureCategory { Self::KeepAliveElapsed => "keep_alive_elapsed", Self::NotYetImplemented => "not_yet_implemented", Self::RetryableWorkerError => "retryable_worker_error", + Self::ModelRulesViolation => "model_rules_violation", } } @@ -65,6 +71,7 @@ impl FrontendFailureCategory { "keep_alive_elapsed" => Ok(Self::KeepAliveElapsed), "not_yet_implemented" => Ok(Self::NotYetImplemented), "retryable_worker_error" => Ok(Self::RetryableWorkerError), + "model_rules_violation" => Ok(Self::ModelRulesViolation), _ => Err(format!("invalid value: {:?}", value)), } } @@ -77,6 +84,7 @@ impl FrontendFailureCategory { Self::KeepAliveElapsed, Self::NotYetImplemented, Self::RetryableWorkerError, + Self::ModelRulesViolation, ]) } } @@ -95,6 +103,7 @@ mod tests { assert_serialization(FrontendFailureCategory::KeepAliveElapsed, "keep_alive_elapsed"); assert_serialization(FrontendFailureCategory::NotYetImplemented, "not_yet_implemented"); assert_serialization(FrontendFailureCategory::RetryableWorkerError, "retryable_worker_error"); + assert_serialization(FrontendFailureCategory::ModelRulesViolation, "model_rules_violation"); } #[test] @@ -103,6 +112,7 @@ mod tests { assert_eq!(FrontendFailureCategory::KeepAliveElapsed.to_str(), "keep_alive_elapsed"); assert_eq!(FrontendFailureCategory::NotYetImplemented.to_str(), "not_yet_implemented"); assert_eq!(FrontendFailureCategory::RetryableWorkerError.to_str(), "retryable_worker_error"); + assert_eq!(FrontendFailureCategory::ModelRulesViolation.to_str(), "model_rules_violation"); } #[test] @@ -111,16 +121,18 @@ mod tests { assert_eq!(FrontendFailureCategory::from_str("keep_alive_elapsed").unwrap(), FrontendFailureCategory::KeepAliveElapsed); assert_eq!(FrontendFailureCategory::from_str("not_yet_implemented").unwrap(), FrontendFailureCategory::NotYetImplemented); assert_eq!(FrontendFailureCategory::from_str("retryable_worker_error").unwrap(), FrontendFailureCategory::RetryableWorkerError); + assert_eq!(FrontendFailureCategory::from_str("model_rules_violation").unwrap(), FrontendFailureCategory::ModelRulesViolation); } #[test] fn all_variants() { let mut variants = FrontendFailureCategory::all_variants(); - assert_eq!(variants.len(), 4); + assert_eq!(variants.len(), 5); assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::FaceNotDetected)); assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::KeepAliveElapsed)); assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::NotYetImplemented)); assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::RetryableWorkerError)); + assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::ModelRulesViolation)); assert_eq!(variants.pop_first(), None); } } diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_category.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_category.rs index f745a89d7b..517359484a 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_category.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_category.rs @@ -40,6 +40,7 @@ pub enum InferenceCategory { ImageGeneration, /// FAL-powered video generation + /// (Also Seedance2-Pro.com) #[serde(rename = "video_generation")] VideoGeneration, diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs index 8152544585..e0e9dcbc36 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs @@ -16,6 +16,10 @@ pub enum InferenceJobExternalThirdParty { #[serde(rename = "fal")] #[default] Fal, + + /// Seedance 2 Pro jobs + #[serde(rename = "seedance2pro")] + Seedance2Pro, } // TODO(bt, 2022-12-21): This desperately needs MySQL integration tests! @@ -27,12 +31,14 @@ impl InferenceJobExternalThirdParty { pub fn to_str(&self) -> &'static str { match self { Self::Fal => "fal", + Self::Seedance2Pro => "seedance2pro", } } pub fn from_str(value: &str) -> Result { match value { "fal" => Ok(Self::Fal), + "seedance2pro" => Ok(Self::Seedance2Pro), _ => Err(format!("invalid value: {:?}", value)), } } @@ -42,6 +48,7 @@ impl InferenceJobExternalThirdParty { // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc. BTreeSet::from([ Self::Fal, + Self::Seedance2Pro, ]) } } @@ -57,22 +64,25 @@ mod tests { #[test] fn test_serialization() { assert_serialization(InferenceJobExternalThirdParty::Fal, "fal"); + assert_serialization(InferenceJobExternalThirdParty::Seedance2Pro, "seedance2pro"); } #[test] fn to_str() { assert_eq!(InferenceJobExternalThirdParty::Fal.to_str(), "fal"); + assert_eq!(InferenceJobExternalThirdParty::Seedance2Pro.to_str(), "seedance2pro"); } #[test] fn from_str() { assert_eq!(InferenceJobExternalThirdParty::from_str("fal").unwrap(), InferenceJobExternalThirdParty::Fal); + assert_eq!(InferenceJobExternalThirdParty::from_str("seedance2pro").unwrap(), InferenceJobExternalThirdParty::Seedance2Pro); } #[test] fn all_variants() { // Static check - const EXPECTED_COUNT : usize = 1; + const EXPECTED_COUNT : usize = 2; assert_eq!(InferenceJobExternalThirdParty::all_variants().len(), EXPECTED_COUNT); assert_eq!(InferenceJobExternalThirdParty::iter().len(), EXPECTED_COUNT); @@ -103,7 +113,7 @@ mod tests { #[test] fn serialized_length_ok_for_database() { - const MAX_LENGTH : usize = 32; + const MAX_LENGTH : usize = 16; for variant in InferenceJobExternalThirdParty::all_variants() { let serialized = variant.to_str(); assert!(serialized.len() > 0, "variant {:?} is too short", variant); diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_product_category.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_product_category.rs index d7b58ff70e..d4f540ccff 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_product_category.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_product_category.rs @@ -30,6 +30,11 @@ pub enum InferenceJobProductCategory { FalObject, FalBgRemoval, + // =============== SEEDANCE 2 PRO =============== + + #[serde(rename = "seedance2pro_video")] + Seedance2ProVideo, + // =============== TEXT TO SPEECH =============== /// TTS: GptSoVits @@ -125,6 +130,7 @@ impl InferenceJobProductCategory { Self::FalVideo => "fal_video", Self::FalObject => "fal_object", Self::FalBgRemoval => "fal_bg_removal", + Self::Seedance2ProVideo => "seedance2pro_video", Self::TtsGptSoVits => "tts_gpt_so_vits", Self::TtsStyleTts2 => "tts_style_tts2", Self::TtsTacotron2 => "tts_tacotron2", @@ -157,6 +163,7 @@ impl InferenceJobProductCategory { "fal_video" => Ok(Self::FalVideo), "fal_object" => Ok(Self::FalObject), "fal_bg_removal" => Ok(Self::FalBgRemoval), + "seedance2pro_video" => Ok(Self::Seedance2ProVideo), "tts_gpt_so_vits" => Ok(Self::TtsGptSoVits), "tts_style_tts2" => Ok(Self::TtsStyleTts2), "tts_tacotron2" => Ok(Self::TtsTacotron2), @@ -192,6 +199,7 @@ impl InferenceJobProductCategory { Self::FalVideo, Self::FalObject, Self::FalBgRemoval, + Self::Seedance2ProVideo, Self::TtsGptSoVits, Self::TtsStyleTts2, Self::TtsTacotron2, @@ -233,6 +241,7 @@ mod tests { assert_serialization(InferenceJobProductCategory::FalVideo, "fal_video"); assert_serialization(InferenceJobProductCategory::FalObject, "fal_object"); assert_serialization(InferenceJobProductCategory::FalBgRemoval, "fal_bg_removal"); + assert_serialization(InferenceJobProductCategory::Seedance2ProVideo, "seedance2pro_video"); assert_serialization(InferenceJobProductCategory::TtsGptSoVits, "tts_gpt_so_vits"); assert_serialization(InferenceJobProductCategory::TtsStyleTts2, "tts_style_tts2"); assert_serialization(InferenceJobProductCategory::TtsTacotron2, "tts_tacotron2"); @@ -264,6 +273,7 @@ mod tests { assert_eq!(InferenceJobProductCategory::FalVideo.to_str(), "fal_video"); assert_eq!(InferenceJobProductCategory::FalObject.to_str(), "fal_object"); assert_eq!(InferenceJobProductCategory::FalBgRemoval.to_str(), "fal_bg_removal"); + assert_eq!(InferenceJobProductCategory::Seedance2ProVideo.to_str(), "seedance2pro_video"); assert_eq!(InferenceJobProductCategory::TtsGptSoVits.to_str(), "tts_gpt_so_vits"); assert_eq!(InferenceJobProductCategory::TtsStyleTts2.to_str(), "tts_style_tts2"); assert_eq!(InferenceJobProductCategory::TtsTacotron2.to_str(), "tts_tacotron2"); @@ -294,6 +304,7 @@ mod tests { assert_eq!(InferenceJobProductCategory::from_str("fal_video").unwrap(), InferenceJobProductCategory::FalVideo); assert_eq!(InferenceJobProductCategory::from_str("fal_object").unwrap(), InferenceJobProductCategory::FalObject); assert_eq!(InferenceJobProductCategory::from_str("fal_bg_removal").unwrap(), InferenceJobProductCategory::FalBgRemoval); + assert_eq!(InferenceJobProductCategory::from_str("seedance2pro_video").unwrap(), InferenceJobProductCategory::Seedance2ProVideo); assert_eq!(InferenceJobProductCategory::from_str("tts_gpt_so_vits").unwrap(), InferenceJobProductCategory::TtsGptSoVits); assert_eq!(InferenceJobProductCategory::from_str("tts_style_tts2").unwrap(), InferenceJobProductCategory::TtsStyleTts2); assert_eq!(InferenceJobProductCategory::from_str("tts_tacotron2").unwrap(), InferenceJobProductCategory::TtsTacotron2); @@ -320,7 +331,7 @@ mod tests { #[test] fn all_variants() { // Static check - const EXPECTED_COUNT : usize = 27; + const EXPECTED_COUNT : usize = 28; assert_eq!(InferenceJobProductCategory::all_variants().len(), EXPECTED_COUNT); assert_eq!(InferenceJobProductCategory::iter().len(), EXPECTED_COUNT); diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_type.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_type.rs index 8dfcff795c..09c7b00d67 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_type.rs +++ b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_type.rs @@ -18,7 +18,11 @@ pub enum InferenceJobType { /// Fal jobs do not run on our job runners. /// Instead, we receive web hook updates from Fal. FalQueue, - + + /// Seedance 2 Pro jobs. We poll for results. + #[serde(rename = "seedance2pro_queue")] + Seedance2ProQueue, + /// Storyteller Studio and Video Style Transfer Jobs (which we may want to split). /// These run in Comfy. /// TODO(bt,2024-07-15): We may segregate these two job types in the future @@ -110,6 +114,7 @@ impl InferenceJobType { pub fn to_str(&self) -> &'static str { match self { Self::FalQueue => "fal_queue", + Self::Seedance2ProQueue => "seedance2pro_queue", Self::VideoRender => "video_render", Self::LivePortrait => "live_portrait", Self::FaceFusion => "face_fusion", @@ -136,6 +141,7 @@ impl InferenceJobType { pub fn from_str(value: &str) -> Result { match value { "fal_queue" => Ok(Self::FalQueue), + "seedance2pro_queue" => Ok(Self::Seedance2ProQueue), "video_render" => Ok(Self::VideoRender), "live_portrait" => Ok(Self::LivePortrait), "face_fusion" => Ok(Self::FaceFusion), @@ -165,6 +171,7 @@ impl InferenceJobType { // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc. BTreeSet::from([ Self::FalQueue, + Self::Seedance2ProQueue, Self::VideoRender, Self::LivePortrait, Self::FaceFusion, @@ -205,6 +212,7 @@ mod tests { #[test] fn test_serialization() { assert_serialization(InferenceJobType::FalQueue, "fal_queue"); + assert_serialization(InferenceJobType::Seedance2ProQueue, "seedance2pro_queue"); assert_serialization(InferenceJobType::VideoRender, "video_render"); assert_serialization(InferenceJobType::LivePortrait, "live_portrait"); assert_serialization(InferenceJobType::FaceFusion, "face_fusion"); @@ -230,6 +238,7 @@ mod tests { #[test] fn to_str() { assert_eq!(InferenceJobType::FalQueue.to_str(), "fal_queue"); + assert_eq!(InferenceJobType::Seedance2ProQueue.to_str(), "seedance2pro_queue"); assert_eq!(InferenceJobType::VideoRender.to_str(), "video_render"); assert_eq!(InferenceJobType::LivePortrait.to_str(), "live_portrait"); assert_eq!(InferenceJobType::FaceFusion.to_str(), "face_fusion"); @@ -255,6 +264,7 @@ mod tests { #[test] fn from_str() { assert_eq!(InferenceJobType::from_str("fal_queue").unwrap(), InferenceJobType::FalQueue); + assert_eq!(InferenceJobType::from_str("seedance2pro_queue").unwrap(), InferenceJobType::Seedance2ProQueue); assert_eq!(InferenceJobType::from_str("video_render").unwrap(), InferenceJobType::VideoRender); assert_eq!(InferenceJobType::from_str("live_portrait").unwrap(), InferenceJobType::LivePortrait); assert_eq!(InferenceJobType::from_str("face_fusion").unwrap(), InferenceJobType::FaceFusion); @@ -280,7 +290,7 @@ mod tests { #[test] fn all_variants() { // Static check - const EXPECTED_COUNT : usize = 21; + const EXPECTED_COUNT : usize = 22; assert_eq!(InferenceJobType::all_variants().len(), EXPECTED_COUNT); assert_eq!(InferenceJobType::iter().len(), EXPECTED_COUNT); diff --git a/crates/schema/public/enums/src/by_table/media_files/media_file_origin_model_type.rs b/crates/schema/public/enums/src/by_table/media_files/media_file_origin_model_type.rs index 20903fb620..b69c7c6db5 100644 --- a/crates/schema/public/enums/src/by_table/media_files/media_file_origin_model_type.rs +++ b/crates/schema/public/enums/src/by_table/media_files/media_file_origin_model_type.rs @@ -216,7 +216,7 @@ mod tests { #[test] fn all_variants() { let mut variants = MediaFileOriginModelType::all_variants(); - assert_eq!(variants.len(), 15); + assert_eq!(variants.len(), 18); assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::FaceFusion)); assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::F5TTS)); assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::LivePortrait)); diff --git a/crates/schema/public/enums/src/by_table/media_files/media_file_origin_product_category.rs b/crates/schema/public/enums/src/by_table/media_files/media_file_origin_product_category.rs index 8ffc554344..062a4dc723 100644 --- a/crates/schema/public/enums/src/by_table/media_files/media_file_origin_product_category.rs +++ b/crates/schema/public/enums/src/by_table/media_files/media_file_origin_product_category.rs @@ -66,6 +66,9 @@ pub enum MediaFileOriginProductCategory { #[serde(rename = "image_gen")] ImageGeneration, + #[serde(rename = "video_gen")] + VideoGeneration, + // Media files for video filters #[deprecated(note = "This isn't relevant product surface area anymore")] #[serde(rename = "video_filter")] @@ -98,6 +101,7 @@ impl MediaFileOriginProductCategory { Self::ZeroShotVoice => "zs_voice", Self::Mocap => "mocap", Self::ImageGeneration => "image_gen", + Self::VideoGeneration => "video_gen", Self::VideoFilter => "video_filter", Self::Workflow => "workflow", } @@ -117,6 +121,7 @@ impl MediaFileOriginProductCategory { "zs_voice" => Ok(Self::ZeroShotVoice), "mocap" => Ok(Self::Mocap), "image_gen" => Ok(Self::ImageGeneration), + "video_gen" => Ok(Self::VideoGeneration), "video_filter" => Ok(Self::VideoFilter), "workflow" => Ok(Self::Workflow), _ => Err(format!("invalid value: {:?}", value)), @@ -139,6 +144,7 @@ impl MediaFileOriginProductCategory { Self::ZeroShotVoice, Self::Mocap, Self::ImageGeneration, + Self::VideoGeneration, Self::VideoFilter, Self::Workflow, ]) @@ -167,6 +173,7 @@ mod tests { assert_serialization(MediaFileOriginProductCategory::ZeroShotVoice, "zs_voice"); assert_serialization(MediaFileOriginProductCategory::Mocap, "mocap"); assert_serialization(MediaFileOriginProductCategory::ImageGeneration, "image_gen"); + assert_serialization(MediaFileOriginProductCategory::VideoGeneration, "video_gen"); assert_serialization(MediaFileOriginProductCategory::VideoFilter, "video_filter"); assert_serialization(MediaFileOriginProductCategory::Workflow, "workflow"); } @@ -185,6 +192,7 @@ mod tests { assert_eq!(MediaFileOriginProductCategory::ZeroShotVoice.to_str(), "zs_voice"); assert_eq!(MediaFileOriginProductCategory::Mocap.to_str(), "mocap"); assert_eq!(MediaFileOriginProductCategory::ImageGeneration.to_str(), "image_gen"); + assert_eq!(MediaFileOriginProductCategory::VideoGeneration.to_str(), "video_gen"); assert_eq!(MediaFileOriginProductCategory::VideoFilter.to_str(), "video_filter"); assert_eq!(MediaFileOriginProductCategory::Workflow.to_str(), "workflow"); } @@ -203,6 +211,7 @@ mod tests { assert_eq!(MediaFileOriginProductCategory::from_str("zs_voice").unwrap(), MediaFileOriginProductCategory::ZeroShotVoice); assert_eq!(MediaFileOriginProductCategory::from_str("mocap").unwrap(), MediaFileOriginProductCategory::Mocap); assert_eq!(MediaFileOriginProductCategory::from_str("image_gen").unwrap(),MediaFileOriginProductCategory::ImageGeneration); + assert_eq!(MediaFileOriginProductCategory::from_str("video_gen").unwrap(), MediaFileOriginProductCategory::VideoGeneration); assert_eq!(MediaFileOriginProductCategory::from_str("video_filter").unwrap(), MediaFileOriginProductCategory::VideoFilter); assert_eq!(MediaFileOriginProductCategory::from_str("workflow").unwrap(), MediaFileOriginProductCategory::Workflow); } @@ -210,7 +219,7 @@ mod tests { #[test] fn all_variants() { let mut variants = MediaFileOriginProductCategory::all_variants(); - assert_eq!(variants.len(), 14); + assert_eq!(variants.len(), 15); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Unknown)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::FaceAnimator)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::FaceFusion)); @@ -223,6 +232,7 @@ mod tests { assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::ZeroShotVoice)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Mocap)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::ImageGeneration)); + assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::VideoGeneration)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::VideoFilter)); assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Workflow)); assert_eq!(variants.pop_first(), None); diff --git a/crates/schema/public/enums/src/common/job_status_plus.rs b/crates/schema/public/enums/src/common/job_status_plus.rs index 9d2c374538..1138673137 100644 --- a/crates/schema/public/enums/src/common/job_status_plus.rs +++ b/crates/schema/public/enums/src/common/job_status_plus.rs @@ -43,7 +43,7 @@ impl Default for JobStatusPlus { } impl JobStatusPlus { - pub fn to_str(&self) -> &'static str { + pub const fn to_str(&self) -> &'static str { match self { Self::Pending => "pending", Self::Started => "started", diff --git a/crates/schema/public/enums/src/common/model_type.rs b/crates/schema/public/enums/src/common/model_type.rs index a2809097e3..420c57e50b 100644 --- a/crates/schema/public/enums/src/common/model_type.rs +++ b/crates/schema/public/enums/src/common/model_type.rs @@ -93,6 +93,8 @@ pub enum ModelType { Seedance10Lite, #[serde(rename = "seedance_1p0_pro")] Seedance10Pro, + #[serde(rename = "seedance_2p0")] + Seedance2p0, #[serde(rename = "sora_2")] Sora2, #[serde(rename = "sora_2_pro")] @@ -163,6 +165,7 @@ impl ModelType { Self::Kling2p6Pro => "kling_2p6_pro", Self::Seedance10Lite => "seedance_1p0_lite", Self::Seedance10Pro => "seedance_1p0_pro", + Self::Seedance2p0 => "seedance_2p0", Self::Sora2 => "sora_2", Self::Sora2Pro => "sora_2_pro", Self::Veo2 => "veo_2", @@ -217,6 +220,7 @@ impl ModelType { "kling_2p6_pro" => Ok(Self::Kling2p6Pro), "seedance_1p0_lite" => Ok(Self::Seedance10Lite), "seedance_1p0_pro" => Ok(Self::Seedance10Pro), + "seedance_2p0" => Ok(Self::Seedance2p0), "sora_2" => Ok(Self::Sora2), "sora_2_pro" => Ok(Self::Sora2Pro), "veo_2" => Ok(Self::Veo2), @@ -275,6 +279,7 @@ impl ModelType { Self::Kling2p6Pro, Self::Seedance10Lite, Self::Seedance10Pro, + Self::Seedance2p0, Self::Sora2, Self::Sora2Pro, Self::Veo2, @@ -337,6 +342,7 @@ mod tests { assert_serialization(ModelType::Kling2p6Pro, "kling_2p6_pro"); assert_serialization(ModelType::Seedance10Lite, "seedance_1p0_lite"); assert_serialization(ModelType::Seedance10Pro, "seedance_1p0_pro"); + assert_serialization(ModelType::Seedance2p0, "seedance_2p0"); assert_serialization(ModelType::Sora2, "sora_2"); assert_serialization(ModelType::Sora2Pro, "sora_2_pro"); assert_serialization(ModelType::Veo2, "veo_2"); @@ -389,6 +395,7 @@ mod tests { assert_eq!(ModelType::Kling2p6Pro.to_str(), "kling_2p6_pro"); assert_eq!(ModelType::Seedance10Lite.to_str(), "seedance_1p0_lite"); assert_eq!(ModelType::Seedance10Pro.to_str(), "seedance_1p0_pro"); + assert_eq!(ModelType::Seedance2p0.to_str(), "seedance_2p0"); assert_eq!(ModelType::Sora2.to_str(), "sora_2"); assert_eq!(ModelType::Sora2Pro.to_str(), "sora_2_pro"); assert_eq!(ModelType::Veo2.to_str(), "veo_2"); @@ -441,6 +448,7 @@ mod tests { assert_eq!(ModelType::from_str("kling_2p6_pro").unwrap(), ModelType::Kling2p6Pro); assert_eq!(ModelType::from_str("seedance_1p0_lite").unwrap(), ModelType::Seedance10Lite); assert_eq!(ModelType::from_str("seedance_1p0_pro").unwrap(), ModelType::Seedance10Pro); + assert_eq!(ModelType::from_str("seedance_2p0").unwrap(), ModelType::Seedance2p0); assert_eq!(ModelType::from_str("sora_2").unwrap(), ModelType::Sora2); assert_eq!(ModelType::from_str("sora_2_pro").unwrap(), ModelType::Sora2Pro); assert_eq!(ModelType::from_str("veo_2").unwrap(), ModelType::Veo2); @@ -458,7 +466,7 @@ mod tests { #[test] fn all_variants() { let mut variants = ModelType::all_variants(); - assert_eq!(variants.len(), 44); + assert_eq!(variants.len(), 45); // Image models assert_eq!(variants.pop_first(), Some(ModelType::Flux1Dev)); assert_eq!(variants.pop_first(), Some(ModelType::Flux1Schnell)); @@ -495,6 +503,7 @@ mod tests { assert_eq!(variants.pop_first(), Some(ModelType::Kling2p6Pro)); assert_eq!(variants.pop_first(), Some(ModelType::Seedance10Lite)); assert_eq!(variants.pop_first(), Some(ModelType::Seedance10Pro)); + assert_eq!(variants.pop_first(), Some(ModelType::Seedance2p0)); assert_eq!(variants.pop_first(), Some(ModelType::Sora2)); assert_eq!(variants.pop_first(), Some(ModelType::Sora2Pro)); assert_eq!(variants.pop_first(), Some(ModelType::Veo2)); diff --git a/crates/schema/public/enums/src/tauri/tasks/task_model_type.rs b/crates/schema/public/enums/src/tauri/tasks/task_model_type.rs index fd1ecadb58..cbe736b8e7 100644 --- a/crates/schema/public/enums/src/tauri/tasks/task_model_type.rs +++ b/crates/schema/public/enums/src/tauri/tasks/task_model_type.rs @@ -65,6 +65,8 @@ pub enum TaskModelType { Kling2p6Pro, #[serde(rename = "seedance_1.0_lite")] Seedance10Lite, + #[serde(rename = "seedance_2p0")] + Seedance2p0, #[serde(rename = "sora_2")] Sora2, #[serde(rename = "sora_2_pro")] @@ -126,6 +128,7 @@ impl TaskModelType { Self::Kling2p5TurboPro => "kling_2p5_turbo_pro", Self::Kling2p6Pro => "kling_2p6_pro", Self::Seedance10Lite => "seedance_1.0_lite", + Self::Seedance2p0 => "seedance_2p0", Self::Sora2 => "sora_2", Self::Sora2Pro => "sora_2_pro", Self::Veo2 => "veo_2", @@ -169,6 +172,7 @@ impl TaskModelType { "kling_2p5_turbo_pro" => Ok(Self::Kling2p5TurboPro), "kling_2p6_pro" => Ok(Self::Kling2p6Pro), "seedance_1.0_lite" => Ok(Self::Seedance10Lite), + "seedance_2p0" => Ok(Self::Seedance2p0), "sora_2" => Ok(Self::Sora2), "sora_2_pro" => Ok(Self::Sora2Pro), "veo_2" => Ok(Self::Veo2), @@ -215,6 +219,7 @@ impl TaskModelType { Self::Kling2p5TurboPro, Self::Kling2p6Pro, Self::Seedance10Lite, + Self::Seedance2p0, Self::Sora2, Self::Sora2Pro, Self::Veo2, @@ -268,6 +273,7 @@ mod tests { assert_serialization(TaskModelType::Kling2p5TurboPro, "kling_2p5_turbo_pro"); assert_serialization(TaskModelType::Kling2p6Pro, "kling_2p6_pro"); assert_serialization(TaskModelType::Seedance10Lite, "seedance_1.0_lite"); + assert_serialization(TaskModelType::Seedance2p0, "seedance_2p0"); assert_serialization(TaskModelType::Sora2, "sora_2"); assert_serialization(TaskModelType::Sora2Pro, "sora_2_pro"); assert_serialization(TaskModelType::Veo2, "veo_2"); @@ -310,6 +316,7 @@ mod tests { assert_eq!(TaskModelType::Kling2p5TurboPro.to_str(), "kling_2p5_turbo_pro"); assert_eq!(TaskModelType::Kling2p6Pro.to_str(), "kling_2p6_pro"); assert_eq!(TaskModelType::Seedance10Lite.to_str(), "seedance_1.0_lite"); + assert_eq!(TaskModelType::Seedance2p0.to_str(), "seedance_2p0"); assert_eq!(TaskModelType::Sora2.to_str(), "sora_2"); assert_eq!(TaskModelType::Sora2Pro.to_str(), "sora_2_pro"); assert_eq!(TaskModelType::Veo2.to_str(), "veo_2"); @@ -352,6 +359,7 @@ mod tests { assert_eq!(TaskModelType::from_str("kling_2p5_turbo_pro").unwrap(), TaskModelType::Kling2p5TurboPro); assert_eq!(TaskModelType::from_str("kling_2p6_pro").unwrap(), TaskModelType::Kling2p6Pro); assert_eq!(TaskModelType::from_str("seedance_1.0_lite").unwrap(), TaskModelType::Seedance10Lite); + assert_eq!(TaskModelType::from_str("seedance_2p0").unwrap(), TaskModelType::Seedance2p0); assert_eq!(TaskModelType::from_str("sora_2").unwrap(), TaskModelType::Sora2); assert_eq!(TaskModelType::from_str("sora_2_pro").unwrap(), TaskModelType::Sora2Pro); assert_eq!(TaskModelType::from_str("veo_2").unwrap(), TaskModelType::Veo2); @@ -380,7 +388,7 @@ mod tests { #[test] fn all_variants() { let mut variants = TaskModelType::all_variants(); - assert_eq!(variants.len(), 35); + assert_eq!(variants.len(), 36); // Image models assert_eq!(variants.pop_first(), Some(TaskModelType::Flux1Dev)); assert_eq!(variants.pop_first(), Some(TaskModelType::Flux1Schnell)); @@ -407,6 +415,7 @@ mod tests { assert_eq!(variants.pop_first(), Some(TaskModelType::Kling2p5TurboPro)); assert_eq!(variants.pop_first(), Some(TaskModelType::Kling2p6Pro)); assert_eq!(variants.pop_first(), Some(TaskModelType::Seedance10Lite)); + assert_eq!(variants.pop_first(), Some(TaskModelType::Seedance2p0)); assert_eq!(variants.pop_first(), Some(TaskModelType::Sora2)); assert_eq!(variants.pop_first(), Some(TaskModelType::Sora2Pro)); assert_eq!(variants.pop_first(), Some(TaskModelType::Veo2));