use crate::common::{

lock::{PyMutex, PyRwLock},

wtf8::{Wtf8Buf, wtf8_concat},

};

use crate::vm::{

AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,

VirtualMachine,

builtins::{

PyBaseExceptionRef, PyByteArray, PyBytes, PyDict, PyDictRef, PyFloat, PyFrozenSet,

PyInt, PyList, PySet, PyStr, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef,

},

function::{ArgIntoBool, FuncArgs, OptionalArg, PySetterValue},

object::{Traverse, TraverseFn},

protocol::{PyBuffer, PyIter, PyIterReturn},

types::{AsBuffer, Constructor, Initializer, Representable},

utils::ToCString,

};

use alloc::collections::TryReserveError;

use core::sync::atomic::{AtomicI32, Ordering};

use malachite_bigint::BigInt;

use num_traits::{ToPrimitive, Zero};

use std::collections::HashMap;

// The highest protocol number `_pickle` knows how to read.

#[pyattr]

const HIGHEST_PROTOCOL: u8 = 5;

// The protocol `dumps`/`dump` use when no protocol is given.

#[pyattr]

const DEFAULT_PROTOCOL: u8 = 5;

#[pyattr(name = "PickleError", once)]

fn pickle_error(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx.new_exception_type(

"_pickle",

"PickleError",

Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),

)

}

#[pyattr(name = "PicklingError", once)]

fn pickling_error(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx

.new_exception_type("_pickle", "PicklingError", Some(vec![pickle_error(vm)]))

}

#[pyattr(name = "UnpicklingError", once)]

fn unpickling_error(vm: &VirtualMachine) -> PyTypeRef {

vm.ctx

.new_exception_type("_pickle", "UnpicklingError", Some(vec![pickle_error(vm)]))

}

pub(super) fn new_pickling_error(

vm: &VirtualMachine,

msg: impl Into<rustpython_common::wtf8::Wtf8Buf>,

) -> PyBaseExceptionRef {

vm.new_exception_msg(pickling_error(vm), msg.into())

}

pub(super) fn new_unpickling_error(

vm: &VirtualMachine,

msg: impl Into<rustpython_common::wtf8::Wtf8Buf>,

) -> PyBaseExceptionRef {

vm.new_exception_msg(unpickling_error(vm), msg.into())

}

// PickleBuffer

#[pyattr]

#[pyclass(module = "pickle", name = "PickleBuffer")]

#[derive(Debug, PyPayload)]

pub(super) struct PyPickleBuffer {

buffer: PyRwLock<Option<PyBuffer>>,

}

