youknowone · Nov 8, 2026 · Nov 4, 2026 · Nov 4, 2026 · Nov 4, 2026 · Nov 4, 2026
diff --git a/crates/capi/src/import.rs b/crates/capi/src/import.rs
@@ -8,11 +8,7 @@ use rustpython_vm::import::{add_module, import_code_obj};
 pub unsafe extern "C" fn PyImport_Import(name: *mut PyObject) -> *mut PyObject {
     with_vm(|vm| {
         let name = unsafe { name.assume_borrowed_and_cast::<PyStr>(vm) }?;
-        let _ = vm.import(name, 0)?;
-
-        vm.sys_module
-            .get_attr(rustpython_vm::identifier!(vm, modules), vm)?
-            .get_item(name, vm)
+        rustpython_vm::import::import_module(vm, name)
     })
 }
 

diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
@@ -11,6 +11,61 @@ use crate::{
 use core::{cell::Cell, sync::atomic::Ordering, time::Duration};
 use std::{io::Write, time::Instant};
 
+/// Import for side effects and return the exact named module (PyImport_Import).
+/// Unlike ordinary imports, this re-reads globals' builtins and passes globals
+/// as both namespace arguments to the selected importer.
+pub fn import_module(vm: &VirtualMachine, module_name: &Py<PyStr>) -> PyResult {
+    let from_list = vm.ctx.new_list(vec![]);
+    let mut importer: Option<PyObjectRef> = None;
+    let mut builtins: Option<PyObjectRef> = None;
+    let mut globals: Option<PyObjectRef> = crate::frame::current_globals().map(Into::into);
+    let has_globals = globals.is_some();
+    // Keep the selected module/error alive across callback-capable cleanup on
+    // every path, including lookup and invocation failures.
+    (|| {
+        let globals = globals.get_or_insert_with(|| vm.ctx.new_dict().into());
+        let builtins = builtins.insert(if has_globals {
+            globals.get_item(identifier!(vm, __builtins__), vm)?
+        } else {
+            // Bootstrap without calling this helper or the frame's importer.
+            let builtins = import_module_level(vm.ctx.intern_str("builtins"), None, None, 0, vm)?;
+            globals.set_item(identifier!(vm, __builtins__), builtins.clone(), vm)?;
+            builtins
+        });
+        let importer = importer.insert(if builtins.downcast_ref::<PyDict>().is_some() {
+            // Dict subclasses keep their subscription callbacks, but every
+            // lookup failure is replaced, not just KeyError.
+            builtins
+                .get_item(identifier!(vm, __import__), vm)
+                .map_err(|_err| vm.new_key_error(identifier!(vm, __import__).to_owned().into()))?
+        } else {
+            builtins.get_attr(identifier!(vm, __import__), vm)?
+        });
+        let imported = importer.call(
+            (
+                module_name.to_owned(),
+                globals.clone(),
+                globals.clone(),
+                from_list.clone(),
+                0,
+            ),
+            vm,
+        )?;
+        drop(imported);
+
+        // RustPython currently exposes the registry through sys' dictionary;
+        // unlike CPython's interpreter-owned registry, reassignment is visible.
+        let modules = vm.sys_module.dict().get_item("modules", vm)?;
+        let selected = match modules.get_item(module_name, vm) {
+            Ok(module) => Ok(Some(module)),
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.key_error) => Ok(None),
+            Err(err) => Err(err),
+        };
+        drop(modules);
+        selected?.ok_or_else(|| vm.new_key_error(module_name.to_owned().into()))
+    })()
+}
+
 /// Return a module from `sys.modules`, creating it if absent or not a module.
 ///
 /// Exact dictionaries use conditional mutations so concurrent callers agree on

diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
@@ -22,7 +22,7 @@ mod builtins {
         common::hash::PyHash,
         function::{
             ArgCallable, ArgIndex, ArgIntoBool, ArgMapping, ArgSpec, ArgStrOrBytesLike, Either,
-            FsPath, FuncArgs, KwArgs, NameKws, NameObjects, OptionalArg, PosArgs,
+            FsPath, FuncArgs, KwArgs, NameObjects, OptionalArg, PosArgs,
         },
         protocol::{PyIter, PyIterReturn},
         py_io,
@@ -800,22 +800,21 @@ mod builtins {
     }
 
     #[pyfunction]
-    fn breakpoint(
-        args: PosArgs,
-        kws: KwArgs<PyObjectRef, NameKws>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let args = FuncArgs {
-            args: args.into_vec(),
-            kwargs: kws.into_default(),
-        };
-        match vm
+    fn breakpoint(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // PySys_GetAttr reads the dictionary, bypassing module attribute hooks.
+        // A present None is still selected and audited before the call fails.
+        let hook = vm
             .sys_module
-            .get_attr(vm.ctx.intern_str("breakpointhook"), vm)
-        {
-            Ok(hook) => hook.as_ref().call(args, vm),
-            Err(_) => Err(vm.new_runtime_error("lost sys.breakpointhook")),
-        }
+            .dict()
+            .get_item_opt("breakpointhook", vm)?
+            .ok_or_else(|| vm.new_runtime_error("lost sys.breakpointhook"))?;
+        vm.audit("builtins.breakpoint", || (hook.clone(),))?;
+
+        // Audit callbacks can replace sys.breakpointhook. Invoke the selected
+        // hook, retaining the original arguments until that hook is released.
+        // Scope cleanup drops the later hook binding before the retained args.
+        let (_retained_args, hook) = (args.clone(), hook);
+        hook.call(args, vm)
     }
 
     #[pyfunction]

diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
@@ -972,55 +972,73 @@ pub mod sys {
     #[pyfunction]
     pub fn breakpointhook(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         #[cfg(feature = "host_env")]
-        let env_var = crate::host_env::os::var("PYTHONBREAKPOINT")
-            .and_then(|env_var| {
-                if env_var.is_empty() {
-                    Err(std::env::VarError::NotPresent)
-                } else {
-                    Ok(env_var)
-                }
-            })
-            .unwrap_or_else(|_| "pdb.set_trace".to_owned());
+        let env_var = if vm.state.config.settings.ignore_environment {
+            None
+        } else {
+            crate::host_env::os::var("PYTHONBREAKPOINT").ok()
+        };
         #[cfg(not(feature = "host_env"))]
-        let env_var = "pdb.set_trace".to_owned();
+        let env_var: Option<String> = None;
 
-        if env_var.eq("0") {
+        // Own the environment value before importing: import callbacks can
+        // change the environment while the selected hook is being resolved.
+        let env_var = env_var
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| "pdb.set_trace".to_owned());
+
+        if env_var == "0" {
             return Ok(vm.ctx.none());
-        };
+        }
 
         let print_unimportable_module_warn = || {
             warn(
                 vm.ctx.exceptions.runtime_warning,
-                format!("Ignoring unimportable $PYTHONBREAKPOINT: \"{env_var}\"",),
+                format!("Ignoring unimportable $PYTHONBREAKPOINT: \"{env_var}\""),
                 0,
                 vm,
             )?;
             Ok(vm.ctx.none())
         };
 
-        let last = match env_var.rsplit_once('.') {
-            Some((_, last)) => last,
-            None if !env_var.is_empty() => env_var.as_str(),
-            _ => return print_unimportable_module_warn(),
+        let (module_path, attr_name) = match env_var.rsplit_once('.') {
+            // A leading separator has no module to import. A trailing one
+            // still imports the module and looks up the empty attribute.
+            Some(("", _)) => return print_unimportable_module_warn(),
+            Some((module_path, attr_name)) => (module_path, attr_name),
+            None => ("builtins", env_var.as_str()),
         };
 
-        let (module_path, attr_name) = if last == env_var {
-            ("builtins", env_var.as_str())
-        } else {
-            (&env_var[..(env_var.len() - last.len() - 1)], last)
+        let module_name = vm.ctx.new_str(module_path);
+        let module = crate::import::import_module(vm, &module_name);
+        drop(module_name);
+        let module = match module {
+            Ok(module) => module,
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.import_error) => {
+                drop(err);
+                return print_unimportable_module_warn();
+            }
+            Err(err) => return Err(err),
         };
 
-        let module = match vm.import(&vm.ctx.new_str(module_path), 0) {
-            Ok(module) => module,
-            Err(_) => {
+        // AttributeError is the only lookup failure treated as an unavailable
+        // hook. Release the module before warning or invoking the hook: its
+        // attribute callback may have removed it from sys.modules.
+        let hook = module.get_attr(&vm.ctx.new_str(attr_name), vm);
+        drop(module);
+        let hook = match hook {
+            Ok(hook) => hook,
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
+                drop(err);
                 return print_unimportable_module_warn();
             }
+            Err(err) => return Err(err),
         };
 
-        match vm.get_attribute_opt(&module, &vm.ctx.new_str(attr_name)) {
-            Ok(Some(hook)) => hook.as_ref().call(args, vm),
-            _ => print_unimportable_module_warn(),
-        }
+        // Calling consumes FuncArgs. Keep the original owners alive through
+        // release of the resolved callable, including when its call fails.
+        // Scope cleanup drops the later hook binding before the retained args.
+        let (_retained_args, hook) = (args.clone(), hook);
+        hook.call(args, vm)
     }
 
     #[pyfunction]