Converting subclass to superclass within Rust

[campbellcole]

I have three classes implemented:

#[pyclass]
pub struct BaseCard;

#[pyclass(extends=BaseCard)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Card {
    #[pyo3(get, set)]
    pub rank: Rank,
    #[pyo3(get, set)]
    pub suit: Suit,
}

#[pymethods]
impl Card {
    #[new]
    fn new(rank: Rank, suit: Suit) -> (Self, BaseCard) {
        (Self { rank, suit }, BaseCard)
    }
}

#[pyclass(extends=BaseCard)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Joker {
    #[pyo3(get, set)]
    pub color: JokerColor,
}

#[pymethods]
impl Joker {
    #[new]
    fn new(color: JokerColor) -> (Self, BaseCard) {
        (Self { color }, BaseCard)
    }
}

I am trying to write a static function on the BaseCard class which returns a full deck of cards:

#[pymethods]
impl BaseCard {
    #[staticmethod]
    fn all_cards(py: Python<'_>) -> Vec<BaseCard> {
        let mut cards = Vec::new();
        // create Card instances and convert them to BaseCard
        for rank in Rank::iter() {
            for suit in Suit::iter() {
                // create a Card instance and convert it to BaseCard
            }
        }
        // ... create two Joker instances and convert them to BaseCard
        cards
    }
}

I know I can't directly return a BaseCard, but I have tried lots of combinations of Py, PyRef, PyAny, and I just can't seem to do it.

Perhaps inevitably, while trying some other things after writing this I managed to solve the issue. I would still like to post this as a discussion because it took me a few hours to figure this out and I only figured it out due to pure luck. Perhaps I'm not reading the documentation very well, but this was not at all intuitive for me. I generalized the approach I am using into a function which does it all in one:

pub fn as_super<T>(py: Python<'_>, val: impl Into<PyClassInitializer<T>>) -> PyResult<Py<PyAny>>
where
    T: PyClass,
    <T as pyo3::impl_::pyclass::PyClassImpl>::BaseType: pyo3::PyClass,
{
    Py::new(py, val).map(|pyt| pyt.borrow(py).into_super().into_py(py))
}

This function does exactly what I was trying to do. The problem I was having with this approach earlier is that I didn't know about the into_py function, and was trying to use the return value of into_super, which ended up with me trying to hold a reference past its owners lifetime. I'm still not very clear on how this avoids that, but I am still reading so maybe I will understand better soon.