How to make 3rd party rust types available to the VM #5459

Activity

1. youknowone commented on Dec 20, 2024

   

   youknowone

   on Dec 20, 2024

   Member

   More actions

   Still RustStruct in the call_between_rust_and_python is the best option. You have to wrap a rust type to make a python type.
   The inner rust type can be literally any type, though they requires different wrapping strategy.
   Please share the details how you are blocked by building on top of call_between_rust_and_python. Then I could understand the situation better.
2. directindex commented on Dec 20, 2024

   

   directindex

   on Dec 20, 2024

   Last edited by directindex

   Author

   More actions

   Thanks for getting back.

   I can't implement the TryFromBorrowedObject trait for MyLazyFrame as LazyFrame doesn't implement TryFromBorrowedObject, and I can't implement the trait myself as it's from an external crate.

   See the comment in the snippet.

   use polars::prelude::*;
   
   #[pyattr]
   #[pyclass(module = "rust_py_module", name = "LazyFrame")]
   #[derive(PyPayload)]
   pub struct MyLazyFrame {
       pub lazy_frame: LazyFrame,
   }
   
   #[pyclass]
   impl MyLazyFrame {
       #[pygetset]
       fn select(self, columns: Vec<String>) -> self {
           let cols = columns.iter().map(|c| col(c)).collect();
   
           MyLazyFrame {
               lazy_frame: self.lazy_frame.select(cols),
           }
       }
   }
   
   impl<'a> TryFromBorrowedObject<'a> for MyLazyFrame {
       fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
           // this doesn't work as Trait `TryFromBorrowedObject` is not implemented for `LazyFrame` 
           let lazy_frame = obj.get_attr("lazy_frame", vm)?.try_into_value::<LazyFrame>(vm)?; 
           Ok(MyLazyFrame { lazy_frame })
       }
   }
3. youknowone commented on Jan 9, 2025

   

   youknowone

   on Jan 9, 2025

   Member

   More actions

   LazyFrame is not a Python type and only MyLazyFrame is. You can neither do obj.get_attr("lazy_frame", vm) nor try_into_value::<LazyFrame>(vm).
   I just realized the example is confusing because python code and rust code shares same field name.

   This is probably the flow you are looking for.

   // MyLazyFrame is already a Python type. You don't need any conversion.
   impl<'a> TryFromObject<'a> for LazyFrame {
       // the `obj` here must be a `MyLazyFrame` object.
       fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
           let frame: PyRef<MyLazyFrame> = obj.try_to_value::<MyLazyFrame>(vm)?;
           Ok(frame.lazy_frame.clone())
       }
   }

   If you don't need to retrieve a LazyFrame object directly, you don't need to implement it.
   downcast, try_to_value, try_to_ref will work for MyLazyFrame without additional work.