# pyo3::exceptions::asyncio::CancelledError - Rust
API documentation for the Rust `CancelledError` struct in crate `pyo3`.
Keywords: rust, rustlang, rust-lang, CancelledError

# Struct pyo3::exceptions::asyncio::CancelledError [−] [src]

    #[repr(transparent)]pub struct CancelledError(_);

## Implementations

### `impl CancelledError` [src]

#### `pub fn new_err<A>(args: A) -> PyErr where
A: PyErrArguments + Send + Sync + 'static,` [src]

## Methods from Deref<Target = PyAny>

#### `pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
T: PyTryFrom<'py>,` [src]

Convert this PyAny to a concrete Python type.

#### `pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool> where
N: ToPyObject,` [src]

Determines whether this object has the given attribute.

This is equivalent to the Python expression `hasattr(self, attr_name)`.

#### `pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny> where
N: ToPyObject,` [src]

Retrieves an attribute value.

This is equivalent to the Python expression `self.attr_name`.

#### `pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()> where
N: ToBorrowedObject,
V: ToBorrowedObject,` [src]

Sets an attribute value.

This is equivalent to the Python expression `self.attr_name = value`.

#### `pub fn delattr<N>(&self, attr_name: N) -> PyResult<()> where
N: ToPyObject,` [src]

Deletes an attribute.

This is equivalent to the Python expression `del self.attr_name`.

#### `pub fn compare<O>(&self, other: O) -> PyResult<Ordering> where
O: ToPyObject,` [src]

Compares two Python objects.

This is equivalent to:

    if self == other:
        return Equal
    elif a < b:
        return Less
    elif a > b:
        return Greater
    else:
        raise TypeError("PyAny::compare(): All comparisons returned false")

#### `pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> PyResult<&PyAny> where
O: ToPyObject,` [src]

Compares two Python objects.

Depending on the value of `compare_op`, this is equivalent to one of the following Python expressions:

- CompareOp::Eq: `self == other`
- CompareOp::Ne: `self != other`
- CompareOp::Lt: `self < other`
- CompareOp::Le: `self <= other`
- CompareOp::Gt: `self > other`
- CompareOp::Ge: `self >= other`

#### `pub fn is_callable(&self) -> bool` [src]

Determines whether this object is callable.

#### `pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls the object.

This is equivalent to the Python expression `self(*args, **kwargs)`.

#### `pub fn call0(&self) -> PyResult<&PyAny>` [src]

Calls the object without arguments.

This is equivalent to the Python expression `self()`.

#### `pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>` [src]

Calls the object with only positional arguments.

This is equivalent to the Python expression `self(*args)`.

#### `pub fn call_method(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls a method on the object.

This is equivalent to the Python expression `self.name(*args, **kwargs)`.

# Example

    use pyo3::types::IntoPyDict;

    let gil = Python::acquire_gil();
    let py = gil.python();
    let list = vec![3, 6, 5, 4, 7].to_object(py);
    let dict = vec![("reverse", true)].into_py_dict(py);
    list.call_method(py, "sort", (), Some(dict)).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3]);

    let new_element = 1.to_object(py);
    list.call_method(py, "append", (new_element,), None).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3, 1]);

#### `pub fn call_method0(&self, name: &str) -> PyResult<&PyAny>` [src]

Calls a method on the object without arguments.

This is equivalent to the Python expression `self.name()`.

