how to return importable Union Type from Function

[BenediktMaag]

Let's say i have function that can either return a string or an int, i would define the function to return a Py.

The rust code might look something like this:

#[pyfunction]
fn get_string_or_number() -> Py<PyAny>

I want to make it known to my package users how to use the api, so I'm creating a type stub __init__.pyi:

def get_string_or_number() -> str | int

Since the actual usecase would consider more variants i want to create a type union:

MyReturnType = str | int

def get_string_or_number() -> MyReturnType

If my users want to use my function they could do:

from mymodule import get_string_or_number

if they have a function that forwards my type, they might want to do something like:

from mymodule import get_string_or_number, MyReturnType

def user_function() -> MyReturnType:
    return get_string_or_number()

This will satisfy the type checker but fail at runtime because the rust plugin does not actually expose the union typedefinition.

Is this currently even possible? I had two ideas but they both are limited and dont seem to work as wanted:

• Implement MyReturnType as an enum annotated by #[pyclass]

#[pyclass]
enum MyReturnType {
    Int(usize),                    // input is a positive int
    String(String),                // input is a string
}

#[pyfunction]
fn get_string_or_number() -> MyReturnType {...}

This will return e.g. an MyReturnType_Int but I don't kow how to directly return the inner of the enum:

>>> from mymodule import get_string_or_number, MyReturnType
>>>
>>> isinstance(get_string_or_number(), MyReturnType)
True
>>> isinstance(get_string_or_number()._0, MyReturnType) # inner value with ._0
False

The other possibility is deriving IntoPyObject:

#[derive(IntoPyObject]
enum MyReturnType {
    Int(usize),                    // input is a positive int
    String(String),                // input is a string
}

But this will stop me from adding MyReturnType to my module since it is not a class anymore.