musicgpt 0.3.2

Generate music based on natural language prompts using LLMs running locally
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

use std::fmt::Write;
use std::ops::{Deref, DerefMut};
use std::time::Duration;

use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressState, ProgressStyle};

pub struct LoadingBarFactor;

pub struct Bar(ProgressBar);

impl Bar {
    pub fn update_elapsed_total(&self, elapsed: usize, total: usize) {
        self.0.set_length(total as u64);
        self.0.set_position(elapsed as u64);
    }
    
    pub fn into_update_callback(self) ->  Box<dyn Fn(usize, usize) + Send + Sync + 'static> {
        Box::new(move |el, t|  self.update_elapsed_total(el, t))
    }
}

impl Deref for Bar {
    type Target = ProgressBar;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for Bar {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

pub struct MultiBar(MultiProgress);

impl MultiBar {
    pub fn add(&self, bar: Bar) -> Bar {
        Bar(self.0.add(bar.0))
    }
}

impl Deref for MultiBar {
    type Target = MultiProgress;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for MultiBar {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl LoadingBarFactor {
    pub fn multi() -> MultiBar {
        MultiBar(MultiProgress::new())
    }

    pub fn spinner(msg: impl Into<String>) -> Bar {
        let pb = ProgressBar::new_spinner();
        pb.enable_steady_tick(Duration::from_millis(120));
        pb.set_style(ProgressStyle::with_template("{spinner:.blue} {msg}").unwrap());
        pb.set_message(msg.into());
        Bar(pb)
    }

    pub fn bar(prefix: impl Into<String>) -> Bar {
        Self::fixed_bar(prefix, 1)
    }

    pub fn fixed_bar(prefix: impl Into<String>, len: usize) -> Bar {
        let pb = ProgressBar::new(len as u64);
        pb.set_style(
            ProgressStyle::with_template(
                &(prefix.into()
                    + " {spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] ({eta})"),
            )
            .unwrap()
            .with_key("eta", |state: &ProgressState, w: &mut dyn Write| {
                write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap()
            })
            .progress_chars("#>-"),
        );
        Bar(pb)
    }

    pub fn download_bar(file: &str) -> Bar {
        const NAME_LEN: usize = 32;
        const NAME_SHIFT_INTERVAL: usize = 300;
        let pb = ProgressBar::with_draw_target(None, ProgressDrawTarget::stderr());
        let file_string = file.to_string();
        pb.set_style(
            ProgressStyle::with_template(
                "{file:>32} {spinner:.green} [{wide_bar:.cyan/blue}] {bytes}/{total_bytes}",
            )
            .unwrap()
            .with_key("file", move |state: &ProgressState, w: &mut dyn Write| {
                if file_string.len() > NAME_LEN {
                    let el = state.elapsed().as_millis() as usize;
                    let offset = (el / NAME_SHIFT_INTERVAL) % (file_string.len() - NAME_LEN + 1);
                    let view = &file_string[offset..offset + NAME_LEN];
                    write!(w, "{view: >w$}", w = NAME_LEN).unwrap();
                } else {
                    write!(w, "{file_string: >w$}", w = NAME_LEN).unwrap();
                }
            })
            .with_key("eta", |state: &ProgressState, w: &mut dyn Write| {
                write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap()
            })
            .progress_chars("#>-"),
        );
        Bar(pb)
    }
}