Passing rust defined struct to other crate, from Python

[GasPasChaud]

I have a mono-repo on which I'm working on with various sub packages. One of those sub package is a rust/python mixed PyO3 project (thanks for the amazing work BTW).

I can interact as expected with my Rust code from Python. It turns out that one of the struct defined in rust is pretty useful for other sub package. I tried creating a second sub project shared that exposes common models to the other sub packages.

Assuming the following structure:

shared/
├─ Cargo.toml
├─ src/
│  ├─ lib.rs
computation_1/
├─ Cargo.toml
├─ src/
│  ├─ lib.rs
├─ python/
│  ├─ computation_1/
│  │  ├─ __init__.py
│  │  ├─ main.py
computation_2/

If I define in shared/lib.rs a very simple struct, for instance:

use pyo3::prelude::*;

#[pyclass(subclass, get_all, set_all)]
#[derive(FromPyObject)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}

#[pymethods]
impl Point {
    #[new]
    pub fn new(x: f64, y: f64) -> Self {
        Point { x, y }
    }
}

I can use it in computation_1/src/lib.rs like so:

use pyo3::prelude::*;
use shared::Point;

#[pyfunction]
pub fn get_distance(point1: &PyAny, point2: &PyAny) -> PyResult<f64> {
    let point1: Point = point1.extract::<Point>()?;
    let point2: Point = point2.extract::<Point>()?;
    Ok(((point1.x - point2.x).powi(2) + (point1.y - point2.y).powi(2)).sqrt())
}

and call it from computation_1/python/computation_1/main.py

from shared import Point
from computation_1 import get_distance

print(get_distance(Point(0, 0), Point(1, 1)))

However with more complex structs, that for example require to have Clone derived I cannot derive FromPyObject without this error:

 #[derive(FromPyObject, Clone, Debug)]
   |          ^^^^^^^^^^^^
   |
   = note: conflicting implementation in crate `pyo3`:
           - impl<'a, T> pyo3::FromPyObject<'a> for T
             where T: PyClass, T: Clone;

If I don't derive FromPyObject, I get a TypeError:

TypeError: 'SomeStruct' object cannot be converted to 'SomeStruct'

Note that the SomeStruct are both originating from shared. I can use it in computation_1's rust code, I can use it in Python but I cannot pass it as an argument from Python to Rust.

I think I'm doing something wrong, here are my questions:

1. Is there any other way to have a rust create, bound to Python, but that is also a dependency to another rust crate (also bound to Python)?
2. Why can't I derive from FromPyObject and Clone?

I'm sorry if I missed something obvious. I haven't found anything anywhere.

Thanks in advance

PS: I would have defined SomeStruct in computation_1 if it wasn't used by other folders (for example computation_2 that is just a python project, that is independent from computation_1.

[davidhewitt]

1. Unfortunately multiple packages is very difficult to make work, the issue is tracked in Sharing pyclasses between multiple Rust packages #1444. My recommendation is you build a single python package if possible.
2. There is a blanket impl<T> FromPyObject for T: PyClass + Clone, which clones the data out of the Python object. You're conflicting with that implementation. This blanket has proved to be a mixed bag; in some ways it is very convenient but it has weakened error messages and also created situations like this.

[GasPasChaud]

Thank you @davidhewitt for your answer. I'll make changes to my project structure accordingly !