@@ -51,6 +51,7 @@ dllhandle
 docstring
 docstrings
 dunder
+dunders
 endianness
 endpos
 eventmask
 
@@ -9,22 +9,31 @@
 //! Exceptions that C code cannot propagate are reported through the embedded
 //! interpreter's `sys.unraisablehook`. When this thread is running RustPython,
 //! that hook is handed to RustPython's `sys.unraisablehook`.
+//!
+//! Warnings go the same way. The embedded `warnings.showwarning` is handed to
+//! this interpreter's `warnings.showwarning` while a RustPython thread is
+//! running, so a recorder installed here observes them. The embedded filters
+//! still decide whether `showwarning` is called. If the function here raises,
+//! that exception propagates to the embedded caller. With no RustPython thread,
+//! or if delivery is already in progress, the embedded function runs.
 
+use core::cell::Cell;
 use core::ffi::CStr;
-use std::sync::Once;
+use std::sync::{Once, OnceLock};
 
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
-use pyo3::types::{PyAnyMethods, PyCFunction, PyDict, PyTuple};
+use pyo3::types::{PyAnyMethods, PyCFunction, PyDict, PyTuple, PyType as CPythonType};
 use rustpython_vm::{
     AsObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    builtins::{PyTuple as RustPyTuple, PyType},
+    builtins::{PyStr, PyTuple as RustPyTuple, PyType},
+    function::{FuncArgs, KwArgs},
     types::{AtomicPyTypeFlags, PyTypeFlags, PyTypeSlots},
 };
 
 use crate::_pyo3::module_state;
 use crate::convert::to_rustpython;
-use crate::errors::cpython_exc_to_rustpython;
+use crate::errors::{cpython_exc_to_rustpython, matching_builtin_type, rustpython_exc_to_cpython};
 use crate::gil::run_rustpython;
 
 /// Initialize CPython on first use and install the unraisable forwarder.
