pyo3/types/
boolobject.rs

1#[cfg(feature = "experimental-inspect")]
2use crate::inspect::types::TypeInfo;
3use crate::{
4    exceptions::PyTypeError, ffi, ffi_ptr_ext::FfiPtrExt, instance::Bound,
5    types::typeobject::PyTypeMethods, Borrowed, FromPyObject, PyAny, PyResult, Python,
6};
7
8use super::any::PyAnyMethods;
9use crate::conversion::IntoPyObject;
10use std::convert::Infallible;
11
12/// Represents a Python `bool`.
13///
14/// Values of this type are accessed via PyO3's smart pointers, e.g. as
15/// [`Py<PyBool>`][crate::Py] or [`Bound<'py, PyBool>`][Bound].
16///
17/// For APIs available on `bool` objects, see the [`PyBoolMethods`] trait which is implemented for
18/// [`Bound<'py, PyBool>`][Bound].
19#[repr(transparent)]
20pub struct PyBool(PyAny);
21
22pyobject_native_type!(PyBool, ffi::PyObject, pyobject_native_static_type_object!(ffi::PyBool_Type), #checkfunction=ffi::PyBool_Check);
23
24impl PyBool {
25    /// Depending on `val`, returns `true` or `false`.
26    ///
27    /// # Note
28    /// This returns a [`Borrowed`] reference to one of Pythons `True` or
29    /// `False` singletons
30    #[inline]
31    pub fn new(py: Python<'_>, val: bool) -> Borrowed<'_, '_, Self> {
32        unsafe {
33            if val { ffi::Py_True() } else { ffi::Py_False() }
34                .assume_borrowed(py)
35                .downcast_unchecked()
36        }
37    }
38}
39
40/// Implementation of functionality for [`PyBool`].
41///
42/// These methods are defined for the `Bound<'py, PyBool>` smart pointer, so to use method call
43/// syntax these methods are separated into a trait, because stable Rust does not yet support
44/// `arbitrary_self_types`.
45#[doc(alias = "PyBool")]
46pub trait PyBoolMethods<'py>: crate::sealed::Sealed {
47    /// Gets whether this boolean is `true`.
48    fn is_true(&self) -> bool;
49}
50
51impl<'py> PyBoolMethods<'py> for Bound<'py, PyBool> {
52    #[inline]
53    fn is_true(&self) -> bool {
54        self.as_ptr() == unsafe { crate::ffi::Py_True() }
55    }
56}
57
58/// Compare `Bound<PyBool>` with `bool`.
59impl PartialEq<bool> for Bound<'_, PyBool> {
60    #[inline]
61    fn eq(&self, other: &bool) -> bool {
62        self.as_borrowed() == *other
63    }
64}
65
66/// Compare `&Bound<PyBool>` with `bool`.
67impl PartialEq<bool> for &'_ Bound<'_, PyBool> {
68    #[inline]
69    fn eq(&self, other: &bool) -> bool {
70        self.as_borrowed() == *other
71    }
72}
73
74/// Compare `Bound<PyBool>` with `&bool`.
75impl PartialEq<&'_ bool> for Bound<'_, PyBool> {
76    #[inline]
77    fn eq(&self, other: &&bool) -> bool {
78        self.as_borrowed() == **other
79    }
80}
81
82/// Compare `bool` with `Bound<PyBool>`
83impl PartialEq<Bound<'_, PyBool>> for bool {
84    #[inline]
85    fn eq(&self, other: &Bound<'_, PyBool>) -> bool {
86        *self == other.as_borrowed()
87    }
88}
89
90/// Compare `bool` with `&Bound<PyBool>`
91impl PartialEq<&'_ Bound<'_, PyBool>> for bool {
92    #[inline]
93    fn eq(&self, other: &&'_ Bound<'_, PyBool>) -> bool {
94        *self == other.as_borrowed()
95    }
96}
97
98/// Compare `&bool` with `Bound<PyBool>`
99impl PartialEq<Bound<'_, PyBool>> for &'_ bool {
100    #[inline]
101    fn eq(&self, other: &Bound<'_, PyBool>) -> bool {
102        **self == other.as_borrowed()
103    }
104}
105
106/// Compare `Borrowed<PyBool>` with `bool`
107impl PartialEq<bool> for Borrowed<'_, '_, PyBool> {
108    #[inline]
109    fn eq(&self, other: &bool) -> bool {
110        self.is_true() == *other
111    }
112}
113
114/// Compare `Borrowed<PyBool>` with `&bool`
115impl PartialEq<&bool> for Borrowed<'_, '_, PyBool> {
116    #[inline]
117    fn eq(&self, other: &&bool) -> bool {
118        self.is_true() == **other
119    }
120}
121
122/// Compare `bool` with `Borrowed<PyBool>`
123impl PartialEq<Borrowed<'_, '_, PyBool>> for bool {
124    #[inline]
125    fn eq(&self, other: &Borrowed<'_, '_, PyBool>) -> bool {
126        *self == other.is_true()
127    }
128}
129
130/// Compare `&bool` with `Borrowed<PyBool>`
131impl PartialEq<Borrowed<'_, '_, PyBool>> for &'_ bool {
132    #[inline]
133    fn eq(&self, other: &Borrowed<'_, '_, PyBool>) -> bool {
134        **self == other.is_true()
135    }
136}
137
138impl<'py> IntoPyObject<'py> for bool {
139    type Target = PyBool;
140    type Output = Borrowed<'py, 'py, Self::Target>;
141    type Error = Infallible;
142
143    #[inline]
144    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
145        Ok(PyBool::new(py, self))
146    }
147
148    #[cfg(feature = "experimental-inspect")]
149    fn type_output() -> TypeInfo {
150        TypeInfo::builtin("bool")
151    }
152}
153
154impl<'py> IntoPyObject<'py> for &bool {
155    type Target = PyBool;
156    type Output = Borrowed<'py, 'py, Self::Target>;
157    type Error = Infallible;
158
159    #[inline]
160    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
161        (*self).into_pyobject(py)
162    }
163
164    #[cfg(feature = "experimental-inspect")]
165    fn type_output() -> TypeInfo {
166        TypeInfo::builtin("bool")
167    }
168}
169
170/// Converts a Python `bool` to a Rust `bool`.
171///
172/// Fails with `TypeError` if the input is not a Python `bool`.
173impl FromPyObject<'_> for bool {
174    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
175        let err = match obj.downcast::<PyBool>() {
176            Ok(obj) => return Ok(obj.is_true()),
177            Err(err) => err,
178        };
179
180        let is_numpy_bool = {
181            let ty = obj.get_type();
182            ty.module().map_or(false, |module| module == "numpy")
183                && ty
184                    .name()
185                    .map_or(false, |name| name == "bool_" || name == "bool")
186        };
187
188        if is_numpy_bool {
189            let missing_conversion = |obj: &Bound<'_, PyAny>| {
190                PyTypeError::new_err(format!(
191                    "object of type '{}' does not define a '__bool__' conversion",
192                    obj.get_type()
193                ))
194            };
195
196            #[cfg(not(any(Py_LIMITED_API, PyPy)))]
197            unsafe {
198                let ptr = obj.as_ptr();
199
200                if let Some(tp_as_number) = (*(*ptr).ob_type).tp_as_number.as_ref() {
201                    if let Some(nb_bool) = tp_as_number.nb_bool {
202                        match (nb_bool)(ptr) {
203                            0 => return Ok(false),
204                            1 => return Ok(true),
205                            _ => return Err(crate::PyErr::fetch(obj.py())),
206                        }
207                    }
208                }
209
210                return Err(missing_conversion(obj));
211            }
212
213            #[cfg(any(Py_LIMITED_API, PyPy))]
214            {
215                let meth = obj
216                    .lookup_special(crate::intern!(obj.py(), "__bool__"))?
217                    .ok_or_else(|| missing_conversion(obj))?;
218
219                let obj = meth.call0()?.downcast_into::<PyBool>()?;
220                return Ok(obj.is_true());
221            }
222        }
223
224        Err(err.into())
225    }
226
227    #[cfg(feature = "experimental-inspect")]
228    fn type_input() -> TypeInfo {
229        Self::type_output()
230    }
231}
232
233#[cfg(test)]
234mod tests {
235    use crate::types::any::PyAnyMethods;
236    use crate::types::boolobject::PyBoolMethods;
237    use crate::types::PyBool;
238    use crate::IntoPyObject;
239    use crate::Python;
240
241    #[test]
242    fn test_true() {
243        Python::with_gil(|py| {
244            assert!(PyBool::new(py, true).is_true());
245            let t = PyBool::new(py, true);
246            assert!(t.extract::<bool>().unwrap());
247            assert!(true.into_pyobject(py).unwrap().is(&*PyBool::new(py, true)));
248        });
249    }
250
251    #[test]
252    fn test_false() {
253        Python::with_gil(|py| {
254            assert!(!PyBool::new(py, false).is_true());
255            let t = PyBool::new(py, false);
256            assert!(!t.extract::<bool>().unwrap());
257            assert!(false
258                .into_pyobject(py)
259                .unwrap()
260                .is(&*PyBool::new(py, false)));
261        });
262    }
263
264    #[test]
265    fn test_pybool_comparisons() {
266        Python::with_gil(|py| {
267            let py_bool = PyBool::new(py, true);
268            let py_bool_false = PyBool::new(py, false);
269            let rust_bool = true;
270
271            // Bound<'_, PyBool> == bool
272            assert_eq!(*py_bool, rust_bool);
273            assert_ne!(*py_bool_false, rust_bool);
274
275            // Bound<'_, PyBool> == &bool
276            assert_eq!(*py_bool, &rust_bool);
277            assert_ne!(*py_bool_false, &rust_bool);
278
279            // &Bound<'_, PyBool> == bool
280            assert_eq!(&*py_bool, rust_bool);
281            assert_ne!(&*py_bool_false, rust_bool);
282
283            // &Bound<'_, PyBool> == &bool
284            assert_eq!(&*py_bool, &rust_bool);
285            assert_ne!(&*py_bool_false, &rust_bool);
286
287            // bool == Bound<'_, PyBool>
288            assert_eq!(rust_bool, *py_bool);
289            assert_ne!(rust_bool, *py_bool_false);
290
291            // bool == &Bound<'_, PyBool>
292            assert_eq!(rust_bool, &*py_bool);
293            assert_ne!(rust_bool, &*py_bool_false);
294
295            // &bool == Bound<'_, PyBool>
296            assert_eq!(&rust_bool, *py_bool);
297            assert_ne!(&rust_bool, *py_bool_false);
298
299            // &bool == &Bound<'_, PyBool>
300            assert_eq!(&rust_bool, &*py_bool);
301            assert_ne!(&rust_bool, &*py_bool_false);
302
303            // Borrowed<'_, '_, PyBool> == bool
304            assert_eq!(py_bool, rust_bool);
305            assert_ne!(py_bool_false, rust_bool);
306
307            // Borrowed<'_, '_, PyBool> == &bool
308            assert_eq!(py_bool, &rust_bool);
309            assert_ne!(py_bool_false, &rust_bool);
310
311            // bool == Borrowed<'_, '_, PyBool>
312            assert_eq!(rust_bool, py_bool);
313            assert_ne!(rust_bool, py_bool_false);
314
315            // &bool == Borrowed<'_, '_, PyBool>
316            assert_eq!(&rust_bool, py_bool);
317            assert_ne!(&rust_bool, py_bool_false);
318            assert_eq!(py_bool, rust_bool);
319            assert_ne!(py_bool_false, rust_bool);
320        })
321    }
322}
pyo3/types/boolobject.rs

pyo3/types/
boolobject.rs
