whis-core 0.6.2

Core library for whis voice-to-text functionality
Documentation 
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use serde::{Deserialize, Serialize};
use std::fmt;

/// Available transcription providers
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum TranscriptionProvider {
    #[default]
    OpenAI,
    #[serde(rename = "openai-realtime")]
    OpenAIRealtime,
    Mistral,
    Groq,
    Deepgram,
    ElevenLabs,
    #[serde(rename = "local-whisper")]
    LocalWhisper,
    #[serde(rename = "local-parakeet")]
    LocalParakeet,
}

impl TranscriptionProvider {
    /// Get the string identifier for this provider
    pub fn as_str(&self) -> &'static str {
        match self {
            TranscriptionProvider::OpenAI => "openai",
            TranscriptionProvider::OpenAIRealtime => "openai-realtime",
            TranscriptionProvider::Mistral => "mistral",
            TranscriptionProvider::Groq => "groq",
            TranscriptionProvider::Deepgram => "deepgram",
            TranscriptionProvider::ElevenLabs => "elevenlabs",
            TranscriptionProvider::LocalWhisper => "local-whisper",
            TranscriptionProvider::LocalParakeet => "local-parakeet",
        }
    }

    /// Get the environment variable name for this provider's API key (or path/URL for local)
    pub fn api_key_env_var(&self) -> &'static str {
        match self {
            TranscriptionProvider::OpenAI | TranscriptionProvider::OpenAIRealtime => {
                "OPENAI_API_KEY"
            }
            TranscriptionProvider::Mistral => "MISTRAL_API_KEY",
            TranscriptionProvider::Groq => "GROQ_API_KEY",
            TranscriptionProvider::Deepgram => "DEEPGRAM_API_KEY",
            TranscriptionProvider::ElevenLabs => "ELEVENLABS_API_KEY",
            TranscriptionProvider::LocalWhisper => "LOCAL_WHISPER_MODEL_PATH",
            TranscriptionProvider::LocalParakeet => "LOCAL_PARAKEET_MODEL_PATH",
        }
    }

    /// List all available providers
    pub fn all() -> &'static [TranscriptionProvider] {
        &[
            TranscriptionProvider::OpenAI,
            TranscriptionProvider::OpenAIRealtime,
            TranscriptionProvider::Mistral,
            TranscriptionProvider::Groq,
            TranscriptionProvider::Deepgram,
            TranscriptionProvider::ElevenLabs,
            TranscriptionProvider::LocalWhisper,
            TranscriptionProvider::LocalParakeet,
        ]
    }

    /// Human-readable display name for this provider
    pub fn display_name(&self) -> &'static str {
        match self {
            TranscriptionProvider::OpenAI => "OpenAI",
            TranscriptionProvider::OpenAIRealtime => "OpenAI Realtime",
            TranscriptionProvider::Mistral => "Mistral",
            TranscriptionProvider::Groq => "Groq",
            TranscriptionProvider::Deepgram => "Deepgram",
            TranscriptionProvider::ElevenLabs => "ElevenLabs",
            TranscriptionProvider::LocalWhisper => "Local Whisper",
            TranscriptionProvider::LocalParakeet => "Local Parakeet",
        }
    }

    /// Whether this provider requires an API key (vs path/URL for local/remote)
    pub fn requires_api_key(&self) -> bool {
        !matches!(
            self,
            TranscriptionProvider::LocalWhisper | TranscriptionProvider::LocalParakeet
        )
    }

    /// Whether this is a local provider (no cloud API)
    pub fn is_local(&self) -> bool {
        matches!(
            self,
            TranscriptionProvider::LocalWhisper | TranscriptionProvider::LocalParakeet
        )
    }
}

impl fmt::Display for TranscriptionProvider {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::str::FromStr for TranscriptionProvider {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "openai" => Ok(TranscriptionProvider::OpenAI),
            "openai-realtime" | "openairealttime" | "realtime" => {
                Ok(TranscriptionProvider::OpenAIRealtime)
            }
            "mistral" => Ok(TranscriptionProvider::Mistral),
            "groq" => Ok(TranscriptionProvider::Groq),
            "deepgram" => Ok(TranscriptionProvider::Deepgram),
            "elevenlabs" => Ok(TranscriptionProvider::ElevenLabs),
            "local-whisper" | "localwhisper" | "whisper" => Ok(TranscriptionProvider::LocalWhisper),
            "local-parakeet" | "localparakeet" | "parakeet" => {
                Ok(TranscriptionProvider::LocalParakeet)
            }
            _ => Err(format!(
                "Unknown provider: {}. Available: openai, openai-realtime, mistral, groq, deepgram, elevenlabs, local-whisper, local-parakeet",
                s
            )),
        }
    }
}