How come the 'transparent' option is not available when using the pyclass macro?

[flotang-gtt]

Mostly my question revolves around the good old "am I missing something?", I am not very experienced.

Thisis an enum with a few unit variants, all of them unit enums. I started out with the following, but ran into the issues that (correctly) the type of those variants is Cuisine_Italian... etc, but I want them to be transparent. Luckily I read that this exists - but I was surprised it does not work when using the pyclass proc macro?

#[derive(PartialEq, Clone, PartialOrd)]
#[pyclass(eq, ord, module = "cuisine")]

pub enum Cuisine {
    Italian(PastaType),
    Mexican(TacoVariety),
    Japanese(SushiStyle),
    Indian(CurryFlavor),
    French(WinePairing),
}

Now, this works fine. But I do not know what I am missing between the switch from pyclass to simply using the IntoPyObject trait.

#[derive(PartialEq, Clone, PartialOrd, IntoPyObject, FromPyObject)] // FromPyObject probably not needed
// #[pyo3(eq, ord, module = "cuisine")]

pub enum Cuisine {
    #[pyo3(transparent)]
    Italian(PastaType),
    #[pyo3(transparent)]
    Mexican(TacoVariety),
    #[pyo3(transparent)]
    Japanese(SushiStyle),
    #[pyo3(transparent)]
    Indian(CurryFlavor),
    #[pyo3(transparent)]
    French(WinePairing),
}

Now, how, forgive me if I do not know about the differences in the macros - is the lower one basically doing everything similarly? I take it the eq that is available on the Python side is a given (given that the variants are all unit enums)?

[Icxolu]

The two macros are quite different. #[pyclass] does a lot more than simply deriving FromPyObject and IntoPyObject.

In this case the former creates a class hierarchy with a base class Cuisine and "child" classes for each variant inheriting from it.

class Cuisine:
   Italian: Italian = ...
   ...
class Italian(Cuisine):
   ...

Each variant class then contains the fields of the variant.

The #[derive(IntoPyObject)] will not define any class at all. In your example it will simply match on the enum and forward to the IntoPyObject impl of the inner type, something like the following.

impl<'py> IntoPyObject<'py> for Cuisine {
    type Target = PyAny;
    type Output = Bound<'py, Self::Target>;
    type Error = PyErr;

    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
        match self {
            Cuisine::Italian(arg) => {
                Ok(arg.into_pyobject(py)?.into_any()) // you will get what ever `PastaType` turns into
            }
            ...
        }
    }
}