convert-invert 0.1.0

Orchestrate spotify playlist downloads using soulseek-rs
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

use anyhow::Context;
use async_trait::async_trait;
use reqwest::Url;
use tracing::instrument;

use crate::internals::{
    judge::judge_manager::{Judge, ResponseFormat},
    search::search_manager::JudgeSubmission,
};

#[derive(Clone)]
pub struct LocalLLM {
    pub address: String,
    pub port: i32,
    pub score_cutoff: f32,
}
impl LocalLLM {
    pub fn new(address: String, port: i32, score_cutoff: f32) -> Self {
        LocalLLM {
            address,
            port,
            score_cutoff,
        }
    }
    #[instrument(name = "LocalLLM::get_score", skip(self, submission))]
    async fn get_score(&self, submission: JudgeSubmission) -> anyhow::Result<ResponseFormat> {
        let url = Url::parse(&format!("{}:{}/score", self.address, self.port))
            .context("Build LLM score URL")?;
        let client = reqwest::Client::new();
        let str_val = serde_json::to_string(&submission).context("Parsing own track")?;
        let res = client
            .post(url)
            .header("Content-Type", "application/json")
            .body(str_val)
            .send()
            .await
            .context("Response from llm server")?
            .error_for_status()
            .context("LLM server returned error")?;
        let text = res.text().await.context("Error reading response")?;
        let response: ResponseFormat = serde_json::from_str(&text).context("parsing response")?;
        Ok(response)
    }
    #[instrument(name = "LocalLLM::get_score", skip(self, submission))]
    async fn get_score_vec(
        &self,
        submission: Vec<JudgeSubmission>,
    ) -> anyhow::Result<Vec<ResponseFormat>> {
        let url = Url::parse(&format!("{}:{}/score", self.address, self.port))
            .context("Build LLM score URL")?;
        let client = reqwest::Client::new();
        let str_val = serde_json::to_string(&submission).context("Parsing own track")?;
        let res = client
            .post(url)
            .header("Content-Type", "application/json")
            .body(str_val)
            .send()
            .await
            .context("Response from llm server")?
            .error_for_status()
            .context("LLM server returned error")?;
        let text = res.text().await.context("Error reading response")?;
        let response: Vec<ResponseFormat> =
            serde_json::from_str(&text).context("parsing response")?;
        Ok(response)
    }
}

#[async_trait]
impl Judge for LocalLLM {
    #[instrument(name = "LocalLLM::judge", skip(self), fields(username = submission.query.username , query_song = submission.track.track, file_q = submission.query.filename))]
    async fn judge(&self, submission: JudgeSubmission) -> anyhow::Result<bool> {
        let response = self.get_score(submission).await.context("Getting score")?;
        tracing::debug!(?response, "LLM judge response");
        match response.score {
            x if x.unwrap_or_default() > self.score_cutoff => Ok(true),
            _ => Ok(false),
        }
    }

    #[instrument(name = "LocalLLM::judge", skip(self), fields(username = submission.query.username , query_song = submission.track.track, file_q = submission.query.filename))]
    async fn judge_score(&self, submission: JudgeSubmission) -> anyhow::Result<f32> {
        let response = self.get_score(submission).await.context("Getting score")?;
        Ok(response.score.unwrap_or_default())
    }
    #[instrument(name = "LocalLLM::judge_block", skip(self))]
    async fn judge_block(&self, submissions: Vec<JudgeSubmission>) -> anyhow::Result<Vec<f32>> {
        let response = self
            .get_score_vec(submissions)
            .await
            .context("Getting score")?;
        let response: Vec<_> = response
            .into_iter()
            .map(|val| val.score.unwrap_or_default())
            .collect();
        Ok(response)
    }
}