trimsec 2.2.1

Calculate time saved on using speed multipliers.
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
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
155
156
157
158
159
160

use std::collections::HashSet;

use reqwest::blocking::Client;

use crate::{
    core::{
        deser::{YTPlaylistItems, YTPlaylistList, YTVideos},
        time::{parse_duration, parse_time},
    },
    errors::TYoutubeError,
    youtube_utils::YoutubeId,
};

pub struct ApiClientManager<'a> {
    client: Client,
    key: &'a str,
}

impl<'a> ApiClientManager<'a> {
    #[must_use]
    pub fn new(key: &'a str) -> Self {
        Self {
            client: Client::new(),
            key,
        }
    }

    pub fn fetch_duration_from_id(
        &self,
        id: &YoutubeId,
        given_max: usize,
    ) -> Result<(String, usize), TYoutubeError> {
        let total_ids = {
            let mut next_tok: Option<String> = None;
            let mut ids = Vec::new();
            let mut seen_tokens: HashSet<String> = HashSet::new();

            if id.is_playlist {
                let url = format!(
                    "https://www.googleapis.com/youtube/v3/playlists?part=contentDetails&id={}&key={}&maxResults=1",
                    &id.id, self.key
                );

                let response: YTPlaylistList = self
                    .client
                    .get(url)
                    .send()
                    .map_err(TYoutubeError::Reqwest)?
                    .json()
                    .map_err(TYoutubeError::Reqwest)?;

                let traversible_items = if let Some(ic) = response.items.first() {
                    let max_traversible = ic.content_details.item_count;

                    if given_max != 0 {
                        if given_max > max_traversible {
                            return Err(TYoutubeError::InvalidMaxSize((
                                given_max,
                                max_traversible,
                            )));
                        } else {
                            given_max
                        }
                    } else {
                        max_traversible
                    }
                } else {
                    return Err(TYoutubeError::InvalidPlaylist(id.id.clone()));
                };

                for start in (0..traversible_items).step_by(50) {
                    let max_results = (traversible_items - start).min(50);

                    let url = format!(
                        "https://www.googleapis.com/youtube/v3/playlistItems?playlistId={}&key={}&maxResults={}&part=contentDetails{}",
                        &id.id,
                        self.key,
                        max_results,
                        if let Some(ref tok) = next_tok {
                            format!("&pageToken={tok}")
                        } else {
                            "".to_string()
                        }
                    );

                    let response: YTPlaylistItems = self
                        .client
                        .get(url)
                        .send()
                        .map_err(TYoutubeError::Reqwest)?
                        .json()
                        .map_err(TYoutubeError::Reqwest)?;

                    if let Some(t) = &response.next_page_token
                        && seen_tokens.contains(t)
                    {
                        break;
                    }

                    let current_ids = response
                        .items
                        .into_iter()
                        .map(|f| f.content_details.video_id);

                    ids.extend(current_ids);

                    if let Some(new_tok) = response.next_page_token {
                        next_tok = Some(new_tok.clone());
                        seen_tokens.insert(new_tok);
                    } else {
                        break;
                    }
                }
            } else {
                ids.push(id.id.clone());
            }

            ids
        };

        let mut total_duration: f64 = 0.0;

        for chunk_ids in total_ids.chunks(50) {
            let url = format!(
                "https://www.googleapis.com/youtube/v3/videos?id={}&key={}&part=contentDetails",
                chunk_ids.join(","),
                self.key
            );

            let response: YTVideos = self
                .client
                .get(url)
                .send()
                .map_err(TYoutubeError::Reqwest)?
                .json()
                .map_err(TYoutubeError::Reqwest)?;

            let chunk_duration: f64 = response
                .items
                .iter()
                .map(|f| {
                    let (dur, _) = parse_duration(
                        f.content_details
                            .duration
                            .to_lowercase()
                            .trim_start_matches("pt"),
                    )
                    .unwrap_or((0.0, 0));
                    dur
                })
                .collect::<Vec<f64>>()
                .iter()
                .sum();

            total_duration += chunk_duration;
        }

        Ok((parse_time(total_duration), total_ids.len()))
    }
}