Struct pyo3::PyErr

pub struct PyErr { /* private fields */ }

Represents a Python exception.

Python exceptions can be raised in a “lazy” fashion, where the full Python object for the exception is not created until needed. The process of creating the full object is known as “normalization”. An exception which has not yet been created is known as “unnormalized”.

This struct builds upon that design, supporting all lazily-created Python exceptions and also supporting exceptions lazily-created from Rust.

Implementations

impl PyErr

pub fn new<T, A>(args: A) -> PyErr where
    T: PyTypeObject,
    A: PyErrArguments + Send + Sync + 'static, 

Creates a new PyErr of type T.

args can be:

• a tuple: the exception instance will be created using the equivalent to the Python expression T(*tuple)
• any other value: the exception instance will be created using the equivalent to the Python expression T(value)

This error will be stored in an unnormalized state. This avoids the need for the Python GIL to be held, but requires args to be Send and Sync. If args is not Send or Sync, consider using PyErr::from_value instead.

If an error occurs during normalization (for example if T is not a Python type which extends from BaseException), then a different error may be produced during normalization.

Example

return Err(PyErr::new::<exceptions::PyTypeError, _>("Error message"));

In most cases, you can use a concrete exception’s constructor instead, which is equivalent:

return Err(exceptions::PyTypeError::new_err("Error message"));

pub fn from_type<A>(ty: &PyType, args: A) -> PyErr where
    A: PyErrArguments + Send + Sync + 'static, 

Constructs a new PyErr from the given Python type and arguments.

ty is the exception type; usually one of the standard exceptions like exceptions::PyRuntimeError.

args is either a tuple or a single value, with the same meaning as in PyErr::new.

If an error occurs during normalization (for example if T is not a Python type which extends from BaseException), then a different error may be produced during normalization.

This error will be stored in an unnormalized state.

pub fn from_value(obj: &PyAny) -> PyErr

Creates a new PyErr.

If obj is a Python exception object, the PyErr will contain that object. The error will be in a normalized state.

If obj is a Python exception type object, this is equivalent to PyErr::from_type(obj, ()).

Otherwise, a TypeError is created.

Examples

use pyo3::{exceptions::PyTypeError, types::PyType, IntoPy, PyErr, Python};
Python::with_gil(|py| {
    // Case #1: Exception object
    let err = PyErr::from_value(PyTypeError::new_err("some type error").value(py));
    assert_eq!(err.to_string(), "TypeError: some type error");

    // Case #2: Exception type
    let err = PyErr::from_value(PyType::new::<PyTypeError>(py));
    assert_eq!(err.to_string(), "TypeError: ");

    // Case #3: Invalid exception value
    let err = PyErr::from_value("foo".into_py(py).as_ref(py));
    assert_eq!(
        err.to_string(),
        "TypeError: exceptions must derive from BaseException"
    );
});

pub fn get_type<'py>(&'py self, py: Python<'py>) -> &'py PyType

Returns the type of this exception.

The object will be normalized first if needed.

Examples

use pyo3::{exceptions::PyTypeError, types::PyType, PyErr, Python};

Python::with_gil(|py| {
    let err: PyErr = PyTypeError::new_err(("some type error",));
    assert!(err.get_type(py).is(PyType::new::<PyTypeError>(py)));
});

pub fn value<'py>(&'py self, py: Python<'py>) -> &'py PyBaseException

Returns the value of this exception.

The object will be normalized first if needed.

Examples

use pyo3::{exceptions::PyTypeError, PyErr, Python};

Python::with_gil(|py| {
    let err: PyErr = PyTypeError::new_err(("some type error",));
    assert!(err.is_instance_of::<PyTypeError>(py));
    assert_eq!(err.value(py).to_string(), "some type error");
});

