talk-rs 0.7.1

Voice dictation for Linux -- record, transcribe, and paste
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::cli::def::Commands;
use std::path::PathBuf;

pub use crate::dictate::{dictate, DictateOpts};
pub use crate::record::ui::record_ui;
pub use crate::record::{record, record_daemon, RecordOpts};
pub use crate::speak::{speak, SpeakOpts};
pub use crate::transcribe::transcribe;

pub async fn dispatch(command: Commands, verbose: u8) -> Result<(), Box<dyn std::error::Error>> {
    match command {
        Commands::Record {
            file,
            monitor,
            no_sounds,
            no_boop,
            no_overlay,
            viz,
            mono,
            ui,
            toggle,
            no_bt_auto_switch,
            daemon,
        } => {
            if ui {
                record_ui().await?;
            } else if toggle {
                crate::record::toggle::toggle_dispatch(&crate::record::toggle::RecordToggleOpts {
                    file: file.map(PathBuf::from),
                    monitor,
                    no_sounds,
                    no_boop,
                    no_overlay,
                    viz,
                    mono,
                    no_bt_auto_switch,
                    verbose,
                })
                .await?;
            } else {
                let args = file.map(|f| vec![f]).unwrap_or_default();
                let opts = RecordOpts {
                    args,
                    monitor,
                    no_sounds,
                    no_boop,
                    no_overlay,
                    viz,
                    mono,
                    no_bt_auto_switch,
                };
                if daemon {
                    record_daemon(opts).await?;
                } else {
                    record(opts).await?;
                }
            }
        }
        Commands::Transcribe {
            input,
            output,
            provider,
            model,
            diarize,
            timestamp,
        } => {
            let mut args = vec![input];
            if let Some(output_file) = output {
                args.push(output_file);
            }
            transcribe(args, provider, model, diarize, timestamp).await?;
        }
        Commands::Speak {
            text,
            file,
            provider,
            voice,
            lang,
            speed,
            output,
            force,
        } => {
            speak(SpeakOpts {
                text,
                file: file.map(PathBuf::from),
                provider,
                voice,
                lang,
                speed,
                output: output.map(PathBuf::from),
                force,
            })
            .await?;
        }
        Commands::Dictate {
            save,
            output_yaml,
            input_audio_file,
            retry_last,
            pick,
            replace_last_paste,
            provider,
            model,
            diarize,
            timestamp,
            realtime,
            toggle,
            no_sounds,
            no_boop,
            no_chunk_paste,
            no_paste,
            monitor,
            no_overlay,
            no_auto_pause,
            viz,
            mono,
            upload_format,
            no_bt_auto_switch,
            daemon,
            target_window,
        } => {
            dictate(DictateOpts {
                save: save.map(PathBuf::from),
                output_yaml: output_yaml.map(PathBuf::from),
                input_audio_file: input_audio_file.map(PathBuf::from),
                retry_last,
                pick,
                replace_last_paste,
                provider,
                model,
                diarize,
                timestamp,
                realtime,
                toggle,
                no_sounds,
                no_boop,
                no_chunk_paste,
                no_paste,
                monitor,
                no_overlay,
                no_auto_pause,
                viz,
                mono,
                upload_format,
                no_bt_auto_switch,
                daemon,
                target_window,
                verbose,
            })
            .await?;
        }
    }
    Ok(())
}