Implement FromPyObject and IntoPy Traits for AnyValue

pyo3-polars/Cargo.toml

@@ -11,7 +11,6 @@ description = "Expression plugins and PyO3 types for polars"
 
 [dependencies]
 ciborium = { version = "0.2.1", optional = true }
-polars = { workspace = true, default-features = false }
 polars-core = { workspace = true, default-features = false }
 polars-ffi = { workspace = true, optional = true }
 polars-lazy = { workspace = true, optional = true }
@@ -21,6 +20,12 @@ pyo3-polars-derive = { version = "0.5.0", path = "../pyo3-polars-derive", option
 serde = { version = "1", optional = true }
 serde-pickle = { version = "1", optional = true }
 thiserror = "1"
+once_cell = "1"
+itoa = "1.0.6"
+
+[dependencies.polars]
+workspace = true
+features = ["dtype-full"]
 
 [features]
 lazy = ["polars/serde-lazy", "polars-plan", "polars-lazy/serde", "ciborium"]

pyo3-polars/src/gil_once_cell.rs

@@ -0,0 +1,34 @@
+use std::cell::UnsafeCell;
+
+use pyo3::{PyResult, Python};
+
+// Adapted from PYO3 with the only change that
+// we allow mutable access with when the GIL is held
+
+pub struct GILOnceCell<T>(UnsafeCell<Option<T>>);
+
+// T: Send is needed for Sync because the thread which drops the GILOnceCell can be different
+// to the thread which fills it.
+unsafe impl<T: Send + Sync> Sync for GILOnceCell<T> {}
+unsafe impl<T: Send> Send for GILOnceCell<T> {}
+
+impl<T> GILOnceCell<T> {
+    /// Create a `GILOnceCell` which does not yet contain a value.
+    pub const fn new() -> Self {
+        Self(UnsafeCell::new(None))
+    }
+
+    /// as long as we have the GIL we can mutate
+    /// this creates a context that checks that.
+    pub fn with_gil<F, O>(&self, _py: Python<'_>, mut op: F) -> PyResult<O>
+    where
+        F: FnMut(&mut T) -> PyResult<O>,
+    {
+        // Safe because GIL is held, so no other thread can be writing to this cell concurrently.
+        let inner = unsafe { &mut *self.0.get() }
+            .as_mut()
+            .expect("not yet initialized");
+
+        op(inner)
+    }
+}