pub fn into_value(self, py: Python<'_>) -> Py<PyBaseException>

Consumes self to take ownership of the exception value contained in this error.

pub fn traceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback>

Returns the traceback of this exception object.

The object will be normalized first if needed.

Examples

use pyo3::{exceptions::PyTypeError, Python};

Python::with_gil(|py| {
    let err = PyTypeError::new_err(("some type error",));
    assert!(err.traceback(py).is_none());
});

pub fn occurred(_: Python<'_>) -> bool

Gets whether an error is present in the Python interpreter’s global state.

pub fn take(py: Python<'_>) -> Option<PyErr>

Takes the current error from the Python interpreter’s global state and clears the global state. If no error is set, returns None.

If the error is a PanicException (which would have originated from a panic in a pyo3 callback) then this function will resume the panic.

Use this function when it is not known if an error should be present. If the error is expected to have been set, for example from PyErr::occurred or by an error return value from a C FFI function, use PyErr::fetch.

pub fn fetch(py: Python<'_>) -> PyErr

Equivalent to PyErr::take, but when no error is set:

• Panics in debug mode.
• Returns a SystemError in release mode.

This behavior is consistent with Python’s internal handling of what happens when a C return value indicates an error occurred but the global error state is empty. (A lack of exception should be treated as a bug in the code which returned an error code but did not set an exception.)

Use this function when the error is expected to have been set, for example from PyErr::occurred or by an error return value from a C FFI function.

pub fn new_type(
    py: Python<'_>,
    name: &str,
    doc: Option<&str>,
    base: Option<&PyType>,
    dict: Option<PyObject>
) -> PyResult<Py<PyType>>

Creates a new exception type with the given name and docstring.

• base can be an existing exception type to subclass, or a tuple of classes.
• dict specifies an optional dictionary of class variables and methods.
• doc will be the docstring seen by python users.

Errors

This function returns an error if name is not of the form <module>.<ExceptionName>.

Panics

This function will panic if name or doc cannot be converted to CStrings.

pub fn print(&self, py: Python<'_>)

Prints a standard traceback to sys.stderr.

pub fn print_and_set_sys_last_vars(&self, py: Python<'_>)

Prints a standard traceback to sys.stderr, and sets sys.last_{type,value,traceback} attributes to this exception’s data.

pub fn matches<T>(&self, py: Python<'_>, exc: T) -> bool where
    T: ToBorrowedObject, 

Returns true if the current exception matches the exception in exc.

If exc is a class object, this also returns true when self is an instance of a subclass. If exc is a tuple, all exceptions in the tuple (and recursively in subtuples) are searched for a match.

pub fn is_instance(&self, py: Python<'_>, typ: &PyType) -> bool

Returns true if the current exception is instance of T.

pub fn is_instance_of<T>(&self, py: Python<'_>) -> bool where
    T: PyTypeObject, 

Returns true if the current exception is instance of T.

pub fn restore(self, py: Python<'_>)

Writes the error back to the Python interpreter’s global state. This is the opposite of PyErr::fetch().

pub fn warn(
    py: Python<'_>,
    category: &PyAny,
    message: &str,
    stacklevel: i32
) -> PyResult<()>

Issues a warning message. May return a PyErr if warnings-as-errors is enabled.

pub fn clone_ref(&self, py: Python<'_>) -> PyErr

Clone the PyErr. This requires the GIL, which is why PyErr does not implement Clone.

Examples

use pyo3::{exceptions::PyTypeError, PyErr, Python};
Python::with_gil(|py| {
    let err: PyErr = PyTypeError::new_err(("some type error",));
    let err_clone = err.clone_ref(py);
    assert!(err.get_type(py).is(err_clone.get_type(py)));
    assert!(err.value(py).is(err_clone.value(py)));
    match err.traceback(py) {
        None => assert!(err_clone.traceback(py).is_none()),
        Some(tb) => assert!(err_clone.traceback(py).unwrap().is(tb)),
    }
});

pub fn cause(&self, py: Python<'_>) -> Option<PyErr>

Return the cause (either an exception instance, or None, set by raise ... from ...) associated with the exception, as accessible from Python through __cause__.

pub fn set_cause(&self, py: Python<'_>, cause: Option<Self>)

Set the cause associated with the exception, pass None to clear it.

pub fn ptype<'py>(&'py self, py: Python<'py>) -> &'py PyType

👎 Deprecated since 0.16.0:

Use err.get_type(py) instead of err.ptype(py)

Deprecated name for PyErr::get_type.

pub fn pvalue<'py>(&'py self, py: Python<'py>) -> &'py PyBaseException

👎 Deprecated since 0.16.0:

Use err.value(py) instead of err.pvalue(py)

Deprecated name for PyErr::value.

pub fn ptraceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback>

👎 Deprecated since 0.16.0:

Use err.traceback(py) instead of err.ptraceback(py)

Deprecated name for PyErr::traceback.

pub fn instance<'py>(&'py self, py: Python<'py>) -> &'py PyBaseException

👎 Deprecated since 0.16.0:

Use err.value(py) instead of err.instance(py)

Deprecated name for PyErr::value.

pub fn from_instance(value: &PyAny) -> PyErr

👎 Deprecated since 0.16.0:

Use err.from_value(py, obj) instead of err.from_instance(py, obj)

Deprecated name for PyErr::from_value.

pub fn into_instance(self, py: Python<'_>) -> Py<PyBaseException>

👎 Deprecated since 0.16.0:

Use err.into_value(py) instead of err.into_instance(py)

Deprecated name for PyErr::into_value.

Trait Implementations

impl Debug for PyErr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for PyErr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for PyErr

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

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

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl From<&'_ CancelledError> for PyErr

fn from(err: &CancelledError) -> PyErr

Converts to this type from the input type.

impl From<&'_ IncompleteReadError> for PyErr

fn from(err: &IncompleteReadError) -> PyErr

Converts to this type from the input type.

impl From<&'_ InvalidStateError> for PyErr

fn from(err: &InvalidStateError) -> PyErr

Converts to this type from the input type.

impl From<&'_ LimitOverrunError> for PyErr

fn from(err: &LimitOverrunError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PanicException> for PyErr

fn from(err: &PanicException) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyArithmeticError> for PyErr

fn from(err: &PyArithmeticError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyAssertionError> for PyErr

fn from(err: &PyAssertionError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyAttributeError> for PyErr

fn from(err: &PyAttributeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyBaseException> for PyErr

fn from(err: &PyBaseException) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyBlockingIOError> for PyErr

fn from(err: &PyBlockingIOError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyBrokenPipeError> for PyErr

fn from(err: &PyBrokenPipeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyBufferError> for PyErr

fn from(err: &PyBufferError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyChildProcessError> for PyErr

fn from(err: &PyChildProcessError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyConnectionAbortedError> for PyErr

fn from(err: &PyConnectionAbortedError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyConnectionError> for PyErr

fn from(err: &PyConnectionError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyConnectionRefusedError> for PyErr

fn from(err: &PyConnectionRefusedError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyConnectionResetError> for PyErr

fn from(err: &PyConnectionResetError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyEOFError> for PyErr

fn from(err: &PyEOFError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyEnvironmentError> for PyErr

fn from(err: &PyEnvironmentError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyException> for PyErr

fn from(err: &PyException) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyFileExistsError> for PyErr

fn from(err: &PyFileExistsError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyFileNotFoundError> for PyErr

fn from(err: &PyFileNotFoundError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyFloatingPointError> for PyErr

fn from(err: &PyFloatingPointError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyGeneratorExit> for PyErr

fn from(err: &PyGeneratorExit) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyIOError> for PyErr

fn from(err: &PyIOError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyImportError> for PyErr

fn from(err: &PyImportError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyIndexError> for PyErr

fn from(err: &PyIndexError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyInterruptedError> for PyErr

fn from(err: &PyInterruptedError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyIsADirectoryError> for PyErr

fn from(err: &PyIsADirectoryError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyKeyError> for PyErr

fn from(err: &PyKeyError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyKeyboardInterrupt> for PyErr

fn from(err: &PyKeyboardInterrupt) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyLookupError> for PyErr

fn from(err: &PyLookupError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyMemoryError> for PyErr

fn from(err: &PyMemoryError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyModuleNotFoundError> for PyErr

fn from(err: &PyModuleNotFoundError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyNameError> for PyErr

fn from(err: &PyNameError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyNotADirectoryError> for PyErr

fn from(err: &PyNotADirectoryError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyNotImplementedError> for PyErr

fn from(err: &PyNotImplementedError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyOSError> for PyErr

fn from(err: &PyOSError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyOverflowError> for PyErr

fn from(err: &PyOverflowError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyPermissionError> for PyErr

fn from(err: &PyPermissionError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyProcessLookupError> for PyErr

fn from(err: &PyProcessLookupError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyRecursionError> for PyErr

fn from(err: &PyRecursionError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyReferenceError> for PyErr

fn from(err: &PyReferenceError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyRuntimeError> for PyErr

fn from(err: &PyRuntimeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyStopAsyncIteration> for PyErr

fn from(err: &PyStopAsyncIteration) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyStopIteration> for PyErr

fn from(err: &PyStopIteration) -> PyErr

Converts to this type from the input type.

impl From<&'_ PySyntaxError> for PyErr

fn from(err: &PySyntaxError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PySystemError> for PyErr

fn from(err: &PySystemError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PySystemExit> for PyErr

fn from(err: &PySystemExit) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyTimeoutError> for PyErr

fn from(err: &PyTimeoutError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyTypeError> for PyErr

fn from(err: &PyTypeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyUnboundLocalError> for PyErr

fn from(err: &PyUnboundLocalError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyUnicodeDecodeError> for PyErr

fn from(err: &PyUnicodeDecodeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyUnicodeEncodeError> for PyErr

fn from(err: &PyUnicodeEncodeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyUnicodeError> for PyErr

fn from(err: &PyUnicodeError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyUnicodeTranslateError> for PyErr

fn from(err: &PyUnicodeTranslateError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyValueError> for PyErr

fn from(err: &PyValueError) -> PyErr

Converts to this type from the input type.

impl From<&'_ PyZeroDivisionError> for PyErr

fn from(err: &PyZeroDivisionError) -> PyErr

Converts to this type from the input type.

impl From<&'_ QueueEmpty> for PyErr

fn from(err: &QueueEmpty) -> PyErr

Converts to this type from the input type.

impl From<&'_ QueueFull> for PyErr

fn from(err: &QueueFull) -> PyErr

Converts to this type from the input type.

impl From<&'_ TimeoutError> for PyErr

fn from(err: &TimeoutError) -> PyErr

Converts to this type from the input type.

impl From<&'_ gaierror> for PyErr

fn from(err: &gaierror) -> PyErr

Converts to this type from the input type.

impl From<&'_ herror> for PyErr

fn from(err: &herror) -> PyErr

Converts to this type from the input type.

impl From<&'_ timeout> for PyErr

fn from(err: &timeout) -> PyErr

Converts to this type from the input type.

impl From<AddrParseError> for PyErr

fn from(err: AddrParseError) -> PyErr

Converts to this type from the input type.

impl From<DecodeUtf16Error> for PyErr

fn from(err: DecodeUtf16Error) -> PyErr

Converts to this type from the input type.

impl From<Error> for PyErr

Create OSError from io::Error

fn from(err: Error) -> PyErr

Converts to this type from the input type.

impl From<FromUtf16Error> for PyErr

fn from(err: FromUtf16Error) -> PyErr

Converts to this type from the input type.

impl From<FromUtf8Error> for PyErr

fn from(err: FromUtf8Error) -> PyErr

Converts to this type from the input type.

impl From<Infallible> for PyErr

fn from(_: Infallible) -> PyErr

Converts to this type from the input type.

impl<W: 'static + Send + Sync + Debug> From<IntoInnerError<W>> for PyErr

fn from(err: IntoInnerError<W>) -> PyErr

Converts to this type from the input type.

impl From<IntoStringError> for PyErr

fn from(err: IntoStringError) -> PyErr

Converts to this type from the input type.

impl From<NulError> for PyErr

fn from(err: NulError) -> PyErr

Converts to this type from the input type.

impl From<ParseBoolError> for PyErr

fn from(err: ParseBoolError) -> PyErr

Converts to this type from the input type.

impl From<ParseFloatError> for PyErr

fn from(err: ParseFloatError) -> PyErr

Converts to this type from the input type.

impl From<ParseIntError> for PyErr

fn from(err: ParseIntError) -> PyErr

Converts to this type from the input type.

impl From<PyBorrowError> for PyErr

fn from(other: PyBorrowError) -> Self

Converts to this type from the input type.

impl From<PyBorrowMutError> for PyErr

fn from(other: PyBorrowMutError) -> Self

Converts to this type from the input type.

impl<'a> From<PyDowncastError<'a>> for PyErr

Convert PyDowncastError to Python TypeError.

fn from(err: PyDowncastError<'_>) -> PyErr

Converts to this type from the input type.

impl From<PyErr> for Error

Convert PyErr to io::Error

fn from(err: PyErr) -> Self

Converts to this type from the input type.

impl From<Report> for PyErr

Converts eyre::Report to a PyErr containing a PyRuntimeError.

If you want to raise a different Python exception you will have to do so manually. See PyErr::new for more information about that.

fn from(error: Report) -> Self

Converts to this type from the input type.

impl From<TryFromIntError> for PyErr

fn from(err: TryFromIntError) -> PyErr

Converts to this type from the input type.

impl From<TryFromSliceError> for PyErr

fn from(err: TryFromSliceError) -> PyErr

Converts to this type from the input type.

impl From<Utf8Error> for PyErr

fn from(err: Utf8Error) -> PyErr

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for PyErr

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a PyErr

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl ToPyObject for PyErr

fn to_object(&self, py: Python<'_>) -> PyObject

Converts self into a Python object.

impl Send for PyErr

impl Sync for PyErr