fix lint errors

Author: kylebarron

python/src/decoder.rs

@@ -8,13 +8,13 @@ use bytes::Bytes;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::sync::GILOnceCell;
+use pyo3::sync::PyOnceLock;
 use pyo3::types::{PyDict, PyTuple};
 use pyo3_bytes::PyBytes;
 
 use crate::enums::PyCompressionMethod;
 
-static DEFAULT_DECODER_REGISTRY: GILOnceCell<Arc<DecoderRegistry>> = GILOnceCell::new();
+static DEFAULT_DECODER_REGISTRY: PyOnceLock<Arc<DecoderRegistry>> = PyOnceLock::new();
 
 pub fn get_default_decoder_registry(py: Python<'_>) -> Arc<DecoderRegistry> {
     let registry =
@@ -49,7 +49,7 @@ impl PyDecoderRegistry {
 }
 
 #[derive(Debug)]
-pub(crate) struct PyDecoder(PyObject);
+pub(crate) struct PyDecoder(Py<PyAny>);
 
 impl PyDecoder {
     fn call(&self, py: Python, buffer: Bytes) -> PyResult<PyBytes> {
@@ -78,7 +78,7 @@ impl Decoder for PyDecoder {
         _photometric_interpretation: PhotometricInterpretation,
         _jpeg_tables: Option<&[u8]>,
     ) -> AsyncTiffResult<Bytes> {
-        let decoded_buffer = Python::with_gil(|py| self.call(py, buffer))
+        let decoded_buffer = Python::attach(|py| self.call(py, buffer))
             .map_err(|err| AsyncTiffError::General(err.to_string()))?;
         Ok(decoded_buffer.into_inner())
     }

python/src/reader.rs

@@ -36,11 +36,11 @@ impl StoreInput {
 /// https://developmentseed.org/obspec/latest/api/get/#obspec.GetRangeAsync
 /// https://developmentseed.org/obspec/latest/api/get/#obspec.GetRangesAsync
 #[derive(Debug)]
-pub(crate) struct ObspecBackend(PyObject);
+pub(crate) struct ObspecBackend(Py<PyAny>);
 
 impl ObspecBackend {
     async fn get_range(&self, path: &str, range: Range<u64>) -> PyResult<PyBytes> {
-        let future = Python::with_gil(|py| {
+        let future = Python::attach(|py| {
             let kwargs = PyDict::new(py);
             kwargs.set_item(intern!(py, "path"), path)?;
             kwargs.set_item(intern!(py, "start"), range.start)?;
@@ -52,14 +52,14 @@ impl ObspecBackend {
             into_future(coroutine.bind(py).clone())
         })?;
         let result = future.await?;
-        Python::with_gil(|py| result.extract(py))
+        Python::attach(|py| result.extract(py))
     }
 
     async fn get_ranges(&self, path: &str, ranges: &[Range<u64>]) -> PyResult<Vec<PyBytes>> {
         let starts = ranges.iter().map(|r| r.start).collect::<Vec<_>>();
         let ends = ranges.iter().map(|r| r.end).collect::<Vec<_>>();
 
-        let future = Python::with_gil(|py| {
+        let future = Python::attach(|py| {
             let kwargs = PyDict::new(py);
             kwargs.set_item(intern!(py, "path"), path)?;
             kwargs.set_item(intern!(py, "starts"), starts)?;
@@ -71,7 +71,7 @@ impl ObspecBackend {
             into_future(coroutine.bind(py).clone())
         })?;
         let result = future.await?;
-        Python::with_gil(|py| result.extract(py))
+        Python::attach(|py| result.extract(py))
     }
 
     async fn get_range_wrapper(&self, path: &str, range: Range<u64>) -> AsyncTiffResult<Bytes> {

python/src/thread_pool.rs

@@ -3,10 +3,10 @@ use std::sync::Arc;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 
-use pyo3::sync::GILOnceCell;
+use pyo3::sync::PyOnceLock;
 use rayon::{ThreadPool, ThreadPoolBuilder};
 
-static DEFAULT_POOL: GILOnceCell<Arc<ThreadPool>> = GILOnceCell::new();
+static DEFAULT_POOL: PyOnceLock<Arc<ThreadPool>> = PyOnceLock::new();
 
 pub fn get_default_pool(py: Python<'_>) -> PyResult<Arc<ThreadPool>> {
     let runtime = DEFAULT_POOL.get_or_try_init(py, || {

python/src/tile.rs

@@ -55,12 +55,12 @@ impl PyTile {
     }
 
     #[pyo3(signature = (*, decoder_registry=None, pool=None))]
-    fn decode_async(
+    fn decode_async<'py>(
         &mut self,
-        py: Python,
+        py: Python<'py>,
         decoder_registry: Option<&PyDecoderRegistry>,
         pool: Option<&PyThreadPool>,
-    ) -> PyResult<PyObject> {
+    ) -> PyResult<Bound<'py, PyAny>> {
         let decoder_registry = decoder_registry
             .map(|r| r.inner().clone())
             .unwrap_or_else(|| get_default_decoder_registry(py));
@@ -69,13 +69,12 @@ impl PyTile {
             .unwrap_or_else(|| get_default_pool(py))?;
         let tile = self.0.take().unwrap();
 
-        let result = future_into_py(py, async move {
+        future_into_py(py, async move {
             let decoded_bytes = pool
                 .spawn_async(move || tile.decode(&decoder_registry))
                 .await
                 .unwrap();
             Ok(PyBytes::new(decoded_bytes))
-        })?;
-        Ok(result.unbind())
+        })
     }
 }