caesura 0.31.0

An all-in-one command line tool to transcode FLAC audio files and upload to gazelle based indexers/trackers
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

use crate::prelude::*;

/// Verify a [`Source`] against the subset of rules that only need API data.
#[injectable]
pub(crate) struct ApiVerifier {
    /// Verify options containing exclude tags.
    verify_options: Ref<VerifyOptions>,
    /// Target format options.
    target_options: Ref<TargetOptions>,
}

impl ApiVerifier {
    /// Run API-only checks on a [`Source`].
    ///
    /// Returns a vector of [`SourceIssue`] entries; an empty vector means the
    /// source passed every API-only rule.
    #[must_use]
    pub(crate) fn execute(&self, source: &Source) -> Vec<SourceIssue> {
        trace!(
            "{} torrent hash against {}",
            "Checking".bold(),
            source.directory.display()
        );
        let exclude_tags = self.verify_options.exclude_tags.as_deref().unwrap_or(&[]);
        let mut issues: Vec<SourceIssue> = Vec::new();
        issues.extend(check_category(source));
        issues.extend(check_scene(source));
        issues.extend(check_possible_scene(source));
        issues.extend(check_lossy_master(source));
        issues.extend(check_lossy_web(source));
        issues.extend(check_trumpable(source));
        issues.extend(check_unconfirmed(source));
        issues.extend(check_excluded_tags(source, exclude_tags));
        let targets = BTreeSet::from_iter(self.target_options.target.clone());
        issues.extend(check_targets(source, &targets));
        issues
    }
}

/// Check the source group category is "Music".
pub(crate) fn check_category(source: &Source) -> Option<SourceIssue> {
    if source.group.category_name != "Music" {
        return Some(SourceIssue::Category {
            actual: source.group.category_name.clone(),
        });
    }
    None
}

/// Check the source is not a scene release.
pub(crate) fn check_scene(source: &Source) -> Option<SourceIssue> {
    if source.torrent.scene {
        return Some(SourceIssue::Scene);
    }
    None
}

/// Check the source does not look like an unmarked scene release.
///
/// Scene releases typically use underscores instead of spaces in both the
/// directory name and file names.
pub(crate) fn check_possible_scene(source: &Source) -> Option<SourceIssue> {
    if !source.torrent.file_path.contains(' ') && !source.torrent.file_list.contains(' ') {
        return Some(SourceIssue::PossibleScene);
    }
    None
}

/// Check the source does not have lossy master approval.
pub(crate) fn check_lossy_master(source: &Source) -> Option<SourceIssue> {
    if source.torrent.lossy_master_approved == Some(true) {
        return Some(SourceIssue::LossyMaster);
    }
    None
}

/// Check the source does not have lossy web approval.
pub(crate) fn check_lossy_web(source: &Source) -> Option<SourceIssue> {
    if source.torrent.lossy_web_approved == Some(true) {
        return Some(SourceIssue::LossyWeb);
    }
    None
}

/// Check the source is not trumpable.
pub(crate) fn check_trumpable(source: &Source) -> Option<SourceIssue> {
    if source.torrent.trumpable == Some(true) {
        return Some(SourceIssue::Trumpable);
    }
    None
}

/// Check the source edition is confirmed.
pub(crate) fn check_unconfirmed(source: &Source) -> Option<SourceIssue> {
    if source.torrent.remastered == Some(false) {
        return Some(SourceIssue::Unconfirmed);
    }
    None
}

/// Check the source does not have any excluded tags.
pub(crate) fn check_excluded_tags(source: &Source, exclude_tags: &[String]) -> Option<SourceIssue> {
    let excluded: Vec<String> = exclude_tags
        .iter()
        .filter(|x| source.group.tags.contains(x))
        .cloned()
        .collect();
    if !excluded.is_empty() {
        return Some(SourceIssue::Excluded { tags: excluded });
    }
    None
}

/// Check there are target formats available for transcoding.
pub(crate) fn check_targets(
    source: &Source,
    configured_targets: &BTreeSet<TargetFormat>,
) -> Option<SourceIssue> {
    if source.targets.is_empty() {
        return Some(SourceIssue::NoTargets {
            formats: configured_targets.clone(),
        });
    }
    None
}