Difficulty understanding function signatures for supported Rust types

[auspicacious]

I'm having difficultly understanding how to define a function signature for many of the built-in Rust types.

I'm trying to expose a function from Rust to Python that includes a std::path::Path. It looks a bit like this:

use pyo3::prelude::*;
// ...
#[pyfunction]
pub fn accept_path(
    output_dir: &Path,
) -> Result<()> {
    // ...
}

and the error I'm getting is this:

error[E0277]: the trait bound `&std::path::Path: pyo3::impl_::extract_argument::PyFunctionArgument<'_, '_, false>` is not satisfied
   --> src/python_api.rs:50:17
    |
50  |     output_dir: &Path,
    |                 ^ the trait `pyo3::PyClass` is not implemented for `&std::path::Path`

If I change the signature to &str, it works, but pyo3's documentation says that there is a built-in mapping for Path.

I ran into a similar problem for a struct method that I wanted to have accept a std::time::Duration, which I was able to fix with this convoluted structure, but I don't understand why it works and I can't find the part of the documentation that explains why. For that matter, I haven't gotten as far as testing to see if it actually works, only compiles.

fn accept_duration(&self, my_duration: &Bound<'_, PyAny>) -> Result<()> {
        let extracted_my_duration: Duration = my_duration.extract()?;
}

The same approach did not work for Path.

Most of the examples in the pyo3 documentation use very simple types, and when I looked at a few of the simpler projects listed as uing pyo3, I couldn't find anyone doing what I was doing. I would appreciate any pointers.

[Icxolu]

Generally you can accept anything which implements FromPyObject as an argument of a pyfunction. There are however only a limited number of types that can safely borrow from Python (&str, &[u8], Cow<str>, Cow<[u8]> and &T for T: PyClass). For &Path (any many other borrowing types) we can't provide a universal implementation, so you have to resort to the owned PathBuf. (We do provide the other direction, turning &Path into a Python object, which is probably the reason it is in the table.)

Duration should work just fine, assuming you take it by value:

#[pyfunction]
fn accept_duration(my_duration: std::time::Duration) -> PyResult<()> {
    todo!()
}

(This is basically a simpler version of what you did above)

[auspicacious]

Thank you, this answer makes things much clearer and improves my understanding of Rust in general. I had suspected borrowing might be part of what was happening.