Exposing Rust Trait Methods to Python

[MillieFD]

Hi everyone,

I’d like to request a feature (or learn about any existing workarounds) for making PyO3 work with Rust trait methods.

Background

Rust traits with default function implementations are a flexible and powerful way to add functionality to multiple structs without duplicating logic. This approach allows function logic to be written once and reused across multiple structs, making maintenance easier and ensuring consistency.

For a minimal example, suppose we have two traits, each providing different functionality:

trait FirstTrait {
    fn function_a(&self) -> String {
        // Some logic
    }
}

trait SecondTrait {
    fn function_b(&self) -> i32 {
        // Some logic
    }
}

Now, we can define a struct and give it access to these two functions by implementing the traits.

struct SomeStruct {
    inner: SomeType,
}

impl FirstTrait for SomeStruct {}

impl SecondTrait for SomeStruct {}

If we wanted to add another struct which only had access to function_a but not function_b, that would be as simple as:

struct AnotherStruct {
    inner: SomeType,
}

impl FirstTrait for SomeStruct {}

// Simply don't implement SecondTrait

If we ever need to update function_a or function_b, the logic only needs to change in one place, and all implementing structs will automatically inherit the updated logic. This is a clean and highly-maintainable approach.

Issue with PyO3

When trying to expose these trait methods to Python using PyO3, I have encountered the following issues:

1. #[pymethods] can’t be applied to a trait impl block.

#[pymethods]
impl FirstTrait for SomeStruct {} // This doesn't work

2. Functions inside the trait cannot be labelled with #[pyfunction]

trait FirstTrait {
    #[pyfunction] // This doesn't work
    fn function_a(&self) -> String {
        // Some logic
    }
}

This may be because #[pyfunction] is intended to work only on static functions which do not take &self? Restricting Self to ensure it is always a struct labelled with #[PyClass] doesn't seem to help.

trait FirstTrait 
where
    Self: PyClass
{
    #[pyfunction] // This still doesn't work
    fn function_a(&self) -> String {
        // Some logic
    }
}

Temporary solution

The only way I can find to expose these methods is by writing boilerplate wrapper methods for each struct.

#[pymethods]
impl SomeStruct {
    fn function_a(&self) -> String {
        FirstTrait::function_a(self)
    }
}

This works, but it undermines the advantages of using traits in the first place. We still have to manually write wrapper methods for each struct, which increases boilerplate and maintenance effort. It seems like these wrappers should be fairly simple to automate?

Feature Request / Workaround?

Is there any way to expose trait methods to Python without needing to write explicit wrapper functions for every implementing struct? If not, do you think it would be possible for PyO3 to support this in a future version?

Thanks,
Millie :)

[MillieFD]

To clarify, I am aware of this previous discussion thread (#3503) and Appendix B from the PyO3 user guide. These both implement boilerplate wrapper functions around each trait function for each struct, which is the temporary solution I am using at the moment.

#[pymethods]
impl SomeStruct {
    fn function_a(&self) -> String {
        FirstTrait::function_a(self)
    }
}

From my perspective, this approach undermines the advantages of using traits in the first place. We still have to manually write wrapper methods for every trait function used by each struct. For large codebases with many structs and traits, this introduces a significant amount of boilerplate and maintenance effort.

Since #3503 is >1 year old, I'm wondering if there has been any progress in this area? If not, is there any practical or ideological reason why this could not be a feature in a future PyO3 release?