babycat 0.0.15

An audio decoding and manipulation library, with bindings for C, Python, and WebAssembly.
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

use pyo3::prelude::*;

/// A container for decoding operations that may have succeeded or failed.
///
/// :py:class:`WaveformNamedResult` contains either a :py:class:`Waveform`
/// from a successful audio decoding or a Python exception from a failed
/// audio decoding.
///
#[pyclass(module = "babycat")]
#[derive(Clone, Debug)]
pub struct WaveformNamedResult {
    /// The "name" of a result as a :py:class:`str`, typically a filename for an audio file.
    #[pyo3(get)]
    pub name: String,
    /// A :py:class:`~babycat.Waveform` if decoding succeeded... or ``None`` if decoding failed.
    #[pyo3(get)]
    pub waveform: Option<crate::frontends::python::waveform::Waveform>,
    error: Option<crate::backend::Error>,
}

#[pymethods]
impl WaveformNamedResult {
    /// ``None`` if decoding succeeded... or an exception if decoding failed.
    #[getter]
    fn get_exception(&self) -> Option<PyErr> {
        self.error.map(PyErr::from)
    }

    #[allow(clippy::unnecessary_wraps)]
    fn __repr__(&self) -> PyResult<String> {
        Ok(format!("{}", self))
    }
}

impl From<crate::backend::WaveformNamedResult> for WaveformNamedResult {
    fn from(inner: crate::backend::WaveformNamedResult) -> Self {
        match inner.result {
            Ok(waveform) => Self {
                name: inner.name,
                waveform: Some(waveform.into()),
                error: None,
            },
            Err(err) => Self {
                name: inner.name,
                waveform: None,
                error: Some(err),
            },
        }
    }
}

impl std::fmt::Display for WaveformNamedResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.waveform {
            Some(waveform) => {
                write!(
                    f,
                    "<babycat.WaveformNamedResult: name={} waveform={}>",
                    self.name, waveform
                )
            }
            None => match self.error {
                Some(error) => {
                    write!(
                        f,
                        "<babycat.WaveformNamedResult name={} error={}>",
                        self.name, error
                    )
                }
                None => {
                    write!(f, "<babycat.WaveformNamedResult name={}>", self.name,)
                }
            },
        }
    }
}