# basic.rs - source
Source of the Rust file `/home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/pyo3-0.13.2/src/class/basic.rs`.
Keywords: rust, rustlang, rust-lang

      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
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205

    // Copyright (c) 2017-present PyO3 Project and Contributors

    //! Basic Python Object customization
    //!
    //! Check [the Python C API information](https://docs.python.org/3/reference/datamodel.html#basic-customization)
    //! for more information.
    //!
    //! Parts of the documentation are copied from the respective methods from the
    //! [typeobj docs](https://docs.python.org/3/c-api/typeobj.html)

    use crate::callback::{HashCallbackOutput, IntoPyCallbackOutput};
    use crate::{exceptions, ffi, FromPyObject, PyAny, PyCell, PyClass, PyObject};
    use std::os::raw::c_int;

    /// Operators for the __richcmp__ method
    #[derive(Debug)]
    pub enum CompareOp {
        Lt = ffi::Py_LT as isize,
        Le = ffi::Py_LE as isize,
        Eq = ffi::Py_EQ as isize,
        Ne = ffi::Py_NE as isize,
        Gt = ffi::Py_GT as isize,
        Ge = ffi::Py_GE as isize,
    }

    /// Basic Python class customization
    #[allow(unused_variables)]
    pub trait PyObjectProtocol<'p>: PyClass {
        fn __getattr__(&'p self, name: Self::Name) -> Self::Result
        where
            Self: PyObjectGetAttrProtocol<'p>,
        {
            unimplemented!()
        }

        fn __setattr__(&'p mut self, name: Self::Name, value: Self::Value) -> Self::Result
        where
            Self: PyObjectSetAttrProtocol<'p>,
        {
            unimplemented!()
        }

        fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result
        where
            Self: PyObjectDelAttrProtocol<'p>,
        {
            unimplemented!()
        }

        fn __str__(&'p self) -> Self::Result
        where
            Self: PyObjectStrProtocol<'p>,
        {
            unimplemented!()
        }

        fn __repr__(&'p self) -> Self::Result
        where
            Self: PyObjectReprProtocol<'p>,
        {
            unimplemented!()
        }

        fn __format__(&'p self, format_spec: Self::Format) -> Self::Result
        where
            Self: PyObjectFormatProtocol<'p>,
        {
            unimplemented!()
        }

        fn __hash__(&'p self) -> Self::Result
        where
            Self: PyObjectHashProtocol<'p>,
        {
            unimplemented!()
        }

        fn __bytes__(&'p self) -> Self::Result
        where
            Self: PyObjectBytesProtocol<'p>,
        {
            unimplemented!()
        }

        fn __richcmp__(&'p self, other: Self::Other, op: CompareOp) -> Self::Result
        where
            Self: PyObjectRichcmpProtocol<'p>,
        {
            unimplemented!()
        }
        fn __bool__(&'p self) -> Self::Result
        where
            Self: PyObjectBoolProtocol<'p>,
        {
            unimplemented!()
        }
    }

    pub trait PyObjectGetAttrProtocol<'p>: PyObjectProtocol<'p> {
        type Name: FromPyObject<'p>;
        type Result: IntoPyCallbackOutput<PyObject>;
    }
    pub trait PyObjectSetAttrProtocol<'p>: PyObjectProtocol<'p> {
        type Name: FromPyObject<'p>;
        type Value: FromPyObject<'p>;
        type Result: IntoPyCallbackOutput<()>;
    }
    pub trait PyObjectDelAttrProtocol<'p>: PyObjectProtocol<'p> {
        type Name: FromPyObject<'p>;
        type Result: IntoPyCallbackOutput<()>;
    }
    pub trait PyObjectStrProtocol<'p>: PyObjectProtocol<'p> {
        type Result: IntoPyCallbackOutput<PyObject>;
    }
    pub trait PyObjectReprProtocol<'p>: PyObjectProtocol<'p> {
        type Result: IntoPyCallbackOutput<PyObject>;
    }
    pub trait PyObjectFormatProtocol<'p>: PyObjectProtocol<'p> {
        type Format: FromPyObject<'p>;
        type Result: IntoPyCallbackOutput<PyObject>;
    }
    pub trait PyObjectHashProtocol<'p>: PyObjectProtocol<'p> {
        type Result: IntoPyCallbackOutput<HashCallbackOutput>;
    }
    pub trait PyObjectBoolProtocol<'p>: PyObjectProtocol<'p> {
        type Result: IntoPyCallbackOutput<bool>;
    }
    pub trait PyObjectBytesProtocol<'p>: PyObjectProtocol<'p> {
        type Result: IntoPyCallbackOutput<PyObject>;
    }
    pub trait PyObjectRichcmpProtocol<'p>: PyObjectProtocol<'p> {
        type Other: FromPyObject<'p>;
        type Result: IntoPyCallbackOutput<PyObject>;
    }

    py_unary_func!(str, PyObjectStrProtocol, T::__str__);
    py_unary_func!(repr, PyObjectReprProtocol, T::__repr__);
    py_unary_func!(hash, PyObjectHashProtocol, T::__hash__, ffi::Py_hash_t);

    #[doc(hidden)]
    pub unsafe extern "C" fn getattr<T>(
        slf: *mut ffi::PyObject,
        arg: *mut ffi::PyObject,
    ) -> *mut ffi::PyObject
    where
        T: for<'p> PyObjectGetAttrProtocol<'p>,
    {
        crate::callback_body!(py, {
            // Behave like python's __getattr__ (as opposed to __getattribute__) and check
            // for existing fields and methods first
            let existing = ffi::PyObject_GenericGetAttr(slf, arg);
            if existing.is_null() {
                // PyObject_HasAttr also tries to get an object and clears the error if it fails
                ffi::PyErr_Clear();
            } else {
                return Ok(existing);
            }

            let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
            let arg = py.from_borrowed_ptr::<PyAny>(arg);
            call_ref!(slf, __getattr__, arg).convert(py)
        })
    }

    #[doc(hidden)]
    pub unsafe extern "C" fn richcmp<T>(
        slf: *mut ffi::PyObject,
        arg: *mut ffi::PyObject,
        op: c_int,
    ) -> *mut ffi::PyObject
    where
        T: for<'p> PyObjectRichcmpProtocol<'p>,
    {
        crate::callback_body!(py, {
            let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
            let arg = extract_or_return_not_implemented!(py, arg);
            let op = match op {
                ffi::Py_LT => CompareOp::Lt,
                ffi::Py_LE => CompareOp::Le,
                ffi::Py_EQ => CompareOp::Eq,
                ffi::Py_NE => CompareOp::Ne,
                ffi::Py_GT => CompareOp::Gt,
                ffi::Py_GE => CompareOp::Ge,
                _ => {
                    return Err(exceptions::PyValueError::new_err(
                        "tp_richcompare called with invalid comparison operator",
                    ))
                }
            };

            slf.try_borrow()?.__richcmp__(arg, op).convert(py)
        })
    }

    py_func_set!(setattr, PyObjectSetAttrProtocol, T::__setattr__);
    py_func_del!(delattr, PyObjectDelAttrProtocol, T::__delattr__);
    py_func_set_del!(
        setdelattr,
        PyObjectSetAttrProtocol,
        PyObjectDelAttrProtocol,
        Self,
        __setattr__,
        __delattr__
    );
    py_unary_func!(bool, PyObjectBoolProtocol, T::__bool__, c_int);