How to implement IntoPyObject for a class which extends a base class?

[tesujimath]

The docs for IntoPyObject quite tantalisingly say

This trait defines the to-python conversion for a Rust type. All types in PyO3 implement this trait, as does a #[pyclass] which doesn't use extends.

But I didn't find anywhere a description of how to deal with a class which does extend a base class.

Here's my class Transaction with its subclass Directive:

/// Beancount directive base class.
#[derive(Debug)]
#[pyclass(frozen, subclass)]
pub(crate) struct Directive {
    #[pyo3(get)]
    pub(crate) date: Py<PyDate>,
    #[pyo3(get)]
    pub(crate) metadata: Option<Metadata>,
}

/// Beancount transaction directive.
#[derive(Debug)]
#[pyclass(frozen, extends=Directive)]
pub(crate) struct Transaction {
    #[pyo3(get)]
    pub(crate) flag: Py<PyString>,
    #[pyo3(get)]
    pub(crate) payee: Option<Py<PyString>>,
    #[pyo3(get)]
    pub(crate) narration: Option<Py<PyString>>,
    #[pyo3(get)]
    pub(crate) postings: Vec<Posting>,
}

and here's my legacy conversion which works nicely in PyO3 0.22, which I need to adapt to use .into_pyobject() since .into_py() is now deprecated.

    pub(crate) fn transaction(
        &mut self,
        py: Python<'_>,
        date: &Date,
        metadata: &lima::Metadata,
        x: &lima::Transaction<'_>,
    ) -> PyResult<Py<PyAny>> {
        let flag = self.flag(py, x.flag().item());
        let payee = x
            .payee()
            .map(|payee| self.string.create_or_reuse(py, payee.item()));
        let narration = x
            .narration()
            .map(|narration| self.string.create_or_reuse(py, narration.item()));
        let postings = x
            .postings()
            .map(|p| self.posting(py, p))
            .collect::<PyResult<Vec<_>>>()?;

        Ok(Py::new(
            py,
            (
                Transaction {
                    flag,
                    payee,
                    narration,
                    postings,
                },
                self.directive(py, date, metadata)?,
            ),
        )?
        .into_py(py))
    }

And self.directive() is this:

    pub(crate) fn directive(
        &mut self,
        py: Python<'_>,
        date: &Date,
        metadata: &lima::Metadata,
    ) -> PyResult<Directive> {
        Ok(Directive {
            date: self.date.create_or_reuse(py, date),
            metadata: self.metadata(py, metadata)?,
        })
    }

I could really do with a pointer towards how to do this now!

In case it helps, my source code is here.

[Icxolu]

Since you already use Py::new you already have a Python object and there is no need to use IntoPyObject. You should be able to just
replace your into_py call with into_any to remove the type info.

---

Previously IntoPy for Py was just throwing away the type information. IntoPyObject is also implemented for Py but now keeps the type information. IntoPyObjectExt also provides a few helpers for common type conversions.

[tesujimath]

Ah yes, thank you, that works nicely. 😄