#### `pub fn call_method1(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>
) -> PyResult<&PyAny>` [src]

Calls a method on the object with only positional arguments.

This is equivalent to the Python expression `self.name(*args)`.

#### `pub fn is_true(&self) -> PyResult<bool>` [src]

Returns whether the object is considered to be true.

This is equivalent to the Python expression `bool(self)`.

#### `pub fn is_none(&self) -> bool` [src]

Returns whether the object is considered to be None.

This is equivalent to the Python expression `self is None`.

#### `pub fn is_empty(&self) -> PyResult<bool>` [src]

Returns true if the sequence or mapping has a length of 0.

This is equivalent to the Python expression `len(self) == 0`.

#### `pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny> where
K: ToBorrowedObject,` [src]

Gets an item from the collection.

This is equivalent to the Python expression `self[key]`.

#### `pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()> where
K: ToBorrowedObject,
V: ToBorrowedObject,` [src]

Sets a collection item value.

This is equivalent to the Python expression `self[key] = value`.

#### `pub fn del_item<K>(&self, key: K) -> PyResult<()> where
K: ToBorrowedObject,` [src]

Deletes an item from the collection.

This is equivalent to the Python expression `del self[key]`.

#### `pub fn iter(&self) -> PyResult<&PyIterator>` [src]

Takes an object and returns an iterator for it.

This is typically a new iterator but if the argument is an iterator, this returns itself.

#### `pub fn get_type(&self) -> &PyType` [src]

Returns the Python type object for this object’s type.

#### `pub fn get_type_ptr(&self) -> *mut PyTypeObject` [src]

Returns the Python type pointer for this object.

#### `pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>> where
D: PyTryFrom<'a>,` [src]

Casts the PyObject to a concrete Python object type.

This can cast only to native Python types, not types implemented in Rust.

#### `pub fn extract<'a, D>(&'a self) -> PyResult<D> where
D: FromPyObject<'a>,` [src]

Extracts some type from the Python object.

This is a wrapper function around `FromPyObject::extract()`.

#### `pub fn get_refcnt(&self) -> isize` [src]

Returns the reference count for the Python object.

#### `pub fn repr(&self) -> PyResult<&PyString>` [src]

Computes the “repr” representation of self.

This is equivalent to the Python expression `repr(self)`.

#### `pub fn str(&self) -> PyResult<&PyString>` [src]

Computes the “str” representation of self.

This is equivalent to the Python expression `str(self)`.

#### `pub fn hash(&self) -> PyResult<isize>` [src]

Retrieves the hash code of self.

This is equivalent to the Python expression `hash(self)`.

#### `pub fn len(&self) -> PyResult<usize>` [src]

Returns the length of the sequence or mapping.

This is equivalent to the Python expression `len(self)`.

#### `pub fn dir(&self) -> &PyList` [src]

Returns the list of attributes of this object.

This is equivalent to the Python expression `dir(self)`.

#### `pub fn is_instance<T: PyTypeObject>(&self) -> PyResult<bool>` [src]

Checks whether this object is an instance of type `T`.

This is equivalent to the Python expression `isinstance(self, T)`.

## Trait Implementations

### `impl AsPyPointer for CancelledError` [src]

#### `fn as_ptr(&self) -> *mut PyObject` [src]

Gets the underlying FFI pointer, returns a borrowed pointer.

### `impl AsRef<PyAny> for CancelledError` [src]

#### `fn as_ref(&self) -> &PyAny` [src]

Performs the conversion.

### `impl Debug for CancelledError` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Deref for CancelledError` [src]

#### `type Target = PyAny`

The resulting type after dereferencing.

#### `fn deref(&self) -> &PyAny` [src]

Dereferences the value.

### `impl Display for CancelledError` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Error for CancelledError` [src]

#### `fn source(&self) -> Option<&(dyn Error + 'static)>` [src]

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

#### `pub fn backtrace(&self) -> Option<&Backtrace>` [src]

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

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

#### `pub fn description(&self) -> &str` 1.0.0 [src]

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

Read more

#### `pub fn cause(&self) -> Option<&dyn Error>`1.0.0 [src]

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

### `impl From<&'_ CancelledError> for PyErr` [src]

#### `fn from(err: &CancelledError) -> PyErr` [src]

Performs the conversion.

### `impl From<&'_ CancelledError> for Py<CancelledError>` [src]

#### `fn from(other: &CancelledError) -> Self` [src]

Performs the conversion.

### `impl<'a> From<&'a CancelledError> for &'a PyAny` [src]

#### `fn from(ob: &'a CancelledError) -> Self` [src]

Performs the conversion.

