fix: Fix RuntimeError when serializing the same DataFrame from multiple threads (#22844)

Author: nameexhaustion

crates/polars-python/src/dataframe/serde.rs

@@ -6,18 +6,28 @@ use polars_io::mmap::ReaderBytes;
 use pyo3::prelude::*;
 
 use super::PyDataFrame;
+use crate::error::PyPolarsErr;
 use crate::exceptions::ComputeError;
 use crate::file::{get_file_like, get_mmap_bytes_reader};
 use crate::utils::EnterPolarsExt;
 
 #[pymethods]
 impl PyDataFrame {
     /// Serialize into binary data.
-    fn serialize_binary(&mut self, py: Python<'_>, py_f: PyObject) -> PyResult<()> {
+    fn serialize_binary(slf: Bound<'_, Self>, py_f: PyObject) -> PyResult<()> {
         let file = get_file_like(py_f, true)?;
         let mut writer = BufWriter::new(file);
 
-        py.enter_polars(|| self.df.serialize_into_writer(&mut writer))
+        let mut slf_1 = slf.try_borrow_mut();
+        let slf_1: Result<&mut PyDataFrame, _> = slf_1.as_deref_mut();
+        let mut slf_2: Option<PyDataFrame> = (slf_1.is_err()).then(|| (*slf.borrow()).clone());
+
+        let slf: &mut PyDataFrame = slf_1.unwrap_or_else(|_| slf_2.as_mut().unwrap());
+
+        Ok(slf
+            .df
+            .serialize_into_writer(&mut writer)
+            .map_err(PyPolarsErr::from)?)
     }
 
     /// Deserialize a file-like object containing binary data into a DataFrame.

py-polars/tests/unit/dataframe/test_serde.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import io
+import pickle
 from datetime import date, datetime, timedelta
 from decimal import Decimal as D
+from multiprocessing.pool import ThreadPool
 from typing import TYPE_CHECKING, Any
 
 import pytest
@@ -211,3 +213,10 @@ def test_df_serde_list_of_null_17230() -> None:
     ser = df.serialize(format="json")
     result = pl.DataFrame.deserialize(io.StringIO(ser), format="json")
     assert_frame_equal(result, df)
+
+
+def test_df_serialize_from_multiple_python_threads_22364() -> None:
+    df = pl.DataFrame({"A": [1, 2, 3, 4]})
+
+    with ThreadPool(4) as tp:
+        tp.map(pickle.dumps, [df] * 1_000)