elevenlabs-cli 0.1.8

Unofficial CLI for ElevenLabs text-to-speech API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Voice settings validation utilities

use anyhow::Result;

/// Valid range for voice settings
const MIN_VALUE: f32 = 0.0;
const MAX_VALUE: f32 = 1.0;

/// Validate stability value is within valid range (0.0-1.0)
pub fn validate_stability(value: f32) -> Result<f32> {
    if !(MIN_VALUE..=MAX_VALUE).contains(&value) {
        Err(anyhow::anyhow!("Stability must be between 0.0 and 1.0"))
    } else {
        Ok(value)
    }
}

/// Validate similarity boost value is within valid range (0.0-1.0)
pub fn validate_similarity_boost(value: f32) -> Result<f32> {
    if !(MIN_VALUE..=MAX_VALUE).contains(&value) {
        Err(anyhow::anyhow!(
            "Similarity boost must be between 0.0 and 1.0"
        ))
    } else {
        Ok(value)
    }
}

/// Validate style value is within valid range (0.0-1.0)
pub fn validate_style(value: f32) -> Result<f32> {
    if !(MIN_VALUE..=MAX_VALUE).contains(&value) {
        Err(anyhow::anyhow!("Style must be between 0.0 and 1.0"))
    } else {
        Ok(value)
    }
}

/// Validate all voice settings if provided
pub fn validate_voice_settings(
    stability: Option<f32>,
    similarity_boost: Option<f32>,
    style: Option<f32>,
) -> Result<()> {
    if let Some(s) = stability {
        validate_stability(s)?;
    }
    if let Some(sb) = similarity_boost {
        validate_similarity_boost(sb)?;
    }
    if let Some(st) = style {
        validate_style(st)?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_stability_valid() {
        assert!(validate_stability(0.0).is_ok());
        assert!(validate_stability(0.5).is_ok());
        assert!(validate_stability(1.0).is_ok());
    }

    #[test]
    fn test_validate_stability_invalid() {
        assert!(validate_stability(-0.1).is_err());
        assert!(validate_stability(1.1).is_err());
    }

    #[test]
    fn test_validate_similarity_boost_valid() {
        assert!(validate_similarity_boost(0.0).is_ok());
        assert!(validate_similarity_boost(0.75).is_ok());
    }

    #[test]
    fn test_validate_style_invalid() {
        assert!(validate_style(-1.0).is_err());
        assert!(validate_style(2.0).is_err());
    }

    #[test]
    fn test_validate_voice_settings_all_valid() {
        assert!(validate_voice_settings(Some(0.5), Some(0.75), Some(0.25)).is_ok());
    }

    #[test]
    fn test_validate_voice_settings_partial() {
        assert!(validate_voice_settings(Some(0.5), None, None).is_ok());
        assert!(validate_voice_settings(None, Some(0.75), None).is_ok());
    }

    #[test]
    fn test_validate_voice_settings_one_invalid() {
        assert!(validate_voice_settings(Some(2.0), None, None).is_err());
    }
}