chore(deps): bump pyo3 0.20.3 -> 0.21.2

Cargo.toml

@@ -12,10 +12,10 @@ crate-type = ["cdylib"]
 calamine = { version = "0.25.0", features = ["dates"] }
 chrono = { version = "0.4.38", default-features = false }
 # NOTE: "extension-module" is actually required, see comments on features below
-pyo3 = { version = "0.20.3", features = ["abi3-py38"] }
+pyo3 = { version = "0.21.2", features = ["abi3-py38"] }
 
 [dependencies.arrow]
-version = "51.0.0"
+version = "52.0.0"
 # There's a lot of stuff we don't want here, such as serde support
 default-features = false
 features = ["pyarrow"]

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["maturin>=1.3.2,<2.0"]
+requires = ["maturin>=1.6.0,<2.0"]
 build-backend = "maturin"
 
 [project]
@@ -25,6 +25,7 @@ Issues = "https://github.com/ToucanToco/fastexcel"
 [tool.maturin]
 python-source = "python"
 module-name = "fastexcel._fastexcel"
+features = ["pyo3/extension-module"]
 
 [tool.mypy]
 python_version = "3.8"

src/lib.rs

@@ -3,15 +3,16 @@ mod types;
 mod utils;
 
 use error::{py_errors, ErrorContext};
-use pyo3::prelude::*;
+use pyo3::{prelude::*, types::PyString};
 use types::python::{excelsheet::column_info::ColumnInfo, ExcelReader, ExcelSheet};
 
 /// Reads an excel file and returns an object allowing to access its sheets and a bit of metadata
 #[pyfunction]
-fn read_excel(source: &PyAny) -> PyResult<ExcelReader> {
+fn read_excel(source: &Bound<'_, PyAny>) -> PyResult<ExcelReader> {
     use py_errors::IntoPyResult;
 
-    if let Ok(path) = source.extract::<&str>() {
+    if let Ok(path) = source.extract::<&PyString>() {
+        let path = path.to_str()?;
         ExcelReader::try_from_path(path)
             .with_context(|| format!("could not load excel file at {path}"))
             .into_pyresult()
@@ -39,7 +40,8 @@ fn get_version() -> String {
 }
 
 #[pymodule]
-fn _fastexcel(py: Python, m: &PyModule) -> PyResult<()> {
+fn _fastexcel(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    let py = m.py();
     m.add_function(wrap_pyfunction!(read_excel, m)?)?;
     m.add_class::<ColumnInfo>()?;
     m.add_class::<ExcelSheet>()?;
@@ -48,32 +50,38 @@ fn _fastexcel(py: Python, m: &PyModule) -> PyResult<()> {
 
     // errors
     [
-        ("FastExcelError", py.get_type::<py_errors::FastExcelError>()),
+        (
+            "FastExcelError",
+            py.get_type_bound::<py_errors::FastExcelError>(),
+        ),
         (
             "UnsupportedColumnTypeCombinationError",
-            py.get_type::<py_errors::UnsupportedColumnTypeCombinationError>(),
+            py.get_type_bound::<py_errors::UnsupportedColumnTypeCombinationError>(),
         ),
         (
             "CannotRetrieveCellDataError",
-            py.get_type::<py_errors::CannotRetrieveCellDataError>(),
+            py.get_type_bound::<py_errors::CannotRetrieveCellDataError>(),
         ),
         (
             "CalamineCellError",
-            py.get_type::<py_errors::CalamineCellError>(),
+            py.get_type_bound::<py_errors::CalamineCellError>(),
+        ),
+        (
+            "CalamineError",
+            py.get_type_bound::<py_errors::CalamineError>(),
         ),
-        ("CalamineError", py.get_type::<py_errors::CalamineError>()),
         (
             "SheetNotFoundError",
-            py.get_type::<py_errors::SheetNotFoundError>(),
+            py.get_type_bound::<py_errors::SheetNotFoundError>(),
         ),
         (
             "ColumnNotFoundError",
-            py.get_type::<py_errors::ColumnNotFoundError>(),
+            py.get_type_bound::<py_errors::ColumnNotFoundError>(),
         ),
-        ("ArrowError", py.get_type::<py_errors::ArrowError>()),
+        ("ArrowError", py.get_type_bound::<py_errors::ArrowError>()),
         (
             "InvalidParametersError",
-            py.get_type::<py_errors::InvalidParametersError>(),
+            py.get_type_bound::<py_errors::InvalidParametersError>(),
         ),
     ]
     .into_iter()

src/types/dtype.rs

@@ -7,7 +7,10 @@ use std::{
 
 use arrow::datatypes::{DataType as ArrowDataType, TimeUnit};
 use calamine::{CellErrorType, CellType, DataType, Range};
-use pyo3::{FromPyObject, PyAny, PyObject, PyResult, Python, ToPyObject};
+use pyo3::{
+    prelude::PyAnyMethods, types::PyString, Bound, FromPyObject, PyAny, PyObject, PyResult, Python,
+    ToPyObject,
+};
 
 use crate::error::{py_errors::IntoPyResult, FastExcelError, FastExcelErrorKind, FastExcelResult};
 
@@ -68,9 +71,9 @@ impl ToPyObject for DType {
 }
 
 impl FromPyObject<'_> for DType {
-    fn extract(py_dtype: &PyAny) -> PyResult<Self> {
-        if let Ok(dtype_str) = py_dtype.extract::<&str>() {
-            dtype_str.parse()
+    fn extract_bound(py_dtype: &Bound<'_, PyAny>) -> PyResult<Self> {
+        if let Ok(dtype_pystr) = py_dtype.extract::<&PyString>() {
+            dtype_pystr.to_str()?.parse()
         } else {
             Err(FastExcelErrorKind::InvalidParameters(format!(
                 "{py_dtype:?} cannot be converted to str"

src/types/idx_or_name.rs

@@ -1,4 +1,6 @@
-use pyo3::{FromPyObject, PyAny, PyObject, PyResult, Python, ToPyObject};
+use pyo3::{
+    prelude::PyAnyMethods, Bound, FromPyObject, PyAny, PyObject, PyResult, Python, ToPyObject,
+};
 
 use crate::error::{py_errors::IntoPyResult, FastExcelError, FastExcelErrorKind, FastExcelResult};
 
@@ -17,10 +19,10 @@ impl IdxOrName {
     }
 }
 
-impl TryFrom<&PyAny> for IdxOrName {
+impl TryFrom<&Bound<'_, PyAny>> for IdxOrName {
     type Error = FastExcelError;
 
-    fn try_from(value: &PyAny) -> FastExcelResult<Self> {
+    fn try_from(value: &Bound<'_, PyAny>) -> FastExcelResult<Self> {
         if let Ok(index) = value.extract() {
             Ok(Self::Idx(index))
         } else if let Ok(name) = value.extract() {
@@ -35,8 +37,8 @@ impl TryFrom<&PyAny> for IdxOrName {
 }
 
 impl FromPyObject<'_> for IdxOrName {
-    fn extract(value: &PyAny) -> PyResult<Self> {
-        value.try_into().into_pyresult()
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
+        ob.try_into().into_pyresult()
     }
 }