diff --git a/crates/polars-plan/src/dsl/python_udf.rs b/crates/polars-plan/src/dsl/python_udf.rs
index efefa5e228af..d30bbc5e29a6 100644
--- a/crates/polars-plan/src/dsl/python_udf.rs
+++ b/crates/polars-plan/src/dsl/python_udf.rs
@@ -6,6 +6,7 @@ use polars_core::error::*;
 use polars_core::frame::DataFrame;
 use polars_core::prelude::Series;
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedBytes;
 use pyo3::types::PyBytes;
 #[cfg(feature = "serde")]
 use serde::ser::Error;
@@ -67,9 +68,9 @@ impl Serialize for PythonFunction {
             let dumped = pickle
                 .call1((python_function,))
                 .map_err(|s| S::Error::custom(format!("cannot pickle {s}")))?;
-            let dumped = dumped.extract::<&PyBytes>().unwrap();
+            let dumped = dumped.extract::<PyBackedBytes>().unwrap();
 
-            serializer.serialize_bytes(dumped.as_bytes())
+            serializer.serialize_bytes(&dumped)
         })
     }
 }
@@ -192,8 +193,8 @@ impl SeriesUdf for PythonUdfExpression {
             let dumped = pickle
                 .call1((self.python_function.clone(),))
                 .map_err(from_pyerr)?;
-            let dumped = dumped.extract::<&PyBytes>().unwrap();
-            buf.extend_from_slice(dumped.as_bytes());
+            let dumped = dumped.extract::<PyBackedBytes>().unwrap();
+            buf.extend_from_slice(&dumped);
             Ok(())
         })
     }
diff --git a/py-polars/Cargo.toml b/py-polars/Cargo.toml
index cb530b2d1445..200ccb34d6cd 100644
--- a/py-polars/Cargo.toml
+++ b/py-polars/Cargo.toml
@@ -27,7 +27,7 @@ ndarray = { workspace = true }
 num-traits = { workspace = true }
 numpy = { version = "0.21", default-features = false }
 once_cell = { workspace = true }
-pyo3 = { workspace = true, features = ["abi3-py38", "extension-module", "multiple-pymethods", "gil-refs"] }
+pyo3 = { workspace = true, features = ["abi3-py38", "extension-module", "multiple-pymethods"] }
 pyo3-built = { version = "0.5", optional = true }
 recursive = { workspace = true }
 serde_json = { workspace = true, optional = true }
diff --git a/py-polars/src/conversion/any_value.rs b/py-polars/src/conversion/any_value.rs
index 84da08f4d23f..7f42a69816a7 100644
--- a/py-polars/src/conversion/any_value.rs
+++ b/py-polars/src/conversion/any_value.rs
@@ -171,8 +171,8 @@ pub(crate) fn py_object_to_any_value<'py>(
     }
 
     fn get_bytes<'py>(ob: &Bound<'py, PyAny>, _strict: bool) -> PyResult<AnyValue<'py>> {
-        let value = ob.extract::<&'py [u8]>().unwrap();
-        Ok(AnyValue::Binary(value))
+        let value = ob.extract::<Vec<u8>>().unwrap();
+        Ok(AnyValue::BinaryOwned(value))
     }
 
     fn get_date(ob: &Bound<'_, PyAny>, _strict: bool) -> PyResult<AnyValue<'static>> {
diff --git a/py-polars/src/conversion/mod.rs b/py-polars/src/conversion/mod.rs
index cb6ed01d9463..b664392aab0f 100644
--- a/py-polars/src/conversion/mod.rs
+++ b/py-polars/src/conversion/mod.rs
@@ -275,27 +275,33 @@ impl ToPyObject for Wrap<DataType> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<Field> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<Field> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let py = ob.py();
-        let name = ob.getattr(intern!(py, "name"))?.str()?.to_str()?;
+        let name = ob
+            .getattr(intern!(py, "name"))?
+            .str()?
+            .extract::<PyBackedStr>()?;
         let dtype = ob
             .getattr(intern!(py, "dtype"))?
             .extract::<Wrap<DataType>>()?;
-        Ok(Wrap(Field::new(name, dtype.0)))
+        Ok(Wrap(Field::new(&name, dtype.0)))
     }
 }
 
