How do I set a new value for the dereferenced raw ffi pointer?

[jymchng]

I am trying to write a descriptor, cached_property with a .setter method.

#[pyclass(name = "cached_property")]
pub struct PropertyGetter {
    pub pv: HashMap<usize, *mut pyo3_ffi::PyObject>,
    pub fget: Py<PyAny>,
    pub fset: Option<Py<PyAny>>,
    pub fdel: Option<Py<PyAny>>,
}

#[pymethods]
impl PropertyGetter {
    #[new]
    fn __new__(fget: &PyAny) -> PyResult<PropertyGetter> {
        Ok(PropertyGetter {
            pv: HashMap::default(),
            fget: fget.into(),
            fset: None,
            fdel: None,
        })
    }

    fn __get__(
        &mut self,
        instance: &PyAny,
        _owner: Option<&PyType>,
    ) -> PyResult<Py<PyAny>> {
        let this_py = instance.py();
        let this_key: usize = instance.as_ptr() as usize;
        if !self.pv.contains_key(&this_key) {
            let insert = self.fget.call1(this_py, PyTuple::new(this_py, vec![instance]))?;
            self.pv.insert(this_key, insert.as_ptr());
        }
        let ret_val = *&self.pv.get(&this_key).unwrap();
        Ok(unsafe {Py::from_borrowed_ptr(this_py, *ret_val)})
    }

    fn __set__(&mut self, instance: &PyAny, new_value: &PyAny) -> PyResult<()> {
        let this_py = instance.py();
        let this_key: usize = instance.as_ptr() as usize;
        if let Some(fset) = &self.fset {
            fset.call1(this_py, PyTuple::new(this_py, vec![instance, new_value]))?;
        } else {
            // unwrap on a Option<*mut pyo3_ffi::PyObject>, then de
            *self.pv.get_mut(&this_key).unwrap() = new_value.as_ptr();
        }
        Ok(())
    }

    fn __delete__(&mut self, instance: &PyAny) -> PyResult<()> {
        let this_py = instance.py();
        let this_key: usize = instance.as_ptr() as usize;
        if let Some(fdel) = &self.fdel {
            fdel.call1(this_py, PyTuple::new(this_py, vec![instance]))?;
            self.pv.remove(&this_key);
        } else {
            self.pv.remove(&this_key);
        }
        Ok(())
    }


    pub fn setter(&mut self, fset: &PyAny) -> PyResult<PropertyGetter> {
        let py = fset.py();
        match &self.fdel {
            Some(fdel) => {
                Ok(PropertyGetter {
                    pv: HashMap::default(),
                    fget: Py::clone_ref(&self.fget, py),
                    fset: Some(fset.into()),
                    fdel: Some(Py::clone_ref(&fdel, py)),
                })
            },
            None => Ok(PropertyGetter {
                pv: HashMap::default(),
                fget: Py::clone_ref(&self.fget, py),
                fset: Some(fset.into()),
                fdel: None,
            })
        }    
    }

    pub fn deleter(&mut self, fdel: &PyAny) -> PyResult<PropertyGetter> {
        let py = fdel.py();
        match &self.fset {
            Some(fset) => {
                Ok(PropertyGetter {
                    pv: HashMap::default(),
                    fget: Py::clone_ref(&self.fget, py),
                    fset: Some(Py::clone_ref(&fset, py)),
                    fdel: Some(fdel.into()),
                })
            },
            None => Ok(PropertyGetter {
                pv: HashMap::default(),
                fget: Py::clone_ref(&self.fget, py),
                fset: None,
                fdel: Some(fdel.into()),
            })
        } 
    }
}

Here are the testing codes:

import pytest
from cached_property import cached_property
import time
from timeit import timeit


class PersonTwo:

    def __init__(self, name: str) -> None:
        self._name = name

    @cached_property
    def name(self):
        print("Sleeping for 2 seconds...")
        time.sleep(2)
        return self._name # storing `*mut pyo3_ffi::PyObject` to track this variable

    @name.setter
    def name(self, new_name):
        time.sleep(2)
        print("Sleeping for 2 seconds...")
        if not isinstance(new_name, str):
            raise ValueError
        self._name = new_name

def test___set__method_working(person_two_james, capfd):
    assert person_two_james.name == 'James'
    person_two_james.name = 'Thomas'
    out, err = capfd.readouterr()
    print(out)
    # caches immediately
    assert timeit(lambda: person_two_james.name, number=10) < 1
    print(person_two_james.name)
    assert person_two_james.name == 'Thomas'  # test fails here

The test test___set__method_working failed at assert person_two_james.name == 'Thomas' as person_two_james.name='James' instead of 'Thomas'. In __set__, how should I write for the case that fset is Option::<Py<PyAny>>::None? I.e. how do I exchange the values behind two raw pointers *mut pyo3_ffi::PyObject?