impl Constructor for PyPickleBuffer {

type Args = PyObjectRef;

fn py_new(_cls: &Py<PyType>, arg: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {

let buffer =

PyBuffer::from_object(vm, &arg, crate::vm::protocol::BufferFlags::FULL_RO)?;

Ok(Self {

buffer: PyRwLock::new(Some(buffer)),

})

}

}

#[pyclass(

impl PyPickleBuffer {

fn get(&self, vm: &VirtualMachine) -> PyResult<PyBuffer> {

self.buffer.read().clone().ok_or_else(|| {

vm.new_value_error("operation forbidden on released PickleBuffer object")

})

}

#[pymethod]

fn raw(

zelf: &Py<Self>,

vm: &VirtualMachine,

) -> PyResult<PyRef<crate::vm::builtins::PyMemoryView>> {

let buffer = zelf.get(vm)?;

if !buffer.desc.is_contiguous() {

return Err(vm.new_buffer_error(

"cannot pickle a non-contiguous buffer: PickleBuffer is not contiguous",

));

}

Ok(crate::vm::builtins::PyMemoryView::from_buffer(buffer, vm)?.into_ref(&vm.ctx))

}

#[pymethod]

fn release(zelf: &Py<Self>) {

// Releasing the last share can invoke Python's __release_buffer__.

// Publish the released state and drop the lock before that callback.

let buffer = zelf.buffer.write().take();

drop(buffer);

}

}

impl AsBuffer for PyPickleBuffer {

fn as_buffer(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyBuffer> {

zelf.get(vm)

}

}

impl Representable for PyPickleBuffer {

fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {

Ok(format!("<PickleBuffer object at {:#x}>", zelf.get_id()))

}

}

// Pickle opcodes. These must be kept updated with pickle.py.

// Extensive docs are in pickletools.py.

macro_rules! pickle_opcodes {

($($name:ident = $val:expr),* $(,)?) => {

#[repr(u8)]

#[derive(Copy, Clone, Debug, Eq, PartialEq)]

#[allow(non_camel_case_types, clippy::upper_case_acronyms)]

enum Opcode {

$($name = $val,)*

}

impl Opcode {

fn from_u8(b: u8) -> Option<Self> {

match b {

$($val => Some(Self::$name),)*

_ => None,

}

}

}

};

}

pickle_opcodes! {

MARK = b'(',

STOP = b'.',

POP = b'0',

POP_MARK = b'1',

DUP = b'2',

FLOAT = b'F',

INT = b'I',

BININT = b'J',

BININT1 = b'K',

LONG = b'L',

BININT2 = b'M',

NONE = b'N',

PERSID = b'P',

BINPERSID = b'Q',

REDUCE = b'R',

STRING = b'S',

BINSTRING = b'T',

SHORT_BINSTRING = b'U',

UNICODE = b'V',

BINUNICODE = b'X',

APPEND = b'a',

BUILD = b'b',

GLOBAL = b'c',

DICT = b'd',

EMPTY_DICT = b'}',

APPENDS = b'e',

GET = b'g',

BINGET = b'h',

INST = b'i',

LONG_BINGET = b'j',

LIST = b'l',

EMPTY_LIST = b']',

OBJ = b'o',

PUT = b'p',

BINPUT = b'q',

LONG_BINPUT = b'r',

SETITEM = b's',

TUPLE = b't',

EMPTY_TUPLE = b')',

SETITEMS = b'u',

BINFLOAT = b'G',

PROTO = 0x80,

NEWOBJ = 0x81,

EXT1 = 0x82,

EXT2 = 0x83,

EXT4 = 0x84,

TUPLE1 = 0x85,

TUPLE2 = 0x86,

TUPLE3 = 0x87,

NEWTRUE = 0x88,

NEWFALSE = 0x89,

LONG1 = 0x8a,

LONG4 = 0x8b,

BINBYTES = b'B',

SHORT_BINBYTES = b'C',

SHORT_BINUNICODE = 0x8c,

BINUNICODE8 = 0x8d,

BINBYTES8 = 0x8e,

EMPTY_SET = 0x8f,

ADDITEMS = 0x90,

FROZENSET = 0x91,

NEWOBJ_EX = 0x92,

STACK_GLOBAL = 0x93,

MEMOIZE = 0x94,

FRAME = 0x95,

BYTEARRAY8 = 0x96,

NEXT_BUFFER = 0x97,

READONLY_BUFFER = 0x98,

}

#[allow(clippy::enum_glob_use)]

use Opcode::*;

/// Amount of data `peek()` grabs at a time from a file-like input.

const PREFETCH: usize = 8192;

// Grow reads geometrically from this bound, rather than trusting a length

// advertised by a potentially truncated pickle.

const MIN_READ_BUF_SIZE: usize = 1 << 20;

// input handling

#[derive(Debug, Default)]

pub(super) struct ReadState {

read: Option<PyObjectRef>,

readinto: Option<PyObjectRef>,

readline: Option<PyObjectRef>,

peek: Option<PyObjectRef>,

/// Bytes currently available to the opcode loop.

buf: Vec<u8>,

/// Index of the next unread byte in `buf`.

pos: usize,

/// Index up to which the underlying file position has been advanced.

/// Anything past it was obtained with `peek()` and is not consumed yet.

prefetched: usize,

/// End of the current FRAME, if any.

frame_end: Option<usize>,

}

// SAFETY: these are all the Python references owned by the input state.

unsafe impl Traverse for ReadState {

fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {

self.read.traverse(traverse_fn);

self.readinto.traverse(traverse_fn);

self.readline.traverse(traverse_fn);

self.peek.traverse(traverse_fn);

}

}

fn to_byte_vec(obj: &PyObject, what: &str, vm: &VirtualMachine) -> PyResult<Vec<u8>> {

let bytes = obj

.downcast_ref::<PyBytes>()

.ok_or_else(|| {

vm.new_type_error(format!(

"{what}() from the underlying stream did not return bytes"

))

})?

.as_bytes();

let mut data = Vec::new();

data.try_reserve_exact(bytes.len())

.map_err(|_| vm.no_memory_error())?;

data.extend_from_slice(bytes);

Ok(data)

}

fn truncated(vm: &VirtualMachine) -> PyBaseExceptionRef {

new_unpickling_error(vm, "pickle data was truncated")

}

impl ReadState {

fn set_file(&mut self, file: &PyObject, vm: &VirtualMachine) -> PyResult<()> {

self.peek = vm.get_attribute_opt(file, "peek")?;

self.readinto = vm.get_attribute_opt(file, "readinto")?;

self.read = vm.get_attribute_opt(file, "read")?;

self.readline = vm.get_attribute_opt(file, "readline")?;

if self.read.is_none() || self.readline.is_none() {

return Err(vm.new_type_error("file must have 'read' and 'readline' attributes"));

}

Ok(())

}

fn set_input(&mut self, data: Vec<u8>, consumed: bool) {

self.prefetched = if consumed { data.len() } else { 0 };

self.buf = data;

self.pos = 0;

}

/// Advance the real file position past bytes we only peeked at.

fn skip_consumed(&mut self, vm: &VirtualMachine) -> PyResult<()> {

if self.read.is_none() || self.pos <= self.prefetched {

return Ok(());

}

let consumed = self.pos - self.prefetched;

let read = self.read.clone().expect("file input");

read.call((consumed,), vm)?;

self.prefetched = self.pos;

Ok(())

}

/// Refill `buf` with at least `n` bytes from the file if possible.

/// Returns the number of bytes made available starting at index 0.

fn fill_from_file(&mut self, n: usize, vm: &VirtualMachine) -> PyResult<usize> {

self.skip_consumed(vm)?;

self.frame_end = None;

if n < PREFETCH

&& let Some(peek) = self.peek.clone()

{

match peek.call((PREFETCH,), vm) {

Ok(data) => {

let data = to_byte_vec(&data, "peek", vm)?;

let len = data.len();

self.set_input(data, false);

if n <= len {

return Ok(len);

}

}

Err(_) => {

// The stream does not really support peek(); stop trying.

self.peek = None;

}

}

}

let read = self.read.clone().expect("file input");

let mut chunk_size = n.min(MIN_READ_BUF_SIZE);

let data = read.call((chunk_size,), vm)?;

let mut data = to_byte_vec(&data, "read", vm)?;

let mut received = data.len();

while received == chunk_size && data.len() < n {

chunk_size = data.len().min(n - data.len());

let chunk = read.call((chunk_size,), vm)?;

let chunk = to_byte_vec(&chunk, "read", vm)?;

received = chunk.len();

data.try_reserve(received)

.map_err(|_| vm.no_memory_error())?;

data.extend_from_slice(&chunk);

}

let len = data.len();

self.set_input(data, true);

Ok(len)

}

/// Drop an exhausted frame, or reject a read that would cross its end.

fn check_frame(&mut self, n: usize, vm: &VirtualMachine) -> PyResult<()> {

if let Some(end) = self.frame_end {

if self.pos >= end {

self.frame_end = None;

} else if n > end - self.pos {

return Err(new_unpickling_error(

vm,

"pickle exhausted before end of frame",

));

}

}

Ok(())

}

fn read_n(&mut self, n: usize, vm: &VirtualMachine) -> PyResult<&[u8]> {

self.check_frame(n, vm)?;

if n <= self.buf.len() - self.pos {

let start = self.pos;

self.pos += n;

return Ok(&self.buf[start..start + n]);

}

if self.read.is_none() {

return Err(truncated(vm));

}

if self.fill_from_file(n, vm)? < n {

return Err(truncated(vm));

}

self.pos = n;

Ok(&self.buf[..n])

}

/// Read up to and including the next newline.

fn read_line(&mut self, vm: &VirtualMachine) -> PyResult<&[u8]> {

if let Some(end) = self.frame_end

&& self.pos >= end

{

self.frame_end = None;

}

let limit = self.frame_end.unwrap_or(self.buf.len());

if let Some(idx) = memchr::memchr(b'\n', &self.buf[self.pos..limit]) {

let start = self.pos;

self.pos = start + idx + 1;

return Ok(&self.buf[start..self.pos]);

}

if self.frame_end.is_some() {

return Err(new_unpickling_error(

vm,

"pickle exhausted before end of frame",

));

}

if self.read.is_none() {

return Err(truncated(vm));

}

self.skip_consumed(vm)?;

let readline = self.readline.clone().expect("file input");

let data = readline.call((), vm)?;

let data = to_byte_vec(&data, "readline", vm)?;

let len = data.len();

self.set_input(data, true);

if len == 0 || self.buf[len - 1] != b'\n' {

return Err(truncated(vm));

}

self.pos = len;

Ok(&self.buf[..len])

}

fn load_frame(&mut self, size: usize, vm: &VirtualMachine) -> PyResult<()> {

if let Some(end) = self.frame_end {

if self.pos < end {

return Err(new_unpickling_error(

vm,

"beginning of a new frame before end of current frame",

));

}

self.frame_end = None;

}

self.read_n(size, vm)?;

self.pos -= size;

self.frame_end = Some(self.pos + size);

Ok(())

}

}

// memo proxies

#[pyattr]

#[pyclass(module = "_pickle", name = "UnpicklerMemoProxy", traverse)]

#[derive(Debug, PyPayload)]

struct UnpicklerMemoProxy {

unpickler: PyRef<PyUnpickler>,

}

#[pyclass(flags(DISALLOW_INSTANTIATION))]

impl UnpicklerMemoProxy {

#[pymethod]

fn clear(zelf: &Py<Self>) {

let old_memo = core::mem::take(&mut *zelf.unpickler.memo.write());

drop(old_memo);

}

#[pymethod]

fn copy(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {

let mut snapshot = Vec::new();

let copied = {

let memo = zelf.unpickler.memo.read();

snapshot.try_reserve_exact(memo.len()).map(|()| {

snapshot.extend(memo.iter().map(|(&index, obj)| (index, obj.clone())));

})

};

copied.map_err(|_| vm.no_memory_error())?;

// CPython inserts present memo indices in ascending order.

snapshot.sort_unstable_by_key(|(index, _)| *index);

let dict = vm.ctx.new_dict();

for (i, obj) in snapshot {

let key: PyObjectRef = vm.ctx.new_int(i).into();

dict.set_item(&*key, obj, vm)?;

}

Ok(dict.into())

}

#[pymethod]

fn __reduce__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {

let contents = Self::copy(zelf, vm)?;

Ok(vm

.ctx

.new_tuple(vec![

vm.ctx.types.dict_type.to_owned().into(),

vm.ctx.new_tuple(vec![]).into(),

vm.ctx.none(),

vm.ctx.none(),

vm.call_method(&contents, "items", ())?,

])

.into())

}

}

// Unpickler

// PUT indices need not be contiguous. A sparse table also keeps MEMOIZE's

// index equal to the number of entries rather than the largest index.

type UnpicklerMemo = HashMap<usize, PyObjectRef>;

#[derive(Debug)]

pub(super) struct UnpicklerConfig {

initialized: bool,

proto: u8,

fix_imports: bool,

encoding: String,

errors: String,

buffers: Option<PyObjectRef>,

}

// SAFETY: buffers is the only Python reference owned by the configuration.

unsafe impl Traverse for UnpicklerConfig {

fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {

self.buffers.traverse(traverse_fn);

}

}

impl Default for UnpicklerConfig {

fn default() -> Self {

Self {

initialized: false,

proto: 0,

fix_imports: true,

encoding: "ASCII".to_owned(),

errors: "strict".to_owned(),

buffers: None,

}

}

}

#[pyattr]

#[pyclass(module = "_pickle", name = "Unpickler", traverse = "manual")]

#[derive(Debug, PyPayload)]

pub(super) struct PyUnpickler {

read_state: PyMutex<ReadState>,

memo: PyRwLock<UnpicklerMemo>,

config: PyRwLock<UnpicklerConfig>,

}

// SAFETY: visit each owned reference once, including sparse memo entries.

unsafe impl Traverse for PyUnpickler {

fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {

self.read_state.traverse(traverse_fn);

self.config.traverse(traverse_fn);

if let Some(memo) = self.memo.try_read_recursive() {

#[expect(

for value in memo.values() {

value.traverse(traverse_fn);

}

}

}

fn clear(&mut self, out: &mut Vec<PyObjectRef>) {

let state = self.read_state.get_mut();

out.extend(state.read.take());

out.extend(state.readinto.take());

out.extend(state.readline.take());

out.extend(state.peek.take());

out.extend(self.memo.get_mut().drain().map(|(_, value)| value));

let config = self.config.get_mut();

out.extend(config.buffers.take());

config.initialized = false;

}

}

fn pickle_string(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {

let value = PyUtf8StrRef::try_from_object(vm, obj.clone())?;

value.to_cstring(vm)?;

Ok(value.as_str().to_owned())

}

// Bind the whole call before converting options: Clinic rejects unknown

// keywords before invoking __bool__. Raw arguments also keep subclasses

// alive until all stream and buffer callbacks have finished.

#[derive(FromArgs)]

struct UnpicklerOptions {

#[pyarg(named, default = true)]

fix_imports: PyObjectRef,

#[pyarg(named, default = "ASCII")]

encoding: PyObjectRef,

#[pyarg(named, default = "strict")]

errors: PyObjectRef,

// Missing or None means no buffers.

#[pyarg(named, optional, py_default = "()")]

buffers: OptionalArg<PyObjectRef>,

}

impl UnpicklerOptions {

fn config(&self, vm: &VirtualMachine) -> PyResult<UnpicklerConfig> {

Ok(UnpicklerConfig {

initialized: true,

proto: 0,

fix_imports: ArgIntoBool::try_from_object(vm, self.fix_imports.clone())?

.into_bool(),

encoding: pickle_string(&self.encoding, vm)?,

errors: pickle_string(&self.errors, vm)?,

buffers: None,

})

}

// Unlike the Clinic converters above, iter(buffers) belongs after

// file/data setup and inside an initializer's recursion guard.

fn buffers(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {

match &self.buffers {

OptionalArg::Present(obj) if !vm.is_none(obj) => {

Ok(Some(PyIter::try_from_object(vm, obj.clone())?.into()))

}

_ => Ok(None),

}

}

}

#[derive(FromArgs)]

pub(super) struct UnpicklerNewArgs {

#[pyarg(any)]

file: PyObjectRef,

#[pyarg(flatten)]

options: UnpicklerOptions,

}

impl Constructor for PyUnpickler {

type Args = FuncArgs;

fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {

Ok(Self {

read_state: PyMutex::new(ReadState::default()),

memo: PyRwLock::new(UnpicklerMemo::new()),

config: PyRwLock::new(UnpicklerConfig::default()),

})

}

}

impl Initializer for PyUnpickler {

type Args = UnpicklerNewArgs;

fn init(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {

let mut config = args.options.config(vm)?;

// On setup failure, the guard must go before staged references:

// dropping a file method or iterator can run a Python finalizer.

let mut new_state = ReadState::default();

let Some(mut state) = zelf.read_state.try_lock() else {

return Err(vm.new_runtime_error("Unpickler.__init__() called recursively"));

};

new_state.set_file(&args.file, vm)?;

config.buffers = args.options.buffers(vm)?;

let old_state = core::mem::replace(&mut *state, new_state);

let old_memo = core::mem::take(&mut *zelf.memo.write());

let old_config = core::mem::replace(&mut *zelf.config.write(), config);

drop(state);

drop((old_state, old_memo, old_config));

Ok(())

}

}

#[pyclass(with(Constructor, Initializer), flags(BASETYPE, HAS_DICT))]

impl PyUnpickler {

#[pymethod]

fn load(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {

load_impl(zelf, vm)

}

// The default hook: no persistent ids are supported.

#[pymethod]

fn persistent_load(

_zelf: &Py<Self>,

_pid: PyObjectRef,

vm: &VirtualMachine,

) -> PyResult<()> {

Err(new_unpickling_error(

vm,

"A load persistent id instruction was encountered, but no persistent_load function was specified.",

))

}

#[pymethod]

fn find_class(

zelf: &Py<Self>,

module_name: PyObjectRef,

global_name: PyObjectRef,

vm: &VirtualMachine,

) -> PyResult<PyObjectRef> {

find_class_impl(zelf, module_name, global_name, vm)

}

#[pygetset]

fn memo(zelf: PyRef<Self>, _vm: &VirtualMachine) -> UnpicklerMemoProxy {

UnpicklerMemoProxy { unpickler: zelf }

}

#[pygetset(setter)]

fn set_memo(zelf: &Py<Self>, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {

let value = match value {

PySetterValue::Assign(v) => v,

PySetterValue::Delete => {

return Err(vm.new_type_error("attribute deletion is not supported"));

}

};

let new_memo = if let Some(proxy) = value.downcast_ref::<UnpicklerMemoProxy>() {

let snapshot = copy_memo(&proxy.unpickler.memo.read());

snapshot.map_err(|_| vm.no_memory_error())?

} else if let Some(dict) = value.downcast_ref::<PyDict>() {

let mut memo = UnpicklerMemo::new();

memo.try_reserve(dict.__len__())

.map_err(|_| vm.no_memory_error())?;

for (key, val) in dict {

let idx = key

.downcast_ref::<PyInt>()

.ok_or_else(|| vm.new_type_error("memo key must be integers"))?;

let idx = idx.try_to_primitive::<isize>(vm)?;

if idx < 0 {

return Err(vm.new_value_error("memo key must be positive integers."));

}

memo_insert(&mut memo, idx as usize, &val).map_err(|_| vm.no_memory_error())?;

}

memo

} else {

return Err(vm.new_type_error(format!(

"'memo' attribute must be an UnpicklerMemoProxy object or dict, not {}",

value.class().name()

)));

};

let old_memo = core::mem::replace(&mut *zelf.memo.write(), new_memo);

drop(old_memo);

Ok(())

}

}

fn mapping_get(

obj: &PyObject,

key: &PyObject,

vm: &VirtualMachine,

) -> PyResult<Option<PyObjectRef>> {

if let Some(dict) = obj.downcast_ref::<PyDict>() {

return dict.get_item_opt(key, vm);

}

match obj.get_item(key, vm) {

Ok(v) => Ok(Some(v)),

Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => Ok(None),

Err(e) => Err(e),

}

}

fn find_class_impl(

zelf: &Py<PyUnpickler>,

module: PyObjectRef,

name: PyObjectRef,

vm: &VirtualMachine,

) -> PyResult<PyObjectRef> {

let (proto, fix_imports) = {

let cfg = zelf.config.read();

(cfg.proto, cfg.fix_imports)

};

vm.audit("pickle.find_class", || (module.clone(), name.clone()))?;

let mut module = module

.downcast::<PyStr>()

.map_err(|_| vm.new_type_error("module name must be a string"))?;

let mut name = name

.downcast::<PyStr>()

.map_err(|_| vm.new_type_error("global name must be a string"))?;

if proto < 3 && fix_imports {

let compat = vm.import("_compat_pickle", 0)?;

let name_mapping = compat.get_attr("NAME_MAPPING", vm)?;

let key = vm

.ctx

.new_tuple(vec![module.clone().into(), name.clone().into()]);

if let Some(mapped) = mapping_get(&name_mapping, key.as_object(), vm)? {

let mapped: PyTupleRef = mapped.downcast().map_err(|_| {