module_def

RustPython · youknowone · Jan 22, 2026 · Jan 21, 2026 · Jan 16, 2026 · Jan 16, 2026
commit 32d2406fa8bd891cd88aa511eb183d5b3d17d1c5
diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
@@ -123,7 +123,7 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
                 pub(crate) const DOC: Option<&'static str> = #doc;
             },
             parse_quote! {
-                pub(crate) fn __module_def(
+                pub(crate) fn module_def(
                     ctx: &::rustpython_vm::Context,
                 ) -> &'static ::rustpython_vm::builtins::PyModuleDef {
                     DEF.get_or_init(|| {
@@ -144,7 +144,7 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
                     vm: &::rustpython_vm::VirtualMachine
                 ) -> ::rustpython_vm::PyRef<::rustpython_vm::builtins::PyModule> {
                     use ::rustpython_vm::PyPayload;
-                    let module = ::rustpython_vm::builtins::PyModule::from_def(__module_def(&vm.ctx)).into_ref(&vm.ctx);
+                    let module = ::rustpython_vm::builtins::PyModule::from_def(module_def(&vm.ctx)).into_ref(&vm.ctx);
                     __init_dict(vm, &module);
                     extend_module(vm, &module).unwrap();
                     module

diff --git a/crates/stdlib/src/binascii.rs b/crates/stdlib/src/binascii.rs
@@ -1,7 +1,7 @@
 // spell-checker:ignore hexlify unhexlify uuencodes CRCTAB rlecode rledecode
 
 pub(super) use decl::crc32;
-pub(crate) use decl::make_module;
+pub(crate) use decl::module_def;
 use rustpython_vm::{VirtualMachine, builtins::PyBaseExceptionRef, convert::ToPyException};
 
 const PAD: u8 = 61u8;

diff --git a/crates/stdlib/src/bisect.rs b/crates/stdlib/src/bisect.rs
@@ -1,4 +1,4 @@
-pub(crate) use _bisect::make_module;
+pub(crate) use _bisect::module_def;
 
 #[pymodule]
 mod _bisect {

diff --git a/crates/stdlib/src/blake2.rs b/crates/stdlib/src/blake2.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore usedforsecurity HASHXOF
 
-pub(crate) use _blake2::make_module;
+pub(crate) use _blake2::module_def;
 
 #[pymodule]
 mod _blake2 {

diff --git a/crates/stdlib/src/bz2.rs b/crates/stdlib/src/bz2.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore compresslevel
 
-pub(crate) use _bz2::make_module;
+pub(crate) use _bz2::module_def;
 
 #[pymodule]
 mod _bz2 {

diff --git a/crates/stdlib/src/cmath.rs b/crates/stdlib/src/cmath.rs
@@ -1,4 +1,4 @@
-pub(crate) use cmath::make_module;
+pub(crate) use cmath::module_def;
 
 #[pymodule]
 mod cmath {

diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
@@ -1,4 +1,4 @@
-pub(crate) use _csv::make_module;
+pub(crate) use _csv::module_def;
 
 #[pymodule]
 mod _csv {

diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
@@ -1,4 +1,4 @@
-pub(crate) use decl::make_module;
+pub(crate) use decl::module_def;
 
 #[allow(static_mut_refs)] // TODO: group code only with static mut refs
 #[pymodule(name = "faulthandler")]

diff --git a/crates/stdlib/src/fcntl.rs b/crates/stdlib/src/fcntl.rs
@@ -1,6 +1,6 @@
 // spell-checker:disable
 
-pub(crate) use fcntl::make_module;
+pub(crate) use fcntl::module_def;
 
 #[pymodule]
 mod fcntl {

diff --git a/crates/stdlib/src/gc.rs b/crates/stdlib/src/gc.rs
@@ -1,8 +1,8 @@
-pub(crate) use gc::make_module;
+pub(crate) use gc::module_def;
 
 #[pymodule]
 mod gc {
-    use crate::vm::{PyResult, VirtualMachine, function::FuncArgs};
+    use crate::vm::{PyObjectRef, PyResult, VirtualMachine, function::FuncArgs};
 
     #[pyfunction]
     fn collect(_args: FuncArgs, _vm: &VirtualMachine) -> i32 {
@@ -40,13 +40,15 @@ mod gc {
     }
 
     #[pyfunction]
-    fn get_referents(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
+    fn get_referents(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
+        // RustPython does not track object references.
+        vm.ctx.new_tuple(vec![]).into()
     }
 
     #[pyfunction]
-    fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
+    fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
+        // RustPython does not track object references.
+        vm.ctx.new_list(vec![]).into()
     }
 
     #[pyfunction]

diff --git a/crates/stdlib/src/grp.rs b/crates/stdlib/src/grp.rs
@@ -1,5 +1,5 @@
 // spell-checker:disable
-pub(crate) use grp::make_module;
+pub(crate) use grp::module_def;
 
 #[pymodule]
 mod grp {

diff --git a/crates/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore usedforsecurity HASHXOF
 
-pub(crate) use _hashlib::make_module;
+pub(crate) use _hashlib::module_def;
 
 #[pymodule]
 pub mod _hashlib {

diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
@@ -1,4 +1,4 @@
-pub(crate) use _json::make_module;
+pub(crate) use _json::module_def;
 mod machinery;
 
 #[pymodule]

diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
@@ -115,14 +115,6 @@ use alloc::borrow::Cow;
 /// These modules are added to sys.modules BEFORE their exec function runs,
 /// allowing safe circular imports.
 pub fn get_module_defs() -> impl Iterator<Item = (Cow<'static, str>, StdlibDefFunc)> {
-    [(
-        Cow::from("_asyncio"),
-        _asyncio::__module_def as StdlibDefFunc,
-    )]
-    .into_iter()
-}
-
-pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInitFunc)> {
     macro_rules! modules {
         {
             $(
@@ -132,7 +124,7 @@ pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInit
         } => {{
             [
                 $(
-                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
+                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), $val as StdlibDefFunc),)*
                 )*
             ]
             .into_iter()
@@ -141,109 +133,135 @@ pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInit
     modules! {
         #[cfg(all())]
         {
-            "array" => array::make_module,
-            "binascii" => binascii::make_module,
-            "_bisect" => bisect::make_module,
-            "_bz2" => bz2::make_module,
-            "cmath" => cmath::make_module,
-            "_contextvars" => contextvars::make_module,
-            "_csv" => csv::make_module,
-            "faulthandler" => faulthandler::make_module,
-            "gc" => gc::make_module,
-            "_hashlib" => hashlib::make_module,
-            "_sha1" => sha1::make_module,
-            "_sha3" => sha3::make_module,
-            "_sha256" => sha256::make_module,
-            "_sha512" => sha512::make_module,
-            "_md5" => md5::make_module,
-            "_blake2" => blake2::make_module,
-            "_json" => json::make_module,
-            "math" => math::make_module,
-            "pyexpat" => pyexpat::make_module,
-            "_opcode" => opcode::make_module,
-            "_random" => random::make_module,
-            "_statistics" => statistics::make_module,
-            "_struct" => pystruct::make_module,
-            "unicodedata" => unicodedata::make_module,
-            "zlib" => zlib::make_module,
-            "_statistics" => statistics::make_module,
-            "_suggestions" => suggestions::make_module,
-            // crate::vm::sysmodule::sysconfigdata_name() => sysconfigdata::make_module,
+            "_asyncio" => _asyncio::module_def,
+            "binascii" => binascii::module_def,
+            "_bisect" => bisect::module_def,
+            "_blake2" => blake2::module_def,
+            "_bz2" => bz2::module_def,
+            "cmath" => cmath::module_def,
+            "_csv" => csv::module_def,
+            "faulthandler" => faulthandler::module_def,
+            "gc" => gc::module_def,
+            "_hashlib" => hashlib::module_def,
+            "_json" => json::module_def,
+            "math" => math::module_def,
+            "_md5" => md5::module_def,
+            "_opcode" => opcode::module_def,
+            "_random" => random::module_def,
+            "_sha1" => sha1::module_def,
+            "_sha3" => sha3::module_def,
+            "_statistics" => statistics::module_def,
+            "_struct" => pystruct::module_def,
+            "_suggestions" => suggestions::module_def,
+            "zlib" => zlib::module_def,
         }
         #[cfg(any(unix, target_os = "wasi"))]
         {
-            "fcntl" => fcntl::make_module,
-        }
-        #[cfg(any(unix, windows, target_os = "wasi"))]
-        {
-            "select" => select::make_module,
+            "fcntl" => fcntl::module_def,
         }
         #[cfg(not(target_arch = "wasm32"))]
         {
-            "_multiprocessing" => multiprocessing::make_module,
-            "_socket" => socket::make_module,
+            "_multiprocessing" => multiprocessing::module_def,
         }
         #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
         {
-            "_lzma" => lzma::make_module,
-        }
-        #[cfg(all(feature = "sqlite", not(any(target_os = "android", target_arch = "wasm32"))))]
-        {
-            "_sqlite3" => sqlite::make_module,
+            "_lzma" => lzma::module_def,
         }
         #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-rustls"))]
         {
-            "_ssl" => ssl::make_module,
-        }
-        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
-        {
-            "_ssl" => openssl::make_module,
+            "_ssl" => ssl::module_def,
         }
         #[cfg(windows)]
         {
-            "_overlapped" => overlapped::make_module,
+            "_overlapped" => overlapped::module_def,
         }
-        // Unix-only
         #[cfg(unix)]
         {
-            "_posixsubprocess" => posixsubprocess::make_module,
+            "_posixsubprocess" => posixsubprocess::module_def,
         }
         #[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
         {
-            "_posixshmem" => posixshmem::make_module,
+            "_posixshmem" => posixshmem::module_def,
         }
         #[cfg(any(unix, windows))]
         {
-            "mmap" => mmap::make_module,
+            "mmap" => mmap::module_def,
         }
         #[cfg(all(unix, not(target_os = "redox")))]
         {
-            "syslog" => syslog::make_module,
-            "resource" => resource::make_module,
+            "syslog" => syslog::module_def,
+            "resource" => resource::module_def,
         }
         #[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
         {
-            "termios" => termios::make_module,
+            "termios" => termios::module_def,
         }
         #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
         {
-            "grp" => grp::make_module,
+            "grp" => grp::module_def,
         }
         #[cfg(target_os = "macos")]
         {
-            "_scproxy" => scproxy::make_module,
+            "_scproxy" => scproxy::module_def,
         }
         #[cfg(not(any(target_os = "android", target_os = "ios", target_os = "windows", target_arch = "wasm32", target_os = "redox")))]
         {
-            "_uuid" => uuid::make_module,
+            "_uuid" => uuid::module_def,
         }
         #[cfg(not(any(target_os = "ios", target_arch = "wasm32")))]
         {
-            "_locale" => locale::make_module,
+            "_locale" => locale::module_def,
         }
         #[cfg(feature = "tkinter")]
         {
-            "_tkinter" => tkinter::make_module,
+            "_tkinter" => tkinter::module_def,
+        }
+    }
+}
+
+/// Returns module initializers for single-phase init modules.
+/// These are modules that don't use #[pymodule] macro or need custom initialization.
+pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInitFunc)> {
+    macro_rules! modules {
+        {
+            $(
+                #[cfg($cfg:meta)]
+                { $( $key:expr => $val:expr),* $(,)? }
+            )*
+        } => {{
+            [
+                $(
+                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
+                )*
+            ]
+            .into_iter()
+        }};
+    }
+    modules! {
+        #[cfg(all())]
+        {
+            "array" => array::make_module,
+            "_contextvars" => contextvars::make_module,
+            "pyexpat" => pyexpat::make_module,
+            "_sha256" => sha256::make_module,
+            "_sha512" => sha512::make_module,
+            "unicodedata" => unicodedata::make_module,
+        }
+        #[cfg(any(unix, windows, target_os = "wasi"))]
+        {
+            "select" => select::make_module,
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            "_socket" => socket::make_module,
+        }
+        #[cfg(all(feature = "sqlite", not(any(target_os = "android", target_arch = "wasm32"))))]
+        {
+            "_sqlite3" => sqlite::make_module,
+        }
+        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
+        {
+            "_ssl" => openssl::make_module,
         }
     }
 }
diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore abday abmon yesexpr noexpr CRNCYSTR RADIXCHAR AMPM THOUSEP
 
-pub(crate) use _locale::make_module;
+pub(crate) use _locale::module_def;
 
 #[cfg(windows)]
 #[repr(C)]

diff --git a/crates/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
@@ -1,6 +1,6 @@
 // spell-checker:ignore ARMTHUMB
 
-pub(crate) use _lzma::make_module;
+pub(crate) use _lzma::module_def;
 
 #[pymodule]
 mod _lzma {

diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
@@ -1,4 +1,4 @@
-pub(crate) use math::make_module;
+pub(crate) use math::__module_def;
 
 use crate::vm::{VirtualMachine, builtins::PyBaseExceptionRef};
 

diff --git a/crates/stdlib/src/md5.rs b/crates/stdlib/src/md5.rs
@@ -1,4 +1,4 @@
-pub(crate) use _md5::make_module;
+pub(crate) use _md5::module_def;
 
 #[pymodule]
 mod _md5 {

diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
@@ -1,6 +1,6 @@
 // spell-checker:disable
 //! mmap module
-pub(crate) use mmap::make_module;
+pub(crate) use mmap::module_def;
 
 #[pymodule]
 mod mmap {

diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
@@ -1,4 +1,4 @@
-pub(crate) use _multiprocessing::make_module;
+pub(crate) use _multiprocessing::module_def;
 
 #[cfg(windows)]
 #[pymodule]

diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
@@ -1,4 +1,4 @@
-pub(crate) use opcode::make_module;
+pub(crate) use opcode::__module_def;
 
 #[pymodule]
 mod opcode {