Fix CI failures: add Python setup, fix clippy deprecations, fix stubtest compat

- rust-test.yml, static-checks.yml: add actions/setup-python so PyO3 can
  link against libpython during cargo test and clippy
- src/*.rs: cargo fmt, replace deprecated PyObject with Py<PyAny>,
  replace downcast() with cast()
- tests/test_stubs.py: conditionally use --ignore-disjoint-bases only
  when the installed mypy version supports it (fixes min-deps matrix)

Author: nathanjmcdougall

.github/workflows/rust-test.yml

@@ -34,6 +34,11 @@ jobs:
         with:
           persist-credentials: false
 
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.10"
+
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@3c5f7ea28cd621ae0bf5283f0e981fb97b8a7af9 # master
         with:

.github/workflows/static-checks.yml

@@ -39,6 +39,11 @@ jobs:
               with:
                   persist-credentials: false
 
+            - name: Set up Python
+              uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+              with:
+                  python-version: "3.10"
+
             - name: Install Rust toolchain
               uses: dtolnay/rust-toolchain@3c5f7ea28cd621ae0bf5283f0e981fb97b8a7af9 # master
               with:

src/convert.rs

@@ -34,22 +34,23 @@ pub fn py_to_yaml_value(obj: &Bound<'_, PyAny>) -> PyResult<Value> {
         if f.is_finite() {
             Ok(Value::Number(serde_yaml::Number::from(f)))
         } else {
-            Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
-                format!("Cannot convert float value {f} to YAML number"),
-            ))
+            Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Cannot convert float value {f} to YAML number"
+            )))
         }
     } else if obj.is_instance_of::<PyString>() {
         Ok(Value::String(obj.extract::<String>()?))
     } else if obj.is_instance_of::<PyList>() {
-        let list = obj.downcast::<PyList>()?;
+        let list = obj.cast::<PyList>()?;
         let items: PyResult<Vec<Value>> = list.iter().map(|item| py_to_yaml_value(&item)).collect();
         Ok(Value::Sequence(items?))
     } else if obj.is_instance_of::<PyTuple>() {
-        let tuple = obj.downcast::<PyTuple>()?;
-        let items: PyResult<Vec<Value>> = tuple.iter().map(|item| py_to_yaml_value(&item)).collect();
+        let tuple = obj.cast::<PyTuple>()?;
+        let items: PyResult<Vec<Value>> =
+            tuple.iter().map(|item| py_to_yaml_value(&item)).collect();
         Ok(Value::Sequence(items?))
     } else if obj.is_instance_of::<PyDict>() {
-        let dict = obj.downcast::<PyDict>()?;
+        let dict = obj.cast::<PyDict>()?;
         let mut mapping = serde_yaml::Mapping::new();
         for (k, v) in dict.iter() {
             let key = py_to_yaml_value(&k)?;
@@ -71,7 +72,7 @@ pub fn py_to_yaml_value(obj: &Bound<'_, PyAny>) -> PyResult<Value> {
 /// This function recurses without a depth limit. The input comes from
 /// `serde_yaml::from_str`, which enforces its own recursion limit (128
 /// by default), so the nesting depth is bounded in practice.
-pub fn yaml_value_to_py(py: Python<'_>, value: &Value) -> PyResult<PyObject> {
+pub fn yaml_value_to_py(py: Python<'_>, value: &Value) -> PyResult<Py<PyAny>> {
     match value {
         Value::Null => Ok(py.None()),
         Value::Bool(b) => Ok(b.into_pyobject(py)?.as_any().to_owned().unbind()),
@@ -152,7 +153,10 @@ mod tests {
             // i64::MAX + 1 is a valid u64 but overflows i64
             let large = (i64::MAX as u64 + 1).into_pyobject(py).unwrap().into_any();
             let val = py_to_yaml_value(&large).unwrap();
-            assert_eq!(val, Value::Number(serde_yaml::Number::from(i64::MAX as u64 + 1)));
+            assert_eq!(
+                val,
+                Value::Number(serde_yaml::Number::from(i64::MAX as u64 + 1))
+            );
         });
     }
 
@@ -192,10 +196,7 @@ mod tests {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
             let s = "hello".into_pyobject(py).unwrap().into_any();
-            assert_eq!(
-                py_to_yaml_value(&s).unwrap(),
-                Value::String("hello".into())
-            );
+            assert_eq!(py_to_yaml_value(&s).unwrap(), Value::String("hello".into()));
         });
     }
 

src/document.rs

@@ -14,9 +14,7 @@ impl PyDocument {
     #[new]
     fn new(source: &str) -> PyResult<Self> {
         let doc = yamlpath::Document::new(source).map_err(|e| {
-            PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-                "Failed to parse YAML: {e}"
-            ))
+            PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Failed to parse YAML: {e}"))
         })?;
         Ok(Self { inner: doc })
     }
@@ -60,7 +58,8 @@ impl PyDocument {
                 "Feature location is out of bounds",
             ));
         }
-        source.get(start..end)
+        source
+            .get(start..end)
             .map(|s| s.to_string())
             .ok_or_else(|| {
                 PyErr::new::<pyo3::exceptions::PyValueError, _>(
@@ -74,7 +73,7 @@ impl PyDocument {
     }
 
     /// Parse the YAML value at a route and return it as a Python object.
-    fn parse_value(&self, py: Python<'_>, route: &PyRoute) -> PyResult<PyObject> {
+    fn parse_value(&self, py: Python<'_>, route: &PyRoute) -> PyResult<Py<PyAny>> {
         let source = self.inner.source();
         let r = route.to_yamlpath_route();
 
@@ -99,10 +98,7 @@ impl PyDocument {
                     // Calculate the column offset (in bytes) of the value
                     // start relative to the beginning of its line, so we can
                     // dedent continuation lines.
-                    let line_start = source[..span.0]
-                        .rfind('\n')
-                        .map(|nl| nl + 1)
-                        .unwrap_or(0);
+                    let line_start = source[..span.0].rfind('\n').map(|nl| nl + 1).unwrap_or(0);
                     let col = span.0 - line_start;
                     if col == 0 {
                         raw.to_string()
@@ -128,7 +124,7 @@ impl PyDocument {
                 Err(e) => {
                     return Err(PyErr::new::<pyo3::exceptions::PyKeyError, _>(format!(
                         "Query error: {e}"
-                    )))
+                    )));
                 }
             }
         };
@@ -151,16 +147,14 @@ impl PyDocument {
             })
             .collect();
 
-        let result =
-            yamlpatch::apply_yaml_patches(&self.inner, &yaml_patches).map_err(|e| {
-                PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!("Patch failed: {e}"))
-            })?;
+        let result = yamlpatch::apply_yaml_patches(&self.inner, &yaml_patches).map_err(|e| {
+            PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!("Patch failed: {e}"))
+        })?;
 
         Ok(Self { inner: result })
     }
 }
 
-
 fn convert_feature(feature: &yamlpath::Feature<'_>) -> PyFeature {
     PyFeature {
         location: PyLocation {

src/lib.rs

@@ -13,22 +13,22 @@ use types::{PyComponent, PyFeature, PyFeatureKind, PyLocation, PyRoute};
 mod _core {
     use super::*;
 
-    #[pymodule_export]
-    use super::PyLocation;
-    #[pymodule_export]
-    use super::PyFeatureKind;
     #[pymodule_export]
     use super::PyComponent;
     #[pymodule_export]
-    use super::PyRoute;
+    use super::PyDocument;
     #[pymodule_export]
     use super::PyFeature;
     #[pymodule_export]
-    use super::PyDocument;
+    use super::PyFeatureKind;
+    #[pymodule_export]
+    use super::PyLocation;
     #[pymodule_export]
     use super::PyOp;
     #[pymodule_export]
     use super::PyPatch;
+    #[pymodule_export]
+    use super::PyRoute;
 
     #[pyfunction]
     fn apply_patches(source: &str, patches: Vec<PyPatch>) -> PyResult<String> {

src/ops.rs

@@ -49,11 +49,11 @@ impl PyOp {
     /// Merge key-value pairs into an existing mapping.
     #[staticmethod]
     fn merge_into(key: &str, updates: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let dict = updates.downcast::<pyo3::types::PyDict>().map_err(|_| {
-            let type_name = updates.get_type().name().map_or_else(
-                |_| "<unknown>".to_string(),
-                |n| n.to_string(),
-            );
+        let dict = updates.cast::<pyo3::types::PyDict>().map_err(|_| {
+            let type_name = updates
+                .get_type()
+                .name()
+                .map_or_else(|_| "<unknown>".to_string(), |n| n.to_string());
             PyErr::new::<pyo3::exceptions::PyTypeError, _>(format!(
                 "updates must be a dict, got {type_name}"
             ))
@@ -88,7 +88,11 @@ impl PyOp {
                 format!("Op.merge_into({}, ...)", yaml_str_repr(key))
             }
             yamlpatch::Op::RewriteFragment { from, to } => {
-                format!("Op.rewrite_fragment({}, {})", yaml_str_repr(&format!("{from:?}")), yaml_str_repr(to))
+                format!(
+                    "Op.rewrite_fragment({}, {})",
+                    yaml_str_repr(&format!("{from:?}")),
+                    yaml_str_repr(to)
+                )
             }
             yamlpatch::Op::ReplaceComment { new } => {
                 format!("Op.replace_comment({})", yaml_str_repr(new))

src/types.rs

@@ -15,9 +15,9 @@ impl PyLocation {
     #[new]
     fn new(start: usize, end: usize) -> PyResult<Self> {
         if start > end {
-            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
-                format!("Location start ({start}) must not exceed end ({end})"),
-            ));
+            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
+                "Location start ({start}) must not exceed end ({end})"
+            )));
         }
         Ok(Self { start, end })
     }
@@ -37,7 +37,14 @@ impl From<yamlpath::Location> for PyLocation {
 }
 
 /// The kind of a YAML feature.
-#[pyclass(name = "FeatureKind", module = "yamltrip._core", frozen, eq, eq_int, hash)]
+#[pyclass(
+    name = "FeatureKind",
+    module = "yamltrip._core",
+    frozen,
+    eq,
+    eq_int,
+    hash
+)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum PyFeatureKind {
     Scalar,
@@ -255,9 +262,7 @@ mod tests {
 
     #[test]
     fn test_empty_route_conversion() {
-        let route = PyRoute {
-            components: vec![],
-        };
+        let route = PyRoute { components: vec![] };
         let _yamlpath_route = route.to_yamlpath_route();
     }
 

tests/test_stubs.py

@@ -6,17 +6,30 @@
 import pytest
 
 
+def _stubtest_supports_ignore_disjoint_bases() -> bool:
+    """Check if the installed mypy stubtest supports --ignore-disjoint-bases."""
+    result = subprocess.run(
+        [sys.executable, "-m", "mypy.stubtest", "--help"],
+        capture_output=True,
+        text=True,
+    )
+    return "--ignore-disjoint-bases" in result.stdout
+
+
 def test_stubtest_core():
     """Run mypy stubtest against yamltrip._core to catch stub drift."""
+    cmd = [
+        sys.executable,
+        "-m",
+        "mypy.stubtest",
+        "yamltrip._core",
+    ]
+    if _stubtest_supports_ignore_disjoint_bases():
+        cmd.append("--ignore-disjoint-bases")
+
     try:
         result = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "mypy.stubtest",
-                "yamltrip._core",
-                "--ignore-disjoint-bases",
-            ],
+            cmd,
             capture_output=True,
             text=True,
         )