-impl FromPyObject<'_> for Wrap<DataType> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<DataType> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let type_name = ob.get_type().qualname()?;
 
         let dtype = match &*type_name {
             "DataTypeClass" => {
                 // just the class, not an object
-                let name = ob.getattr(intern!(py, "__name__"))?.str()?.to_str()?;
-                match name {
+                let name = ob
+                    .getattr(intern!(py, "__name__"))?
+                    .str()?
+                    .extract::<PyBackedStr>()?;
+                match &*name {
                     "UInt8" => DataType::UInt8,
                     "UInt16" => DataType::UInt16,
                     "UInt32" => DataType::UInt32,
@@ -429,16 +435,16 @@ impl ToPyObject for Wrap<TimeUnit> {
 }
 
 impl<'s> FromPyObject<'s> for Wrap<Row<'s>> {
-    fn extract(ob: &'s PyAny) -> PyResult<Self> {
+    fn extract_bound(ob: &Bound<'s, PyAny>) -> PyResult<Self> {
         let vals = ob.extract::<Vec<Wrap<AnyValue<'s>>>>()?;
         let vals = vec_extract_wrapped(vals);
         Ok(Wrap(Row(vals)))
     }
 }
 
-impl FromPyObject<'_> for Wrap<Schema> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
-        let dict = ob.extract::<&PyDict>()?;
+impl<'py> FromPyObject<'py> for Wrap<Schema> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+        let dict = ob.downcast::<PyDict>()?;
 
         Ok(Wrap(
             dict.iter()
@@ -528,7 +534,7 @@ impl From<PyObject> for ObjectValue {
 }
 
 impl<'a> FromPyObject<'a> for ObjectValue {
-    fn extract(ob: &'a PyAny) -> PyResult<Self> {
+    fn extract_bound(ob: &Bound<'a, PyAny>) -> PyResult<Self> {
         Python::with_gil(|py| {
             Ok(ObjectValue {
                 inner: ob.to_object(py),
@@ -560,7 +566,7 @@ impl Default for ObjectValue {
 }
 
 impl<'a, T: NativeType + FromPyObject<'a>> FromPyObject<'a> for Wrap<Vec<T>> {
-    fn extract(obj: &'a PyAny) -> PyResult<Self> {
+    fn extract_bound(obj: &Bound<'a, PyAny>) -> PyResult<Self> {
         let seq = obj.downcast::<PySequence>()?;
         let mut v = Vec::with_capacity(seq.len().unwrap_or(0));
         for item in seq.iter()? {
@@ -571,8 +577,8 @@ impl<'a, T: NativeType + FromPyObject<'a>> FromPyObject<'a> for Wrap<Vec<T>> {
 }
 
 #[cfg(feature = "asof_join")]
-impl FromPyObject<'_> for Wrap<AsofStrategy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<AsofStrategy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*(ob.extract::<PyBackedStr>()?) {
             "backward" => AsofStrategy::Backward,
             "forward" => AsofStrategy::Forward,
@@ -587,8 +593,8 @@ impl FromPyObject<'_> for Wrap<AsofStrategy> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<InterpolationMethod> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<InterpolationMethod> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*(ob.extract::<PyBackedStr>()?) {
             "linear" => InterpolationMethod::Linear,
             "nearest" => InterpolationMethod::Nearest,
@@ -603,8 +609,8 @@ impl FromPyObject<'_> for Wrap<InterpolationMethod> {
 }
 
 #[cfg(feature = "avro")]
-impl FromPyObject<'_> for Wrap<Option<AvroCompression>> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<Option<AvroCompression>> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "uncompressed" => None,
             "snappy" => Some(AvroCompression::Snappy),
@@ -619,8 +625,8 @@ impl FromPyObject<'_> for Wrap<Option<AvroCompression>> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<CategoricalOrdering> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<CategoricalOrdering> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "physical" => CategoricalOrdering::Physical,
             "lexical" => CategoricalOrdering::Lexical,
@@ -634,8 +640,8 @@ impl FromPyObject<'_> for Wrap<CategoricalOrdering> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<StartBy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<StartBy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "window" => StartBy::WindowBound,
             "datapoint" => StartBy::DataPoint,
@@ -656,8 +662,8 @@ impl FromPyObject<'_> for Wrap<StartBy> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<ClosedWindow> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<ClosedWindow> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "left" => ClosedWindow::Left,
             "right" => ClosedWindow::Right,
@@ -674,8 +680,8 @@ impl FromPyObject<'_> for Wrap<ClosedWindow> {
 }
 
 #[cfg(feature = "csv")]
-impl FromPyObject<'_> for Wrap<CsvEncoding> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<CsvEncoding> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "utf8" => CsvEncoding::Utf8,
             "utf8-lossy" => CsvEncoding::LossyUtf8,
@@ -690,8 +696,8 @@ impl FromPyObject<'_> for Wrap<CsvEncoding> {
 }
 
 #[cfg(feature = "ipc")]
-impl FromPyObject<'_> for Wrap<Option<IpcCompression>> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<Option<IpcCompression>> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "uncompressed" => None,
             "lz4" => Some(IpcCompression::LZ4),
@@ -706,8 +712,8 @@ impl FromPyObject<'_> for Wrap<Option<IpcCompression>> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<JoinType> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<JoinType> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "inner" => JoinType::Inner,
             "left" => JoinType::Left,
@@ -730,8 +736,8 @@ impl FromPyObject<'_> for Wrap<JoinType> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<Label> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<Label> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "left" => Label::Left,
             "right" => Label::Right,
@@ -746,8 +752,8 @@ impl FromPyObject<'_> for Wrap<Label> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<ListToStructWidthStrategy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<ListToStructWidthStrategy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "first_non_null" => ListToStructWidthStrategy::FirstNonNull,
             "max_width" => ListToStructWidthStrategy::MaxWidth,
@@ -761,8 +767,8 @@ impl FromPyObject<'_> for Wrap<ListToStructWidthStrategy> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<NonExistent> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<NonExistent> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "null" => NonExistent::Null,
             "raise" => NonExistent::Raise,
@@ -776,8 +782,8 @@ impl FromPyObject<'_> for Wrap<NonExistent> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<NullBehavior> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<NullBehavior> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "drop" => NullBehavior::Drop,
             "ignore" => NullBehavior::Ignore,
@@ -791,8 +797,8 @@ impl FromPyObject<'_> for Wrap<NullBehavior> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<NullStrategy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<NullStrategy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "ignore" => NullStrategy::Ignore,
             "propagate" => NullStrategy::Propagate,
@@ -807,8 +813,8 @@ impl FromPyObject<'_> for Wrap<NullStrategy> {
 }
 
 #[cfg(feature = "parquet")]
-impl FromPyObject<'_> for Wrap<ParallelStrategy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<ParallelStrategy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "auto" => ParallelStrategy::Auto,
             "columns" => ParallelStrategy::Columns,
@@ -824,8 +830,8 @@ impl FromPyObject<'_> for Wrap<ParallelStrategy> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<IndexOrder> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<IndexOrder> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "fortran" => IndexOrder::Fortran,
             "c" => IndexOrder::C,
@@ -839,8 +845,8 @@ impl FromPyObject<'_> for Wrap<IndexOrder> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<QuantileInterpolOptions> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<QuantileInterpolOptions> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "lower" => QuantileInterpolOptions::Lower,
             "higher" => QuantileInterpolOptions::Higher,
@@ -857,8 +863,8 @@ impl FromPyObject<'_> for Wrap<QuantileInterpolOptions> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<RankMethod> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<RankMethod> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "min" => RankMethod::Min,
             "max" => RankMethod::Max,
@@ -876,8 +882,8 @@ impl FromPyObject<'_> for Wrap<RankMethod> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<Roll> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<Roll> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "raise" => Roll::Raise,
             "forward" => Roll::Forward,
@@ -892,8 +898,8 @@ impl FromPyObject<'_> for Wrap<Roll> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<TimeUnit> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<TimeUnit> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "ns" => TimeUnit::Nanoseconds,
             "us" => TimeUnit::Microseconds,
@@ -908,8 +914,8 @@ impl FromPyObject<'_> for Wrap<TimeUnit> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<UniqueKeepStrategy> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<UniqueKeepStrategy> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "first" => UniqueKeepStrategy::First,
             "last" => UniqueKeepStrategy::Last,
@@ -926,8 +932,8 @@ impl FromPyObject<'_> for Wrap<UniqueKeepStrategy> {
 }
 
 #[cfg(feature = "ipc")]
-impl FromPyObject<'_> for Wrap<IpcCompression> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<IpcCompression> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "zstd" => IpcCompression::ZSTD,
             "lz4" => IpcCompression::LZ4,
@@ -942,8 +948,8 @@ impl FromPyObject<'_> for Wrap<IpcCompression> {
 }
 
 #[cfg(feature = "search_sorted")]
-impl FromPyObject<'_> for Wrap<SearchSortedSide> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<SearchSortedSide> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "any" => SearchSortedSide::Any,
             "left" => SearchSortedSide::Left,
@@ -958,8 +964,8 @@ impl FromPyObject<'_> for Wrap<SearchSortedSide> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<ClosedInterval> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<ClosedInterval> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "both" => ClosedInterval::Both,
             "left" => ClosedInterval::Left,
@@ -975,8 +981,8 @@ impl FromPyObject<'_> for Wrap<ClosedInterval> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<WindowMapping> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<WindowMapping> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "group_to_rows" => WindowMapping::GroupsToRows,
             "join" => WindowMapping::Join,
@@ -991,8 +997,8 @@ impl FromPyObject<'_> for Wrap<WindowMapping> {
     }
 }
 
-impl FromPyObject<'_> for Wrap<JoinValidation> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<JoinValidation> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "1:1" => JoinValidation::OneToOne,
             "1:m" => JoinValidation::OneToMany,
@@ -1009,8 +1015,8 @@ impl FromPyObject<'_> for Wrap<JoinValidation> {
 }
 
 #[cfg(feature = "csv")]
-impl FromPyObject<'_> for Wrap<QuoteStyle> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<QuoteStyle> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "always" => QuoteStyle::Always,
             "necessary" => QuoteStyle::Necessary,
@@ -1033,8 +1039,8 @@ pub(crate) fn parse_cloud_options(uri: &str, kv: Vec<(String, String)>) -> PyRes
 }
 
 #[cfg(feature = "list_sets")]
-impl FromPyObject<'_> for Wrap<SetOperation> {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for Wrap<SetOperation> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let parsed = match &*ob.extract::<PyBackedStr>()? {
             "union" => SetOperation::Union,
             "difference" => SetOperation::Difference,
diff --git a/py-polars/src/datatypes.rs b/py-polars/src/datatypes.rs
index 9072eed71118..fa06b23e48b9 100644
--- a/py-polars/src/datatypes.rs
+++ b/py-polars/src/datatypes.rs
@@ -1,6 +1,6 @@
 use polars::prelude::*;
 use polars_core::utils::arrow::array::Utf8ViewArray;
-use pyo3::{FromPyObject, PyAny, PyResult};
+use pyo3::prelude::*;
 
 #[cfg(feature = "object")]
 use crate::object::OBJECT_NAME;
@@ -111,8 +111,8 @@ impl From<PyDataType> for DataType {
     }
 }
 
-impl FromPyObject<'_> for PyDataType {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+impl<'py> FromPyObject<'py> for PyDataType {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
         let dt = ob.extract::<Wrap<DataType>>()?;
         Ok(dt.0.into())
     }
diff --git a/py-polars/src/lazyframe/mod.rs b/py-polars/src/lazyframe/mod.rs
index 93e7c197c3bf..f7a2b1cde698 100644
--- a/py-polars/src/lazyframe/mod.rs
+++ b/py-polars/src/lazyframe/mod.rs
@@ -13,7 +13,7 @@ use polars::time::*;
 use polars_core::prelude::*;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::pybacked::PyBackedStr;
+use pyo3::pybacked::{PyBackedBytes, PyBackedStr};
 use pyo3::types::{PyBytes, PyDict, PyList};
 pub(crate) use visit::PyExprIR;
 
@@ -59,9 +59,9 @@ impl PyLazyFrame {
 
     fn __setstate__(&mut self, py: Python, state: PyObject) -> PyResult<()> {
         // Used in pickle/pickling
-        match state.extract::<&PyBytes>(py) {
+        match state.extract::<PyBackedBytes>(py) {
             Ok(s) => {
-                let lp: DslPlan = ciborium::de::from_reader(s.as_bytes())
+                let lp: DslPlan = ciborium::de::from_reader(&*s)
                     .map_err(|e| PyPolarsErr::Other(format!("{}", e)))?;
                 self.ldf = LazyFrame::from(lp);
                 Ok(())
diff --git a/py-polars/src/map/dataframe.rs b/py-polars/src/map/dataframe.rs
index 7b6a58879824..d50adb7404e1 100644
--- a/py-polars/src/map/dataframe.rs
+++ b/py-polars/src/map/dataframe.rs
@@ -84,14 +84,8 @@ pub fn apply_lambda_unknown<'a>(
             let first_value = out.extract::<PyBackedStr>().ok();
             return Ok((
                 PySeries::new(
-                    apply_lambda_with_string_out_type(
-                        df,
-                        py,
-                        lambda,
-                        null_count,
-                        first_value.as_deref(),
-                    )
-                    .into_series(),
+                    apply_lambda_with_string_out_type(df, py, lambda, null_count, first_value)
+                        .into_series(),
                 )
                 .into_py(py),
                 false,
@@ -204,20 +198,14 @@ pub fn apply_lambda_with_string_out_type<'a>(
     py: Python,
     lambda: Bound<'a, PyAny>,
     init_null_count: usize,
-    first_value: Option<&str>,
+    first_value: Option<PyBackedStr>,
 ) -> StringChunked {
     let skip = usize::from(first_value.is_some());
     if init_null_count == df.height() {
         ChunkedArray::full_null("map", df.height())
     } else {
-        let iter = apply_iter::<Cow<str>>(df, py, lambda, init_null_count, skip);
-        iterator_to_string(
-            iter,
-            init_null_count,
-            first_value.map(Cow::Borrowed),
-            "map",
-            df.height(),
-        )
+        let iter = apply_iter::<PyBackedStr>(df, py, lambda, init_null_count, skip);
+        iterator_to_string(iter, init_null_count, first_value, "map", df.height())
     }
 }
 
diff --git a/py-polars/src/map/lazy.rs b/py-polars/src/map/lazy.rs
index 75084783a295..88b05beb16cc 100644
--- a/py-polars/src/map/lazy.rs
+++ b/py-polars/src/map/lazy.rs
@@ -29,14 +29,14 @@ impl ToSeries for PyObject {
                 let res = py_polars_module
                     .getattr(py, "Series")
                     .unwrap()
-                    .call1(py, (name, PyList::new(py, [self])));
+                    .call1(py, (name, PyList::new_bound(py, [self])));
 
                 match res {
                     Ok(python_s) => python_s.getattr(py, "_s").unwrap(),
                     Err(_) => {
                         polars_bail!(ComputeError:
                             "expected a something that could convert to a `Series` but got: {}",
-                            self.as_ref(py).get_type()
+                            self.bind(py).get_type()
                         )
                     },
                 }
@@ -53,7 +53,7 @@ pub(crate) fn call_lambda_with_series(
     s: Series,
     lambda: &PyObject,
 ) -> PyResult<PyObject> {
-    let pypolars = POLARS.downcast::<PyModule>(py).unwrap();
+    let pypolars = POLARS.downcast_bound::<PyModule>(py).unwrap();
 
     // create a PySeries struct/object for Python
     let pyseries = PySeries::new(s);
@@ -75,7 +75,7 @@ pub(crate) fn binary_lambda(
 ) -> PolarsResult<Option<Series>> {
     Python::with_gil(|py| {
         // get the pypolars module
-        let pypolars = PyModule::import(py, "polars").unwrap();
+        let pypolars = PyModule::import_bound(py, "polars").unwrap();
         // create a PySeries struct/object for Python
         let pyseries_a = PySeries::new(a);
         let pyseries_b = PySeries::new(b);
@@ -97,7 +97,7 @@ pub(crate) fn binary_lambda(
             match lambda.call1(py, (python_series_wrapper_a, python_series_wrapper_b)) {
                 Ok(pyobj) => pyobj,
                 Err(e) => polars_bail!(
-                    ComputeError: "custom python function failed: {}", e.value(py),
+                    ComputeError: "custom python function failed: {}", e.value_bound(py),
                 ),
             };
         let pyseries = if let Ok(expr) = result_series_wrapper.getattr(py, "_pyexpr") {
@@ -142,7 +142,7 @@ pub(crate) fn call_lambda_with_series_slice(
     lambda: &PyObject,
     polars_module: &PyObject,
 ) -> PyObject {
-    let pypolars = polars_module.downcast::<PyModule>(py).unwrap();
+    let pypolars = polars_module.downcast_bound::<PyModule>(py).unwrap();
 
     // create a PySeries struct/object for Python
     let iter = s.iter().map(|s| {
@@ -153,12 +153,12 @@ pub(crate) fn call_lambda_with_series_slice(
 
         python_series_wrapper
     });
-    let wrapped_s = PyList::new(py, iter);
+    let wrapped_s = PyList::new_bound(py, iter);
 
     // call the lambda and get a python side Series wrapper
     match lambda.call1(py, (wrapped_s,)) {
         Ok(pyobj) => pyobj,
-        Err(e) => panic!("python function failed: {}", e.value(py)),
+        Err(e) => panic!("python function failed: {}", e.value_bound(py)),
     }
 }
 
@@ -172,7 +172,7 @@ pub fn map_mul(
 ) -> PyExpr {
     // get the pypolars module
     // do the import outside of the function to prevent import side effects in a hot loop.
-    let pypolars = PyModule::import(py, "polars").unwrap().to_object(py);
+    let pypolars = PyModule::import_bound(py, "polars").unwrap().to_object(py);
 
     let function = move |s: &mut [Series]| {
         Python::with_gil(|py| {
diff --git a/py-polars/src/map/mod.rs b/py-polars/src/map/mod.rs
index f6ffe15a9bdf..0af601338352 100644
--- a/py-polars/src/map/mod.rs
+++ b/py-polars/src/map/mod.rs
@@ -2,7 +2,6 @@ pub mod dataframe;
 pub mod lazy;
 pub mod series;
 
-use std::borrow::Cow;
 use std::collections::BTreeMap;
 
 use polars::chunked_array::builder::get_list_builder;
diff --git a/py-polars/src/on_startup.rs b/py-polars/src/on_startup.rs
index af83c2e1ed12..232699852db6 100644
--- a/py-polars/src/on_startup.rs
+++ b/py-polars/src/on_startup.rs
@@ -39,7 +39,7 @@ fn python_function_caller_df(df: DataFrame, lambda: &PyObject) -> PolarsResult<D
         })?;
         // unpack the wrapper in a PyDataFrame
         let py_pydf = result_df_wrapper.getattr(py, "_df").map_err(|_| {
-            let pytype = result_df_wrapper.as_ref(py).get_type();
+            let pytype = result_df_wrapper.bind(py).get_type();
             PolarsError::ComputeError(
                 format!("Expected 'LazyFrame.map' to return a 'DataFrame', got a '{pytype}'",)
                     .into(),
@@ -57,10 +57,7 @@ fn python_function_caller_df(df: DataFrame, lambda: &PyObject) -> PolarsResult<D
 
 fn warning_function(msg: &str, warning: PolarsWarning) {
     Python::with_gil(|py| {
-        let warn_fn = UTILS
-            .as_ref(py)
-            .getattr(intern!(py, "_polars_warn"))
-            .unwrap();
+        let warn_fn = UTILS.bind(py).getattr(intern!(py, "_polars_warn")).unwrap();
 
         if let Err(e) = warn_fn.call1((msg, Wrap(warning))) {
             eprintln!("{e}")
diff --git a/py-polars/src/series/comparison.rs b/py-polars/src/series/comparison.rs
index c60dbc0e1540..8ebd85021463 100644
--- a/py-polars/src/series/comparison.rs
+++ b/py-polars/src/series/comparison.rs
@@ -189,7 +189,7 @@ impl_lt_eq_num!(lt_eq_str, &str);
 struct PyDecimal(i128, usize);
 
 impl<'source> FromPyObject<'source> for PyDecimal {
-    fn extract(obj: &'source PyAny) -> PyResult<Self> {
+    fn extract_bound(obj: &Bound<'source, PyAny>) -> PyResult<Self> {
         if let Ok(val) = obj.extract() {
             return Ok(PyDecimal(val, 0));
         }
diff --git a/py-polars/src/series/mod.rs b/py-polars/src/series/mod.rs
index b0fece16a5cb..afa11b69306d 100644
--- a/py-polars/src/series/mod.rs
+++ b/py-polars/src/series/mod.rs
@@ -647,15 +647,17 @@ impl PySeries {
             .with_pl_flavor(true)
             .finish(&mut df)
             .expect("ipc writer");
-        Ok(PyBytes::new(py, &buf).to_object(py))
+        Ok(PyBytes::new_bound(py, &buf).to_object(py))
     }
 
     #[cfg(feature = "ipc_streaming")]
     fn __setstate__(&mut self, py: Python, state: PyObject) -> PyResult<()> {
         // Used in pickle/pickling
-        match state.extract::<&PyBytes>(py) {
+
+        use pyo3::pybacked::PyBackedBytes;
+        match state.extract::<PyBackedBytes>(py) {
             Ok(s) => {
-                let c = Cursor::new(s.as_bytes());
+                let c = Cursor::new(&s);
                 let reader = IpcStreamReader::new(c);
                 let mut df = reader.finish().map_err(PyPolarsErr::from)?;
 
diff --git a/py-polars/src/series/numpy_ufunc.rs b/py-polars/src/series/numpy_ufunc.rs
index e8d8f5005f77..e46048ad3d99 100644
--- a/py-polars/src/series/numpy_ufunc.rs
+++ b/py-polars/src/series/numpy_ufunc.rs
@@ -71,7 +71,7 @@ macro_rules! impl_ufuncs {
             // the out array is allocated in this method, send to Python and once the ufunc is applied
             // ownership is taken by Rust again to prevent memory leak.
             // if the ufunc fails, we first must take ownership back.
-            fn $name(&self, lambda: &PyAny) -> PyResult<PySeries> {
+            fn $name(&self, lambda: &Bound<PyAny>) -> PyResult<PySeries> {
                 // numpy array object, and a *mut ptr
                 Python::with_gil(|py| {
                     let size = self.len();
@@ -80,7 +80,7 @@ macro_rules! impl_ufuncs {
 
                     debug_assert_eq!(get_refcnt(&out_array), 1);
                     // inserting it in a tuple increase the reference count by 1.
-                    let args = PyTuple::new(py, &[out_array.clone()]);
+                    let args = PyTuple::new_bound(py, &[out_array.clone()]);
                     debug_assert_eq!(get_refcnt(&out_array), 2);
 
                     // whatever the result, we must take the leaked memory ownership back
@@ -88,7 +88,7 @@ macro_rules! impl_ufuncs {
                         Ok(_) => {
                             // if this assert fails, the lambda has taken a reference to the object, so we must panic
                             // args and the lambda return have a reference, making a total of 3
-                            assert_eq!(get_refcnt(&out_array), 3);
+                            assert!(get_refcnt(&out_array) <= 3);
 
                             let validity = self.series.chunks()[0].validity().cloned();
                             let ca =
diff --git a/py-polars/src/to_numpy.rs b/py-polars/src/to_numpy.rs
index d1894e2dfba9..51587dc49315 100644
--- a/py-polars/src/to_numpy.rs
+++ b/py-polars/src/to_numpy.rs
@@ -43,8 +43,7 @@ where
     std::mem::forget(owner);
     PY_ARRAY_API.PyArray_SetBaseObject(py, array as *mut PyArrayObject, owner_ptr);
 
-    let any: &PyAny = py.from_owned_ptr(array);
-    any.into_py(py)
+    Py::from_owned_ptr(py, array)
 }
 
 #[pymethods]