@@ -37,6 +46,7 @@ pub(crate) fn ensure_cpython_initialized() {
     static INIT: Once = Once::new();
     INIT.call_once(initialize_cpython);
     install_unraisable_hook();
+    install_warning_hook();
 }
 
 fn initialize_cpython() {
@@ -91,6 +101,138 @@ fn set_unraisable_hook(py: Python<'_>) -> pyo3::PyResult<()> {
     py.import("sys")?.setattr("unraisablehook", hook)
 }
 
+static ORIGINAL_SHOWWARNING: OnceLock<Py<PyAny>> = OnceLock::new();
+
+std::thread_local! {
+    static IN_SHOWWARNING: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Set while a warning is being delivered, so a nested report uses the
+/// embedded function instead of calling back into the same delivery.
+struct ShowwarningGuard;
+
+impl ShowwarningGuard {
+    fn enter() -> Option<Self> {
+        IN_SHOWWARNING.with(|flag| {
+            if flag.get() {
+                None
+            } else {
+                flag.set(true);
+                Some(Self)
+            }
+        })
+    }
+}
+
+impl Drop for ShowwarningGuard {
+    fn drop(&mut self) {
+        IN_SHOWWARNING.with(|flag| flag.set(false));
+    }
+}
+
+fn install_warning_hook() {
+    static HOOK: Once = Once::new();
+    HOOK.call_once(|| {
+        Python::attach(|py| {
+            if let Err(err) = set_warning_hook(py) {
+                panic!("failed to install the embedded warning hook: {err}");
+            }
+        });
+    });
+}
+
+fn set_warning_hook(py: Python<'_>) -> pyo3::PyResult<()> {
+    let warnings = py.import("warnings")?;
+    let original = warnings.getattr("showwarning")?;
+    let _ = ORIGINAL_SHOWWARNING.set(original.unbind());
+    let hook = PyCFunction::new_closure(py, Some(c"showwarning"), None, showwarning_hook)?;
+    warnings.setattr("showwarning", hook)
+}
+
+fn showwarning_hook(
+    args: &Bound<'_, PyTuple>,
+    kwargs: Option<&Bound<'_, PyDict>>,
+) -> pyo3::PyResult<()> {
+    let Some(_guard) = ShowwarningGuard::enter() else {
+        return call_original_showwarning(args, kwargs);
+    };
+    let py = args.py();
+    let forwarded = rustpython_vm::vm::thread::try_with_current_vm(|vm| {
+        vm.attach_for_callback(|| forward_showwarning(py, args, kwargs, vm))
+    });
+    match forwarded {
+        Some(result) => result,
+        None => call_original_showwarning(args, kwargs),
+    }
+}
+
+fn forward_showwarning(
+    py: Python<'_>,
+    args: &Bound<'_, PyTuple>,
+    kwargs: Option<&Bound<'_, PyDict>>,
+    vm: &VirtualMachine,
+) -> pyo3::PyResult<()> {
+    let call_args =
+        showwarning_args(args, kwargs, vm).map_err(|err| rustpython_exc_to_cpython(py, err, vm))?;
+    run_rustpython(py, || {
+        let warnings = vm.import("warnings", 0)?;
+        let show = warnings.get_attr("showwarning", vm)?;
+        show.call(call_args, vm)?;
+        Ok(())
+    })
+    .map_err(|err| rustpython_exc_to_cpython(py, err, vm))
+}
+
+fn showwarning_args(
+    args: &Bound<'_, PyTuple>,
+    kwargs: Option<&Bound<'_, PyDict>>,
+    vm: &VirtualMachine,
+) -> PyResult<FuncArgs> {
+    let positional = args
+        .iter()
+        .enumerate()
+        .map(|(index, arg)| showwarning_value(index == 1, &arg, vm))
+        .collect::<PyResult<Vec<_>>>()?;
+    let kwargs = kwargs
+        .into_iter()
+        .flatten()
+        .map(|(key, value)| {
+            let key = to_rustpython(&key, vm)?;
+            let key = key
+                .downcast_ref::<PyStr>()
+                .ok_or_else(|| vm.new_type_error("keywords must be strings"))?;
+            let is_category = key.to_str() == Some("category");
+            let value = showwarning_value(is_category, &value, vm)?;
+            Ok((key.as_wtf8().to_owned(), value))
+        })
+        .collect::<PyResult<KwArgs>>()?;
+    Ok(FuncArgs::new(positional, kwargs))
+}
+
+/// `category` is a warning class. Hand this interpreter's class across so a
+/// filter or recorder here sees the class it already imported.
+fn showwarning_value(category: bool, value: &Bound<'_, PyAny>, vm: &VirtualMachine) -> PyResult {
+    if category
+        && let Ok(ty) = value.cast::<CPythonType>()
+        && let Some(mapped) = matching_builtin_type(ty, vm)
+        && mapped.fast_issubclass(vm.ctx.exceptions.warning)
+    {
+        return Ok(mapped.into());
+    }
+    to_rustpython(value, vm)
+}
+
+fn call_original_showwarning(
+    args: &Bound<'_, PyTuple>,
+    kwargs: Option<&Bound<'_, PyDict>>,
+) -> pyo3::PyResult<()> {
+    let Some(original) = ORIGINAL_SHOWWARNING.get() else {
+        return Ok(());
+    };
+    original.bind(args.py()).call(args, kwargs)?;
+    Ok(())
+}
+
 /// What happened to one unraisable exception.
 enum Forwarded {
     /// RustPython's hook ran and returned.
 
@@ -176,6 +176,20 @@ pub(crate) fn rustpython_exc_to_cpython(
     PyErr::from_value(instance)
 }
 
+/// The built-in class on this side that corresponds to `ty`, when `ty`'s
+/// MRO contains a class defined in `builtins`.
+pub(crate) fn matching_builtin_type(
+    ty: &Bound<'_, CPythonType>,
+    vm: &VirtualMachine,
+) -> Option<rustpython_vm::PyRef<PyType>> {
+    let (name, _) = cpython_mro_builtin(ty)?;
+    vm.builtins
+        .get_attr(&vm.ctx.new_str(name.as_str()), vm)
+        .ok()?
+        .downcast::<PyType>()
+        .ok()
+}
+
 /// The first class in `ty.__mro__` defined in `builtins`, and whether that is
 /// `ty` itself.
 fn cpython_mro_builtin(ty: &Bound<'_, CPythonType>) -> Option<(String, bool)> {
 
@@ -16,10 +16,26 @@
 //! slots come from the methods the class actually defines. Classes that
 //! cannot be laid out that way stay generic proxies, and `proxy.__class__`
 //! is still the wrapped class. A wrapper's metaclass is the wrapper of the
-//! CPython metaclass, or `pyo3.pyo3_type` when that metaclass is `type`.
+//! CPython metaclass. When that metaclass is `type`, the class is itself a
+//! metaclass, and the class is immutable, the wrapper's metaclass is `type`
+//! too and the immutable-type flag is copied from the wrapped class. A
+//! mutable metaclass keeps `pyo3.pyo3_type`, so reads and writes on the
+//! wrapper reach the wrapped class. Every other class whose metaclass is
+//! `type` uses `pyo3.pyo3_type`.
 //! See [`convert`] for what crosses by value and what by reference,
 //! [`pyo3_type`] for classes, and [`errors`] for exceptions.
 //!
+//! `copy.copy` and `copy.deepcopy` of an embedded object call the embedded
+//! `copy` module. `pickle` stores `pyo3.load_embedded` and the bytes the
+//! embedded `pickle` produced; loading unpickles there and converts the
+//! result back. See [`pyo3_ref`].
+//!
+//! A RustPython object handed across publishes the non-slot dunder methods
+//! its class defines. The first definition in the MRO wins, and a name only
+//! `object` defines stays unpublished. Its sequence length is its `__len__`.
+//! See [`rustpython_object`]. Embedded `warnings.showwarning` is delivered to
+//! this interpreter while a thread is running it. See [`cpython_init`].
+//!
 //! `pyo3.wraps` instead runs a whole function in CPython:
 //!
 //! ```python
@@ -95,6 +111,9 @@ mod _pyo3 {
         types: PyMutex<HashMap<usize, (pyo3::Py<pyo3::PyAny>, PyTypeRef)>>,
         /// Tuple subclass passed to `sys.unraisablehook`. One per interpreter.
         unraisable_args: PyMutex<Option<PyTypeRef>>,
+        /// `mro` of metaclass wrappers whose own metaclass is `type`.
+        /// One descriptor, shared; it binds the class it is read from.
+        published_mro_method: PyMutex<Option<PyObjectRef>>,
     }
 
     #[pyclass(flags(DISALLOW_INSTANTIATION))]
@@ -139,6 +158,20 @@ mod _pyo3 {
             *slot = Some(ty.clone());
             ty
         }
+
+        pub(crate) fn cached_published_mro_method(&self) -> Option<PyObjectRef> {
+            self.published_mro_method.lock().clone()
+        }
+
+        /// Remember `method` unless another thread stored one first.
+        pub(crate) fn store_published_mro_method(&self, method: PyObjectRef) -> PyObjectRef {
+            let mut slot = self.published_mro_method.lock();
+            if let Some(existing) = slot.clone() {
+                return existing;
+            }
+            *slot = Some(method.clone());
+            method
+        }
     }
 
     pub(crate) fn module_state(vm: &VirtualMachine) -> PyResult<PyRef<Pyo3State>> {
@@ -167,6 +200,22 @@ mod _pyo3 {
         import_module_impl(name.as_str(), vm)
     }
 
+    /// Unpickle `data` with the embedded interpreter's `pickle` and convert the result.
+    ///
+    /// Embedded objects reduce to this function plus the bytes that
+    /// interpreter's `pickle.dumps` produced. Protocol 5 buffers are included
+    /// in those bytes. The failure of an object that cannot be pickled is the
+    /// embedded failure, converted.
+    #[pyfunction]
+    fn load_embedded(data: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        with_gil(vm, |py| {
+            let pickle = run_cpython(vm, || py.import("pickle"))?;
+            let data = to_cpython(py, &data, vm)?;
+            let result = run_cpython(vm, || pickle.call_method1("loads", (data,)))?;
+            to_rustpython(&result, vm)
+        })
+    }
+
     pub(crate) fn import_module_impl(name: &str, vm: &VirtualMachine) -> PyResult {
         with_gil(vm, |py| {
             let module = run_cpython(vm, || py.import(name))?;