### `impl<'py> FromPyObject<'py> for &'py CancelledError` [src]

#### `fn extract(obj: &'py PyAny) -> PyResult<Self>` [src]

Extracts `Self` from the source `PyObject`.

### `impl IntoPy<Py<CancelledError>> for &CancelledError` [src]

#### `fn into_py(self, py: Python<'_>) -> Py<CancelledError>` [src]

Performs the conversion.

### `impl PartialEq<CancelledError> for CancelledError` [src]

#### `fn eq(&self, o: &CancelledError) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PyLayout<CancelledError> for PyBaseExceptionObject` [src]

#### `const IS_NATIVE_TYPE: bool` [src]

#### `fn get_super(&mut self) -> Option<&mut T::BaseLayout>` [src]

#### `fn py_init(&mut self, _value: T)` [src]

#### `unsafe fn py_drop(&mut self, _py: Python<'_>)` [src]

### `impl PyNativeType for CancelledError` [src]

#### `fn py(&self) -> Python<'_>` [src]

#### `unsafe fn unchecked_downcast(obj: &PyAny) -> &Self` [src]

Cast `&PyAny` to `&Self` without no type checking. Read more

### `impl PyTypeInfo for CancelledError` [src]

#### `type Type = ()`

Type of objects to store in PyObject struct

#### `type BaseType = PyAny`

Base class

#### `type Layout = PyBaseExceptionObject`

Layout

#### `type BaseLayout = PyObject`

Layout of Basetype.

#### `type Initializer = PyNativeTypeInitializer<Self>`

Initializer for layout

#### `type AsRefTarget = Self`

Utility type to make Py::as_ref work

#### `const NAME: &'static str` [src]

Class name

#### `const MODULE: Option<&'static str>` [src]

Module name, if any

#### `fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject` [src]

PyTypeObject instance for this type.

#### `const DESCRIPTION: &'static str` [src]

Class doc string

#### `const FLAGS: usize` [src]

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

#### `fn is_type_of(object: &PyAny) -> bool` [src]

Checks if `object` is an instance of this type or a subclass of this type.

#### `fn is_exact_type_of(object: &PyAny) -> bool` [src]

Checks if `object` is an instance of this type.

### `impl ToPyObject for CancelledError` [src]

#### `fn to_object(&self, py: Python<'_>) -> PyObject` [src]

Converts self into a Python object.

## Auto Trait Implementations

### `impl !RefUnwindSafe for CancelledError`

### `impl !Send for CancelledError`

### `impl !Sync for CancelledError`

### `impl Unpin for CancelledError`

### `impl UnwindSafe for CancelledError`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<'p, T> FromPyPointer<'p> for T where
T: 'p + PyNativeType,` [src]

#### `pub unsafe fn from_owned_ptr_or_opt(Python<'p>, *mut PyObject) -> Option<&'p T>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `pub unsafe fn from_borrowed_ptr_or_opt(
Python<'p>,
*mut PyObject
) -> Option<&'p T>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_owned_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<'v, T> PyTryFrom<'v> for T where
T: PyTypeInfo + PyNativeType,` [src]

#### `pub fn try_from<V>(V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,` [src]

Cast from a concrete Python object type to PyObject.

#### `pub fn try_from_exact<V>(V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,` [src]

Cast from a concrete Python object type to PyObject. With exact type check.

#### `pub unsafe fn try_from_unchecked<V>(V) -> &'v T where
V: Into<&'v PyAny>,` [src]

Cast a PyAny to a specific type of PyObject. The caller must have already verified the reference is for this type. Read more

### `impl<T> PyTypeObject for T where
T: PyTypeInfo,` [src]

#### `pub fn type_object(Python<'_>) -> &PyType` [src]

Returns the safe abstraction over the type object.

### `impl<T> ToBorrowedObject for T where
T: ToPyObject,` [src]

#### `fn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> R where
F: FnOnce(*mut PyObject) -> R,` [src]

Converts self into a Python object and calls the specified closure on the native FFI pointer underlying the Python object. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.