Struct ContextWatcherGuard 

pub struct ContextWatcherGuard { /* private fields */ }

An unbound guard which keeps a context watcher registered.

Unlike BoundContextWatcherGuard, this guard is not tied to a particular Python attachment, so it can be stored outside that attachment or sent to another thread.

Dropping this guard automatically attaches to Python to remove the watcher. Use clear to remove it with an existing attachment and observe any error returned by CPython, or into_bound to recover a bound guard.

If Python cannot be attached during drop, the watcher remains registered. This does not create a dangling function pointer because watch_callback! creates a static, monomorphized trampoline.

Example

use pyo3::prelude::*;
use pyo3::types::context::{watch_callback, ContextEvent};
use pyo3::types::PyContext;

fn context_changed(
    _py: Python<'_>,
    _event: ContextEvent<'_, '_>,
) -> PyResult<()> {
    Ok(())
}

let watcher = Python::attach(|py| -> PyResult<_> {
    Ok(PyContext::add_watcher(py, watch_callback!(context_changed))?.unbind())
})?;

// The guard can be stored until an attachment is available for explicit cleanup.
Python::attach(|py| watcher.clear(py))

Implementations

impl ContextWatcherGuard

pub fn clear(self, py: Python<'_>) -> PyResult<()>

Removes this watcher from the current Python interpreter.

Dropping the guard also removes the watcher, but cannot report a failure to the caller.

pub fn into_bound<'py>(self, py: Python<'py>) -> BoundContextWatcherGuard<'py>

Connects this guard to the given Python attachment.

PyO3 does not currently support using a module from multiple interpreters, so py is the attachment for the interpreter in which this watcher was registered.

Trait Implementations

impl Drop for ContextWatcherGuard

Available on Py_3_14 and non-Py_GIL_DISABLED only.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.