Upgrade pyo3 to version 0.26

PyObject and ::with_gil have been deprecated, so both of these had to be replaced.

Author: DanielT

Cargo.lock

@@ -15,4 +15,4 @@ crate-type = ["cdylib"]
 autosar-data = {version = "0.20"}
 autosar-data-specification = {version = "0.20"}
 autosar-data-abstraction = {version = "0.6"}
-pyo3 = "0.25"
+pyo3 = "0.26"

Cargo.toml

@@ -9,8 +9,8 @@ use crate::abstraction::{
         ApplicationArrayDataType, ApplicationArraySize, ApplicationPrimitiveCategory,
         ApplicationPrimitiveDataType, ApplicationRecordDataType, BaseTypeEncoding, CompuMethod,
         ConstantSpecification, DataConstr, DataTypeMappingSet, ImplementationDataType, SwBaseType,
-        Unit, pyany_to_implmentation_settings, pyobject_to_compu_method_content,
-        pyobject_to_value_specification,
+        Unit, pyany_to_compu_method_content, pyany_to_implmentation_settings,
+        pyany_to_value_specification,
     },
     ecu_configuration::{
         EcucDefinitionCollection, EcucDestinationUriDefSet, EcucModuleConfigurationValues,
@@ -185,7 +185,7 @@ impl ArPackage {
     /// create a new `CompuMethod` in the package
     #[pyo3(text_signature = "(self, name: str, content: CompuMethodContent)")]
     fn create_compu_method(&self, name: &str, content: &Bound<'_, PyAny>) -> PyResult<CompuMethod> {
-        let content = pyobject_to_compu_method_content(content)?;
+        let content = pyany_to_compu_method_content(content)?;
         match self.0.create_compu_method(name, content) {
             Ok(value) => Ok(CompuMethod(value)),
             Err(e) => Err(AutosarAbstractionError::new_err(e.to_string())),
@@ -199,7 +199,7 @@ impl ArPackage {
         name: &str,
         value: &Bound<'_, PyAny>,
     ) -> PyResult<ConstantSpecification> {
-        let value = pyobject_to_value_specification(value)?;
+        let value = pyany_to_value_specification(value)?;
         match self.0.create_constant_specification(name, value) {
             Ok(value) => Ok(ConstantSpecification(value)),
             Err(e) => Err(AutosarAbstractionError::new_err(e.to_string())),

src/abstraction/arpackage.rs

@@ -83,7 +83,7 @@ impl DataTransformationSet {
         name: &str,
         config: &Bound<'_, PyAny>, // some variant of TransformationTechnologyConfig
     ) -> PyResult<TransformationTechnology> {
-        let config = transformation_technology_config_from_pyobject(config)?;
+        let config = transformation_technology_config_from_pyany(config)?;
         match self.0.create_transformation_technology(name, &config) {
             Ok(value) => Ok(TransformationTechnology(value)),
             Err(e) => Err(AutosarAbstractionError::new_err(e.to_string())),
@@ -230,15 +230,15 @@ impl TransformationTechnology {
     #[pyo3(signature = (config, /))]
     #[pyo3(text_signature = "(self, config: TransformationTechnologyConfig, /)")]
     fn set_config(&self, config: &Bound<'_, PyAny>) -> PyResult<()> {
-        let config = transformation_technology_config_from_pyobject(config)?;
+        let config = transformation_technology_config_from_pyany(config)?;
         self.0.set_config(&config).map_err(abstraction_err_to_pyerr)
     }
 
     /// Get the configuration of the `TransformationTechnology`
-    fn config(&self, py: Python) -> Option<PyObject> {
+    fn config(&self, py: Python) -> Option<Py<PyAny>> {
         self.0
             .config()
-            .and_then(|config| transformation_technology_config_to_pyobject(py, &config).ok())
+            .and_then(|config| transformation_technology_config_to_pyany(py, &config).ok())
     }
 }
 
@@ -248,8 +248,8 @@ iterator_wrapper!(TransformationTechnologyIterator, TransformationTechnology);
 
 //##################################################################
 
-// when we receive a generic PyObject, we need to determine the actual type of the config and wrap it appropriately
-fn transformation_technology_config_from_pyobject(
+// when we receive a generic Py<PyAny>, we need to determine the actual type of the config and wrap it appropriately
+fn transformation_technology_config_from_pyany(
     config: &Bound<'_, PyAny>,
 ) -> PyResult<autosar_data_abstraction::communication::TransformationTechnologyConfig> {
     if let Ok(config) = config.extract::<GenericTransformationTechnologyConfig>() {
@@ -283,11 +283,11 @@ fn transformation_technology_config_from_pyobject(
     }
 }
 
-// instead of representing TransformationTechnologyConfig with a matching enum in python, we can simply return generic PyObjects
-fn transformation_technology_config_to_pyobject(
+// instead of representing TransformationTechnologyConfig with a matching enum in python, we can simply return generic Py<PyAny>s
+fn transformation_technology_config_to_pyany(
     py: Python,
     config: &autosar_data_abstraction::communication::TransformationTechnologyConfig,
-) -> PyResult<PyObject> {
+) -> PyResult<Py<PyAny>> {
     match config {
         autosar_data_abstraction::communication::TransformationTechnologyConfig::Generic(
             config,

src/abstraction/communication/data_transformation.rs

@@ -55,7 +55,7 @@ impl PduToFrameMapping {
 
     /// Reference to the PDU that is mapped into the frame. The PDU reference is mandatory.
     #[getter]
-    fn pdu(&self) -> Option<PyObject> {
+    fn pdu(&self) -> Option<Py<PyAny>> {
         self.0.pdu().and_then(|pdu| pdu_to_pyany(&pdu).ok())
     }
 

src/abstraction/communication/frame/mod.rs

@@ -119,13 +119,13 @@ impl NmConfig {
     fn nm_clusters(&self) -> NmClusterIterator {
         NmClusterIterator::new(self.0.nm_clusters().filter_map(|cluster| match cluster {
             autosar_data_abstraction::communication::NmCluster::CanNm(cluster) => {
-                Python::with_gil(|py| CanNmCluster(cluster).into_py_any(py).ok())
+                Python::attach(|py| CanNmCluster(cluster).into_py_any(py).ok())
             }
             autosar_data_abstraction::communication::NmCluster::FlexrayNm(cluster) => {
-                Python::with_gil(|py| FlexrayNmCluster(cluster).into_py_any(py).ok())
+                Python::attach(|py| FlexrayNmCluster(cluster).into_py_any(py).ok())
             }
             autosar_data_abstraction::communication::NmCluster::UdpNm(cluster) => {
-                Python::with_gil(|py| UdpNmCluster(cluster).into_py_any(py).ok())
+                Python::attach(|py| UdpNmCluster(cluster).into_py_any(py).ok())
             }
         }))
     }
@@ -177,13 +177,13 @@ impl NmConfig {
     fn nm_cluster_couplings(&self) -> NmClusterCouplingIterator {
         NmClusterCouplingIterator::new(self.0.nm_cluster_couplings().filter_map(|coupling| match coupling {
             autosar_data_abstraction::communication::NmClusterCoupling::CanNmClusterCoupling(coupling) => {
-                Python::with_gil(|py| CanNmClusterCoupling(coupling).into_py_any(py).ok())
+                Python::attach(|py| CanNmClusterCoupling(coupling).into_py_any(py).ok())
             }
             autosar_data_abstraction::communication::NmClusterCoupling::FlexrayNmClusterCoupling(coupling) => {
-                Python::with_gil(|py| FlexrayNmClusterCoupling(coupling).into_py_any(py).ok())
+                Python::attach(|py| FlexrayNmClusterCoupling(coupling).into_py_any(py).ok())
             }
             autosar_data_abstraction::communication::NmClusterCoupling::UdpNmClusterCoupling(coupling) => {
-                Python::with_gil(|py| UdpNmClusterCoupling(coupling).into_py_any(py).ok())
+                Python::attach(|py| UdpNmClusterCoupling(coupling).into_py_any(py).ok())
             }
         }))
     }
@@ -208,12 +208,12 @@ impl NmConfig {
 
 iterator_wrapper!(
     NmClusterIterator,
-    PyObject,
+    Py<PyAny>,
     "Union[CanNmCluster, FlexrayNmCluster, UdpNmCluster]"
 );
 iterator_wrapper!(
     NmClusterCouplingIterator,
-    PyObject,
+    Py<PyAny>,
     "Union[CanNmClusterCoupling, FlexrayNmClusterCoupling, UdpNmClusterCoupling]"
 );
 iterator_wrapper!(NmEcuIterator, NmEcu);