RustPython · bschoenmaeckers · Jun 1, 2026 · bschoenmaeckers · Jun 12, 2026 · coderabbitai
diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
@@ -170,6 +170,7 @@ nvars
 opname
 opnames
 orelse
+osmodule
 outparam
 outparm
 paramfunc

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -343,6 +343,7 @@ jobs:
         with:
           openssl: true
 
+      # Keep features in sync with update-caches.yml CARGO_ARGS.
       - name: build rustpython
         run: cargo build --release --verbose --features=threading,jit ${{ env.CARGO_ARGS }}
 

diff --git a/.github/workflows/update-caches.yml b/.github/workflows/update-caches.yml
@@ -19,6 +19,7 @@ env:
   CARGO_PROFILE_TEST_DEBUG: 0
   CARGO_PROFILE_DEV_DEBUG: 0
   CARGO_PROFILE_RELEASE_DEBUG: 0
+  # Keep feature list in sync with CI's release build in .github/workflows/ci.yaml.
   CARGO_ARGS: --workspace --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,ssl-rustls-aws-lc,host_env,threading,jit --exclude rustpython_wasm --exclude rustpython-compiler-source --exclude rustpython-venvlauncher
 
 jobs:

diff --git a/crates/capi/Cargo.toml b/crates/capi/Cargo.toml
@@ -22,7 +22,7 @@ rustpython-stdlib = {workspace = true, features = ["threading"] }
 rustpython-pylib = { workspace = true }
 
 [dev-dependencies]
-pyo3 = { workspace = true, features = ["auto-initialize", "abi3"] }
+pyo3 = { workspace = true, features = ["auto-initialize", "abi3t"] }
 
 [lints]
 workspace = true
diff --git a/crates/capi/pyo3-rustpython.config b/crates/capi/pyo3-rustpython.config
@@ -1,5 +1,5 @@
-implementation=CPython
-version=3.14
+implementation=RustPython
+version=3.15
 shared=true
-abi3=true
+target_abi=RustPython-abi3t-3.15
 suppress_build_script_link_lines=true
