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
77

use pyo3::prelude::*;

use crate::frontends::python::waveform::PyArraySamples;

/// A container for decoding operations that may have succeeded or failed.
///
/// :py:class:`NumPyNamedResult` contains either a :py:class:`numpy.ndarray`
/// from a successful audio decoding or a Python exception from a failed
/// audio decoding.
///
#[pyclass(module = "babycat")]
#[derive(Clone, Debug)]
pub struct NumPyNamedResult {
    /// 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:`numpy.ndarray` if decoding succeeded... or ``None`` if decoding failed.
    #[pyo3(get)]
    pub array: Option<PyArraySamples>,
    error: Option<crate::backend::Error>,
}

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

    fn __repr__(&self) -> PyResult<String> {
        Ok(format!("{}", self))
    }
}

impl IntoPy<NumPyNamedResult> for crate::backend::WaveformNamedResult {
    fn into_py(self, py: Python<'_>) -> NumPyNamedResult {
        match self.result {
            Ok(waveform) => NumPyNamedResult {
                name: self.name,
                array: Some(waveform.into_py(py)),
                error: None,
            },
            Err(err) => NumPyNamedResult {
                name: self.name,
                array: None,
                error: Some(err),
            },
        }
    }
}

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