FromPyObject, IntoPy and ToPyObject for subclasses

[CLOVIS-AI]

Hello! First, thanks for the amazing work, this library is impressive.

I currently have something similar to this:

enum Inside {
    First,
    Second,
}

struct Outside {
  inside: Inside,
}

Which is exposed to Python as sub-classes:

#[pyclass(subclass)]
struct Base {
  inner: Outside,
}

#[pyclass(extends = Base)]
struct First;

#[pyclass(extends = Base)]
struct Second;

I'm omitting the impl blocks (no issues with them, following the documentation).

I'd like to be able to declare #[pymethods] that take Outsides as parameters, or that return them.
Therefore, I'm trying to implement FromPyObject, etc, for Outside.
However, I'm stuck with trying to implement them:

impl<'a> FromPyObject<'a> for Outside {
  fn extract(arg: &'a PyAny) -> PyResult<Outside> {
    if let Some(first) = First::extract(arg) {
      // I now have a 'First'
      // I'd like to access 'Base.inner'
      // The only way I found in the documentation is with a PyRef<First>...
      // but how can I get a PyRef<First> here?
    } else { ... }
  }
}

Is there another method similar to extract that would also give a reference to the parent class? Or is there any other way to access the parent class from the child?

[CLOVIS-AI]

Of course, after an hour of searching, I find the solution immediately after posting.

For future reference, this works:

impl<'a> FromPyObject<'a> for Outside {
  fn extract(arg: &'a PyAny) -> PyResult<Outside> {
    if let Some(first) = PyRef::<First>::extract(arg) {
      // first is now a PyRef<First>
      // it's possible to get the base class' fields using get_ref(), as explained in the doc
    } else { ... }
  }
}

Now, I just need to find how to do the same for IntoPy.

[CLOVIS-AI]

fn foo(py: Python) -> PyObject {
    PyClassInitializer::from(BaseClass {…})
        .add_subclass(SubClass {…})
        .into_py(py)
}

Fails on into_py:

    = note: the following trait bounds were not satisfied:
            `pyo3::PyClassInitializer<SubClass>: AsPyPointer`
            which is required by `&pyo3::PyClassInitializer<SubClass>: pyo3::IntoPy<Py<pyo3::PyAny>>`

[CLOVIS-AI]

Is it actually possible to implement IntoPy for classes with extends at all? All the examples I can find are using the constructor to generate the instance... but there can't be two constructors, can there?

[CLOVIS-AI]

So far the best I have is:

PyClassInitializer::from(BaseClass {})
    .add_subclass(SubClass {})
    .create_cell(py).unwrap() // returns *mut Call<SubClass>
    .as_ref().unwrap() // unsafe!
    .into_py(py);

Is this safe?

[davidhewitt]

I think you should probably use Py::from_owned_ptr(initialiser.create_cell(py)?) to avoid leaking memory produced by create_cell. As said earlier, this is a really janky API and I'd be glad to improve this sometime.

[CLOVIS-AI]

Thanks for the reply, I'll use that, then.

I have no experience with unsafe Rust (FFI, raw pointers), so I'm not sure I can be of much use for the moment... I'll probably revisit this in a few months.

[messense]

Just encountered this, and the code I used is

let initializer = PyClassInitializer::from(BaseClass {}).add_subclass(Subclass {});
Py::new(py, initializer)?.into_py(py)

Not sure if it's the best way to do this, but it's much simpler.