diff --git a/crates/capi/src/abstract_.rs b/crates/capi/src/abstract_.rs
@@ -178,3 +178,40 @@ pub unsafe extern "C" fn PyObject_Size(obj: *mut PyObject) -> isize {
         obj.length(vm)
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use pyo3::prelude::*;
+    use pyo3::types::{PyDict, PyString};
+
+    #[test]
+    fn call_method1() {
+        Python::attach(|py| {
+            let string = PyString::new(py, "Hello, World!");
+            assert!(
+                string
+                    .call_method1("endswith", ("!",))
+                    .unwrap()
+                    .is_truthy()
+                    .unwrap()
+            );
+        })
+    }
+
+    #[test]
+    fn object_set_get_del_item() {
+        Python::attach(|py| {
+            let obj = PyDict::new(py).into_any();
+            obj.set_item("key", "value").unwrap();
+            assert_eq!(
+                obj.get_item("key")
+                    .unwrap()
+                    .cast_into::<PyString>()
+                    .unwrap(),
+                "value"
+            );
+            obj.del_item("key").unwrap();
+            assert!(obj.get_item("key").is_err());
+        })
+    }
+}
diff --git a/crates/capi/src/abstract_/iter.rs b/crates/capi/src/abstract_/iter.rs
@@ -89,7 +89,7 @@ pub unsafe extern "C" fn PyIter_Send(
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{PyAnyMethods, PyIterator, PyList, PySendResult};

diff --git a/crates/capi/src/abstract_/mapping.rs b/crates/capi/src/abstract_/mapping.rs
@@ -194,7 +194,7 @@ pub unsafe extern "C" fn PyMapping_SetItemString(
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{PyDict, PyMapping, PyMappingMethods, PyTuple};

diff --git a/crates/capi/src/abstract_/number.rs b/crates/capi/src/abstract_/number.rs
@@ -232,7 +232,7 @@ pub unsafe extern "C" fn PyNumber_Subtract(o1: *mut PyObject, o2: *mut PyObject)
     with_vm(|vm| vm._sub(unsafe { &*o1 }, unsafe { &*o2 }))
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
 

diff --git a/crates/capi/src/abstract_/sequence.rs b/crates/capi/src/abstract_/sequence.rs
@@ -177,7 +177,7 @@ pub unsafe extern "C" fn PySequence_In(obj: *mut PyObject, value: *mut PyObject)
     unsafe { PySequence_Contains(obj, value) }
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{PyAnyMethods, PyDict, PyList, PySequence, PySequenceMethods, PyTuple};

diff --git a/crates/capi/src/bytearrayobject.rs b/crates/capi/src/bytearrayobject.rs
@@ -71,7 +71,7 @@ pub unsafe extern "C" fn PyByteArray_Resize(bytearray: *mut PyObject, len: isize
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{PyByteArray, PyBytes};

diff --git a/crates/capi/src/bytesobject.rs b/crates/capi/src/bytesobject.rs
@@ -1,6 +1,5 @@
-use crate::PyObject;
 use crate::object::define_py_check;
-use crate::pystate::with_vm;
+use crate::{PyObject, pystate::with_vm};
 use core::ffi::c_char;
 use rustpython_vm::builtins::PyBytes;
 
@@ -46,21 +45,21 @@ pub unsafe extern "C" fn PyBytes_AsString(bytes: *mut PyObject) -> *mut c_char {
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::PyBytes;
 
     #[test]
-    fn test_bytes() {
+    fn bytes() {
         Python::attach(|py| {
             let bytes = PyBytes::new(py, b"Hello, World!");
             assert_eq!(bytes.as_bytes(), b"Hello, World!");
         })
     }
 
     #[test]
-    fn test_bytes_uninit() {
+    fn bytes_uninit() {
         Python::attach(|py| {
             let bytes = PyBytes::new_with(py, 13, |data| {
                 data.copy_from_slice(b"Hello, World!");

diff --git a/crates/capi/src/ceval.rs b/crates/capi/src/ceval.rs
@@ -52,21 +52,21 @@ pub extern "C" fn PyEval_GetBuiltins() -> *mut PyObject {
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::exceptions::PyException;
     use pyo3::prelude::*;
 
     #[test]
-    fn test_code_eval() {
+    fn code_eval() {
         Python::attach(|py| {
             let result = py.eval(c"1 + 1", None, None).unwrap();
             assert_eq!(result.extract::<u32>().unwrap(), 2);
         })
     }
 
     #[test]
-    fn test_code_run_exception() {
+    fn code_run_exception() {
         Python::attach(|py| {
             let err = py.run(c"raise Exception()", None, None).unwrap_err();
             assert!(err.is_instance_of::<PyException>(py));

diff --git a/crates/capi/src/complexobject.rs b/crates/capi/src/complexobject.rs
@@ -36,13 +36,13 @@ pub unsafe extern "C" fn PyComplex_ImagAsDouble(obj: *mut PyObject) -> c_double
     with_vm(|vm| try_to_complex(vm, unsafe { &*obj }).map(|complex| complex.im))
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::PyComplex;
 
     #[test]
-    fn test_py_int() {
+    fn py_int() {
         Python::attach(|py| {
             let number = PyComplex::from_doubles(py, 1.0, 2.0);
             assert_eq!(number.real(), 1.0);

diff --git a/crates/capi/src/critical_section.rs b/crates/capi/src/critical_section.rs
@@ -0,0 +1,31 @@
+use crate::PyObject;
+
+#[repr(C)]
+pub struct PyCriticalSection;
+
+#[repr(C)]
+pub struct PyCriticalSection2;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn PyCriticalSection_Begin(c: *mut PyCriticalSection, op: *mut PyObject) {
+    let _ = (c, op);
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn PyCriticalSection_End(c: *mut PyCriticalSection) {
+    let _ = c;
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn PyCriticalSection2_Begin(
+    c: *mut PyCriticalSection2,
+    a: *mut PyObject,
+    b: *mut PyObject,
+) {
+    let _ = (c, a, b);
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn PyCriticalSection2_End(c: *mut PyCriticalSection2) {
+    let _ = c;
+}
diff --git a/crates/capi/src/descrobject.rs b/crates/capi/src/descrobject.rs
@@ -11,7 +11,7 @@ pub unsafe extern "C" fn PyDictProxy_New(mapping: *mut PyObject) -> *mut PyObjec
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{PyDict, PyInt, PyMappingProxy};
@@ -23,7 +23,7 @@ mod tests {
             dict.set_item("x", 7).unwrap();
 
             let mapping = dict.as_mapping();
-            let proxy = PyMappingProxy::new(py, &mapping);
+            let proxy = PyMappingProxy::new(py, mapping);
             let value = proxy.get_item("x").unwrap().cast_into::<PyInt>().unwrap();
             assert_eq!(value, 7);
         })

diff --git a/crates/capi/src/dictobject.rs b/crates/capi/src/dictobject.rs
@@ -57,6 +57,43 @@ pub unsafe extern "C" fn PyDict_GetItemRef(
     })
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn PyDict_SetDefaultRef(
+    dict: *mut PyObject,
+    key: *mut PyObject,
+    default_value: *mut PyObject,
+    result: *mut *mut PyObject,
+) -> c_int {
+    with_vm(|vm| {
+        let result = NonNull::new(result);
+        if let Some(result) = result {
+            unsafe {
+                result.write(core::ptr::null_mut());
+            }
+        }
+        let dict = unsafe { &*dict }.try_downcast_ref::<PyDict>(vm)?;
+        let key = unsafe { &*key };
+
+        if let Some(value) = dict.inner_getitem_opt(key, vm)? {
+            if let Some(result) = result {
+                unsafe {
+                    result.write(value.into_raw().as_ptr());
+                }
+            }
+            Ok(true)
+        } else {
+            let value = unsafe { &*default_value }.to_owned();
+            dict.inner_setitem(key, value.clone(), vm)?;
+            if let Some(result) = result {
+                unsafe {
+                    result.write(value.into_raw().as_ptr());
+                }
+            }
+            Ok(false)
+        }
+    })
+}
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn PyDict_Size(dict: *mut PyObject) -> isize {
     with_vm(|vm| {
@@ -187,21 +224,21 @@ pub unsafe extern "C" fn PyDict_Next(
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use pyo3::prelude::*;
     use pyo3::types::{IntoPyDict, PyDict, PyDictMethods, PyInt, PyList};
 
     #[test]
-    fn test_create_empty_dict() {
+    fn create_empty_dict() {
         Python::attach(|py| {
             let dict = PyDict::new(py);
             assert!(dict.is_instance_of::<PyDict>());
         })
     }
 
     #[test]
-    fn test_create_dict_with_items() {
+    fn create_dict_with_items() {
         Python::attach(|py| {
             let dict = [(1, 2), (3, 4)].into_py_dict(py)?;
             let value = dict.get_item(1)?.unwrap().cast_into::<PyInt>()?;
@@ -214,7 +251,7 @@ mod tests {
     }
 
     #[test]
-    fn test_dict_iter() {
+    fn dict_iter() {
         Python::attach(|py| {
             let dict = [(1, 2), (3, 4)].into_py_dict(py).unwrap();
             let values = dict

diff --git a/crates/capi/src/floatobject.rs b/crates/capi/src/floatobject.rs
@@ -57,14 +57,14 @@ pub unsafe extern "C" fn PyFloat_FromString(obj: *mut PyObject) -> *mut PyObject
     })
 }
 
-#[cfg(false)]
+#[cfg(test)]
 mod tests {
     use core::f64::consts::PI;
     use pyo3::prelude::*;
     use pyo3::types::PyFloat;
 
     #[test]
-    fn test_py_float() {
+    fn py_float() {
         Python::attach(|py| {
             let pi = PyFloat::new(py, PI);
             assert!(pi.is_instance_of::<PyFloat>());

diff --git a/crates/capi/src/genericaliasobject.rs b/crates/capi/src/genericaliasobject.rs
@@ -0,0 +1,15 @@
+use crate::{PyObject, pystate::with_vm};
+use rustpython_vm::PyPayload;
+use rustpython_vm::builtins::PyGenericAlias;
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn Py_GenericAlias(
+    origin: *mut PyObject,
+    args: *mut PyObject,
+) -> *mut PyObject {
+    with_vm(|vm| {
+        let origin = unsafe { &*origin }.to_owned();
+        let args = unsafe { &*args }.to_owned();
+        PyGenericAlias::from_args(origin, args, vm).into_pyobject(vm)
+    })
+}
-Original file line number
+Diff line change
@@ Expand Up / @@ -170,6 +170,7 @@ nvars @@
     opname
     opnames
     orelse
+    osmodule
     outparam
     outparm
     paramfunc
@@ Expand Down @@