Struct Bound 

#[repr(transparent)]
pub struct Bound<'py, T>(Python<'py>, ManuallyDrop<Py<T>>);

A Python thread-attached equivalent to Py<T>.

This type can be thought of as equivalent to the tuple (Py<T>, Python<'py>). By having the 'py lifetime of the Python<'py> token, this ties the lifetime of the Bound<'py, T> smart pointer to the lifetime the thread is attached to the Python interpreter and allows PyO3 to call Python APIs at maximum efficiency.

To access the object in situations where the thread is not attached, convert it to Py<T> using .unbind(). This includes, for example, usage in Python::detach’s closure.

See the guide for more detail.

Tuple Fields

0: Python<'py>

1: ManuallyDrop<Py<T>>

Implementations

impl Bound<'_, PyType>

pub(crate) fn get_slot<const S: c_int>( &self, slot: Slot<S>, ) -> <Slot<S> as GetSlotImpl>::Type

where Slot<S>: GetSlotImpl,

impl<'py, T> Bound<'py, T>

where T: PyClass,

pub fn new( py: Python<'py>, value: impl Into<PyClassInitializer<T>>, ) -> PyResult<Bound<'py, T>>

Creates a new instance Bound<T> of a #[pyclass] on the Python heap.

Examples

use pyo3::prelude::*;

#[pyclass]
struct Foo {/* fields omitted */}

let foo: Py<Foo> = Python::attach(|py| -> PyResult<_> {
    let foo: Bound<'_, Foo> = Bound::new(py, Foo {})?;
    Ok(foo.into())
})?;

impl<'py, T> Bound<'py, T>

pub fn cast<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>

where U: PyTypeCheck,

Cast this to a concrete Python type or pyclass.

Note that you can often avoid casting yourself by just specifying the desired type in function or method signatures. However, manual casting is sometimes necessary.

For extracting a Rust-only type, see extract.

This performs a runtime type check using the equivalent of Python’s isinstance(self, U).

Example: Casting to a specific Python object

use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

Python::attach(|py| {
    let dict = PyDict::new(py);
    assert!(dict.is_instance_of::<PyAny>());
    let any = dict.as_any();

    assert!(any.cast::<PyDict>().is_ok());
    assert!(any.cast::<PyList>().is_err());
});

Example: Getting a reference to a pyclass

This is useful if you want to mutate a Py<PyAny> that might actually be a pyclass.

use pyo3::prelude::*;

#[pyclass]
struct Class {
    i: i32,
}

Python::attach(|py| {
    let class = Bound::new(py, Class { i: 0 })?.into_any();

    let class_bound: &Bound<'_, Class> = class.cast()?;

    class_bound.borrow_mut().i += 1;

    // Alternatively you can get a `PyRefMut` directly
    let class_ref: PyRefMut<'_, Class> = class.extract()?;
    assert_eq!(class_ref.i, 1);
    Ok(())
})

pub fn cast_into<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>

where U: PyTypeCheck,

Like cast but takes ownership of self.

In case of an error, it is possible to retrieve self again via CastIntoError::into_inner.

Example

use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

Python::attach(|py| {
    let obj: Bound<'_, PyAny> = PyDict::new(py).into_any();

    let obj: Bound<'_, PyAny> = match obj.cast_into::<PyList>() {
        Ok(_) => panic!("obj should not be a list"),
        Err(err) => err.into_inner(),
    };

    // obj is a dictionary
    assert!(obj.cast_into::<PyDict>().is_ok());
})

pub fn cast_exact<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>

where U: PyTypeInfo,

Cast this to a concrete Python type or pyclass (but not a subclass of it).

It is almost always better to use cast because it accounts for Python subtyping. Use this method only when you do not want to allow subtypes.

The advantage of this method over cast is that it is faster. The implementation of cast_exact uses the equivalent of the Python expression type(self) is U, whereas cast uses isinstance(self, U).

For extracting a Rust-only type, see extract.

Example: Casting to a specific Python object but not a subtype

use pyo3::prelude::*;
use pyo3::types::{PyBool, PyInt};

Python::attach(|py| {
    let b = PyBool::new(py, true);
    assert!(b.is_instance_of::<PyBool>());
    let any: &Bound<'_, PyAny> = b.as_any();

    // `bool` is a subtype of `int`, so `cast` will accept a `bool` as an `int`
    // but `cast_exact` will not.
    assert!(any.cast::<PyInt>().is_ok());
    assert!(any.cast_exact::<PyInt>().is_err());

    assert!(any.cast_exact::<PyBool>().is_ok());
});

pub fn cast_into_exact<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>

where U: PyTypeInfo,

Like cast_exact but takes ownership of self.

pub unsafe fn cast_unchecked<U>(&self) -> &Bound<'py, U>

Converts this to a concrete Python type without checking validity.

Safety

Callers must ensure that the type is valid or risk type confusion.

pub unsafe fn cast_into_unchecked<U>(self) -> Bound<'py, U>

Like cast_unchecked but takes ownership of self.

Safety

Callers must ensure that the type is valid or risk type confusion.

impl<'py> Bound<'py, PyAny>

pub unsafe fn from_owned_ptr(py: Python<'py>, ptr: *mut PyObject) -> Self

Constructs a new Bound<'py, PyAny> from a pointer. Panics if ptr is null.

Safety

• ptr must be a valid pointer to a Python object (or null, which will cause a panic)
• ptr must be an owned Python reference, as the Bound<'py, PyAny> will assume ownership

Panics

Panics if ptr is null.

pub unsafe fn from_owned_ptr_or_opt( py: Python<'py>, ptr: *mut PyObject, ) -> Option<Self>

Constructs a new Bound<'py, PyAny> from a pointer. Returns None if ptr is null.

Safety

• ptr must be a valid pointer to a Python object, or null
• ptr must be an owned Python reference, as the Bound<'py, PyAny> will assume ownership

pub unsafe fn from_owned_ptr_or_err( py: Python<'py>, ptr: *mut PyObject, ) -> PyResult<Self>

Constructs a new Bound<'py, PyAny> from a pointer. Returns an Err by calling PyErr::fetch if ptr is null.

Safety

• ptr must be a valid pointer to a Python object, or null
• ptr must be an owned Python reference, as the Bound<'py, PyAny> will assume ownership

pub(crate) unsafe fn from_owned_ptr_unchecked( py: Python<'py>, ptr: *mut PyObject, ) -> Self

Constructs a new Bound<'py, PyAny> from a pointer without checking for null.

Safety

• ptr must be a valid pointer to a Python object
• ptr must be a strong/owned reference

pub unsafe fn from_borrowed_ptr(py: Python<'py>, ptr: *mut PyObject) -> Self

Constructs a new Bound<'py, PyAny> from a pointer by creating a new Python reference. Panics if ptr is null.

Safety

• ptr must be a valid pointer to a Python object

Panics

Panics if ptr is null

pub unsafe fn from_borrowed_ptr_or_opt( py: Python<'py>, ptr: *mut PyObject, ) -> Option<Self>

Constructs a new Bound<'py, PyAny> from a pointer by creating a new Python reference. Returns None if ptr is null.

Safety

• ptr must be a valid pointer to a Python object, or null

pub unsafe fn from_borrowed_ptr_or_err( py: Python<'py>, ptr: *mut PyObject, ) -> PyResult<Self>

Constructs a new Bound<'py, PyAny> from a pointer by creating a new Python reference. Returns an Err by calling PyErr::fetch if ptr is null.

Safety

• ptr must be a valid pointer to a Python object, or null

#[doc(hidden)]

pub unsafe fn ref_from_ptr<'a>( _py: Python<'py>, ptr: &'a *mut PyObject, ) -> &'a Self

This slightly strange method is used to obtain &Bound<PyAny> from a pointer in macro code where we need to constrain the lifetime 'a safely.

Note that 'py is required to outlive 'a implicitly by the nature of the fact that &'a Bound<'py> means that Bound<'py> exists for at least the lifetime 'a.

Safety

• ptr must be a valid pointer to a Python object for the lifetime 'a. The ptr can be either a borrowed reference or an owned reference, it does not matter, as this is just &Bound there will never be any ownership transfer.

pub(crate) unsafe fn ref_from_ptr_or_opt<'a>( _py: Python<'py>, ptr: &'a *mut PyObject, ) -> &'a Option<Self>

Variant of the above which returns None for null pointers.

Safety

• ptr must be a valid pointer to a Python object for the lifetime `’a, or null.

#[doc(hidden)]

pub unsafe fn ref_from_non_null<'a>( _py: Python<'py>, ptr: &'a NonNull<PyObject>, ) -> &'a Self

This slightly strange method is used to obtain &Bound<PyAny> from a NonNull in macro code where we need to constrain the lifetime 'a safely.

Note that 'py is required to outlive 'a implicitly by the nature of the fact that &'a Bound<'py> means that Bound<'py> exists for at least the lifetime 'a.

Safety

• ptr must be a valid pointer to a Python object for the lifetime 'a. The ptr can be either a borrowed reference or an owned reference, it does not matter, as this is just &Bound there will never be any ownership transfer.

impl<'py, T> Bound<'py, T>

where T: PyClass,

pub fn borrow(&self) -> PyRef<'py, T>

Immutably borrows the value T.

This borrow lasts while the returned PyRef exists. Multiple immutable borrows can be taken out at the same time.

For frozen classes, the simpler get is available.

Examples

#[pyclass]
struct Foo {
    inner: u8,
}

Python::attach(|py| -> PyResult<()> {
    let foo: Bound<'_, Foo> = Bound::new(py, Foo { inner: 73 })?;
    let inner: &u8 = &foo.borrow().inner;

    assert_eq!(*inner, 73);
    Ok(())
})?;

Panics

Panics if the value is currently mutably borrowed. For a non-panicking variant, use try_borrow.

pub fn borrow_mut(&self) -> PyRefMut<'py, T>

where T: PyClass<Frozen = False>,

Mutably borrows the value T.

This borrow lasts while the returned PyRefMut exists.

Examples

#[pyclass]
struct Foo {
    inner: u8,
}

Python::attach(|py| -> PyResult<()> {
    let foo: Bound<'_, Foo> = Bound::new(py, Foo { inner: 73 })?;
    foo.borrow_mut().inner = 35;

    assert_eq!(foo.borrow().inner, 35);
    Ok(())
})?;

Panics

Panics if the value is currently borrowed. For a non-panicking variant, use try_borrow_mut.

pub fn try_borrow(&self) -> Result<PyRef<'py, T>, PyBorrowError>

Attempts to immutably borrow the value T, returning an error if the value is currently mutably borrowed.

The borrow lasts while the returned PyRef exists.

This is the non-panicking variant of borrow.

For frozen classes, the simpler get is available.

pub fn try_borrow_mut(&self) -> Result<PyRefMut<'py, T>, PyBorrowMutError>

where T: PyClass<Frozen = False>,

Attempts to mutably borrow the value T, returning an error if the value is currently borrowed.

The borrow lasts while the returned PyRefMut exists.

This is the non-panicking variant of borrow_mut.

pub fn get(&self) -> &T

where T: PyClass<Frozen = True> + Sync,

Provide an immutable borrow of the value T.

This is available if the class is frozen and Sync.

Examples

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

#[pyclass(frozen)]
struct FrozenCounter {
    value: AtomicUsize,
}

Python::attach(|py| {
    let counter = FrozenCounter { value: AtomicUsize::new(0) };

    let py_counter = Bound::new(py, counter).unwrap();

    py_counter.get().value.fetch_add(1, Ordering::Relaxed);
});

pub fn as_super(&self) -> &Bound<'py, T::BaseType>

Upcast this Bound<PyClass> to its base type by reference.

If this type defined an explicit base class in its pyclass declaration (e.g. #[pyclass(extends = BaseType)]), the returned type will be &Bound<BaseType>. If an explicit base class was not declared, the return value will be &Bound<PyAny> (making this method equivalent to as_any).

This method is particularly useful for calling methods defined in an extension trait that has been implemented for Bound<BaseType>.

See also the into_super method to upcast by value, and the PyRef::as_super/PyRefMut::as_super methods for upcasting a pyclass that has already been borrowed.

Example: Calling a method defined on the Bound base type

use pyo3::prelude::*;

#[pyclass(subclass)]
struct BaseClass;

trait MyClassMethods<'py> {
    fn pyrepr(&self) -> PyResult<String>;
}
impl<'py> MyClassMethods<'py> for Bound<'py, BaseClass> {
    fn pyrepr(&self) -> PyResult<String> {
        self.call_method0("__repr__")?.extract()
    }
}

#[pyclass(extends = BaseClass)]
struct SubClass;

Python::attach(|py| {
    let initializer = PyClassInitializer::from(BaseClass).add_subclass(SubClass);
    let obj = Bound::new(py, initializer).unwrap();
    assert!(obj.as_super().pyrepr().is_ok());
})

pub fn into_super(self) -> Bound<'py, T::BaseType>

Upcast this Bound<PyClass> to its base type by value.

If this type defined an explicit base class in its pyclass declaration (e.g. #[pyclass(extends = BaseType)]), the returned type will be Bound<BaseType>. If an explicit base class was not declared, the return value will be Bound<PyAny> (making this method equivalent to into_any).

This method is particularly useful for calling methods defined in an extension trait that has been implemented for Bound<BaseType>.

See also the as_super method to upcast by reference, and the PyRef::into_super/PyRefMut::into_super methods for upcasting a pyclass that has already been borrowed.

Example: Calling a method defined on the Bound base type

use pyo3::prelude::*;

#[pyclass(subclass)]
struct BaseClass;

trait MyClassMethods<'py> {
    fn pyrepr(self) -> PyResult<String>;
}
impl<'py> MyClassMethods<'py> for Bound<'py, BaseClass> {
    fn pyrepr(self) -> PyResult<String> {
        self.call_method0("__repr__")?.extract()
    }
}

#[pyclass(extends = BaseClass)]
struct SubClass;

Python::attach(|py| {
    let initializer = PyClassInitializer::from(BaseClass).add_subclass(SubClass);
    let obj = Bound::new(py, initializer).unwrap();
    assert!(obj.into_super().pyrepr().is_ok());
})

pub(crate) fn get_class_object(&self) -> &<T as PyClassImpl>::Layout

impl<'py, T> Bound<'py, T>

pub fn py(&self) -> Python<'py>

Returns the Python token associated with this object.

pub fn as_ptr(&self) -> *mut PyObject

Returns the raw FFI pointer represented by self.

Safety

Callers are responsible for ensuring that the pointer does not outlive self.

The reference is borrowed; callers should not decrease the reference count when they are finished with the pointer.

pub fn into_ptr(self) -> *mut PyObject

Returns an owned raw FFI pointer represented by self.

Safety

The reference is owned; when finished the caller should either transfer ownership of the pointer or decrease the reference count (e.g. with pyo3::ffi::Py_DecRef).

pub fn as_any(&self) -> &Bound<'py, PyAny>

Helper to cast to Bound<'py, PyAny>.

pub fn into_any(self) -> Bound<'py, PyAny>

Helper to cast to Bound<'py, PyAny>, transferring ownership.

pub fn as_borrowed<'a>(&'a self) -> Borrowed<'a, 'py, T>

Casts this Bound<T> to a Borrowed<T> smart pointer.

pub fn unbind(self) -> Py<T>

Removes the connection for this Bound<T> from the Python<'py> token, allowing it to cross thread boundaries.

pub fn as_unbound(&self) -> &Py<T>

Removes the connection for this Bound<T> from the Python<'py> token, allowing it to cross thread boundaries, without transferring ownership.

impl<'py> Bound<'py, PyAny>

pub(crate) fn lookup_special<N>( &self, attr_name: N, ) -> PyResult<Option<Bound<'py, PyAny>>>

where N: IntoPyObject<'py, Target = PyString>,

Retrieve an attribute value, skipping the instance dictionary during the lookup but still binding the object to the instance.

This is useful when trying to resolve Python’s “magic” methods like __getitem__, which are looked up starting from the type object. This returns an Option as it is not typically a direct error for the special lookup to fail, as magic methods are optional in many situations in which they might be called.

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

pub(crate) fn _get_refcnt(&self) -> isize

impl<'py> Bound<'py, PyIterator>

pub fn send(&self, value: &Bound<'py, PyAny>) -> PyResult<PySendResult<'py>>

Available on Py_3_10 and non-PyPy only.

Sends a value into a python generator. This is the equivalent of calling generator.send(value) in Python. This resumes the generator and continues its execution until the next yield or return statement. When the generator completes, the (optional) return value will be returned as PySendResult::Return. All subsequent calls will return PySendResult::Return(None). The first call to send must be made with None as the argument to start the generator, failing to do so will raise a TypeError.

Trait Implementations

impl<'py> Add for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the + operator.

fn add(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the + operation.

impl<'py> Add for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the + operator.

fn add(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the + operation.

impl<'py> Add<&Bound<'py, PyComplex>> for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the + operator.

fn add(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the + operation.

impl<'py> Add<Bound<'py, PyComplex>> for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the + operator.

fn add(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the + operation.

impl<'py, T> AsRef<Bound<'py, PyAny>> for Bound<'py, T>

fn as_ref(&self) -> &Bound<'py, PyAny>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<Py<PyAny>> for Bound<'_, T>

fn as_ref(&self) -> &Py<PyAny>

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8]> for Bound<'_, PyBytes>

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'py, T> BoundObject<'py, T> for Bound<'py, T>

type Any = Bound<'py, PyAny>

Type erased version of Self

fn as_borrowed(&self) -> Borrowed<'_, 'py, T>

Borrow this smart pointer.

fn into_bound(self) -> Bound<'py, T>

Turns this smart pointer into an owned Bound<'py, T>

fn into_any(self) -> Self::Any

Upcast the target type of this smart pointer

fn into_ptr(self) -> *mut PyObject

Turn this smart pointer into a strong reference pointer

fn as_ptr(&self) -> *mut PyObject

Turn this smart pointer into a borrowed reference pointer

fn unbind(self) -> Py<T>

Turn this smart pointer into an owned Py<T>

impl<T> Clone for Bound<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Bound<'_, T>

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

Formats the value using the given formatter.

impl<'py, T> Deref for Bound<'py, T>

where T: DerefToPyAny,

type Target = Bound<'py, PyAny>

The resulting type after dereferencing.

fn deref(&self) -> &Bound<'py, PyAny>

Dereferences the value.

impl<T> Display for Bound<'_, T>

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

Formats the value using the given formatter.

impl<'py> Div for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the / operator.

fn div(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the / operation.

impl<'py> Div for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the / operator.

fn div(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the / operation.

impl<'py> Div<&Bound<'py, PyComplex>> for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the / operator.

fn div(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the / operation.

impl<'py> Div<Bound<'py, PyComplex>> for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the / operator.

fn div(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the / operation.

impl<T> Drop for Bound<'_, T>

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.

impl<'a, 'py, T> From<&'a Bound<'py, T>> for Borrowed<'a, 'py, T>

fn from(instance: &'a Bound<'py, T>) -> Self

Create borrow on a Bound

impl<T> From<&Bound<'_, T>> for Py<T>

fn from(value: &Bound<'_, T>) -> Self

Converts to this type from the input type.

impl<'py, T> From<&Bound<'py, T>> for Bound<'py, T>

fn from(value: &Bound<'py, T>) -> Self

Converts to this type from the input type.

impl From<Bound<'_, PyByteArray>> for PyBackedBytes

fn from(py_bytearray: Bound<'_, PyByteArray>) -> Self

Converts to this type from the input type.

impl From<Bound<'_, PyBytes>> for PyBackedBytes

fn from(py_bytes: Bound<'_, PyBytes>) -> Self

Converts to this type from the input type.

impl<T> From<Bound<'_, T>> for Py<PyAny>

where T: DerefToPyAny,

fn from(other: Bound<'_, T>) -> Self

Converts to this type from the input type.

impl<T> From<Bound<'_, T>> for Py<T>

fn from(other: Bound<'_, T>) -> Self

Converts to this type from the input type.

impl<'py, T> From<Bound<'py, T>> for PyErr

where T: ToPyErr,

fn from(err: Bound<'py, T>) -> PyErr

Converts to this type from the input type.

impl<'a, 'py, T> FromPyObject<'a, 'py> for Bound<'py, T>

where T: PyTypeCheck + 'a,

fn extract(ob: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error>

Extracts Self from the source PyObject.

const INPUT_TYPE: PyStaticExpr = T::TYPE_HINT

Available on crate feature experimental-inspect only.

Provides the type hint information for this type when it appears as an argument.

type Error = CastError<'a, 'py>

The type returned in the event of a conversion error.

#[doc(hidden)]

fn sequence_extractor( _obj: Borrowed<'_, 'py, PyAny>, _: Token, ) -> Option<impl FromPyObjectSequence<Target = Self>>

Specialization hook for extracting sequences for types like Vec<u8> and [u8; N], where the bytes can be directly copied from some python objects without going through iteration.

fn as_local_tz(_: Token) -> Option<Self>

Available on crate feature chrono-local only.

Helper used to make a specialized path in extracting DateTime<Tz> where Tz is chrono::Local, which will accept “naive” datetime objects as being in the local timezone.

impl<I: SliceIndex<[u8]>> Index<I> for Bound<'_, PyBytes>

This is the same way Vec is indexed.

type Output = <I as SliceIndex<[u8]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'py> IntoIterator for Bound<'py, PyDict>

type Item = (Bound<'py, PyAny>, Bound<'py, PyAny>)

The type of the elements being iterated over.

type IntoIter = BoundDictIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for &Bound<'py, PyDict>

type Item = (Bound<'py, PyAny>, Bound<'py, PyAny>)

The type of the elements being iterated over.

type IntoIter = BoundDictIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for Bound<'py, PyFrozenSet>

fn into_iter(self) -> Self::IntoIter

Returns an iterator of values in this set.

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundFrozenSetIterator<'py>

Which kind of iterator are we turning this into?

impl<'py> IntoIterator for &Bound<'py, PyFrozenSet>

fn into_iter(self) -> Self::IntoIter

Returns an iterator of values in this set.

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundFrozenSetIterator<'py>

Which kind of iterator are we turning this into?

impl<'py> IntoIterator for &Bound<'py, PyIterator>

type Item = Result<Bound<'py, PyAny>, PyErr>

The type of the elements being iterated over.

type IntoIter = Bound<'py, PyIterator>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for Bound<'py, PyList>

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundListIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for &Bound<'py, PyList>

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundListIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for Bound<'py, PySet>

fn into_iter(self) -> Self::IntoIter

Returns an iterator of values in this set.

Panics

If PyO3 detects that the set is mutated during iteration, it will panic.

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundSetIterator<'py>

Which kind of iterator are we turning this into?

impl<'py> IntoIterator for &Bound<'py, PySet>

fn into_iter(self) -> Self::IntoIter

Returns an iterator of values in this set.

Panics

If PyO3 detects that the set is mutated during iteration, it will panic.

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundSetIterator<'py>

Which kind of iterator are we turning this into?

impl<'py> IntoIterator for Bound<'py, PyTuple>

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundTupleIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py> IntoIterator for &Bound<'py, PyTuple>

type Item = Bound<'py, PyAny>

The type of the elements being iterated over.

type IntoIter = BoundTupleIterator<'py>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'py, T: PyTypeCheck> IntoPyObject<'py> for Bound<'py, T>

const OUTPUT_TYPE: PyStaticExpr = T::TYPE_HINT

Available on crate feature experimental-inspect only.

Extracts the type hint information for this type when it appears as a return value.

type Target = T

The Python output type

type Output = Bound<'py, <Bound<'py, T> as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = Infallible

The type returned in the event of a conversion error.

fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error>

Performs the conversion.

#[doc(hidden)]

fn owned_sequence_into_pyobject<I>( iter: I, py: Python<'py>, _: Token, ) -> Result<Bound<'py, PyAny>, PyErr>

where I: IntoIterator<Item = Self> + AsRef<[Self]>, I::IntoIter: ExactSizeIterator<Item = Self>,

Converts sequence of Self into a Python object. Used to specialize Vec<u8>, [u8; N] and SmallVec<[u8; N]> as a sequence of bytes into a bytes object.

#[doc(hidden)]

const SEQUENCE_OUTPUT_TYPE: PyStaticExpr = _

Available on crate feature experimental-inspect only.

The output type of IntoPyObject::owned_sequence_into_pyobject and IntoPyObject::borrowed_sequence_into_pyobject

impl<'a, 'py, T: PyTypeCheck> IntoPyObject<'py> for &'a Bound<'py, T>

const OUTPUT_TYPE: PyStaticExpr = T::TYPE_HINT

Available on crate feature experimental-inspect only.

Extracts the type hint information for this type when it appears as a return value.

type Target = T

The Python output type

type Output = Borrowed<'a, 'py, <&'a Bound<'py, T> as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = Infallible

The type returned in the event of a conversion error.

fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error>

Performs the conversion.

#[doc(hidden)]

fn owned_sequence_into_pyobject<I>( iter: I, py: Python<'py>, _: Token, ) -> Result<Bound<'py, PyAny>, PyErr>

where I: IntoIterator<Item = Self> + AsRef<[Self]>, I::IntoIter: ExactSizeIterator<Item = Self>,

Converts sequence of Self into a Python object. Used to specialize Vec<u8>, [u8; N] and SmallVec<[u8; N]> as a sequence of bytes into a bytes object.

#[doc(hidden)]

fn borrowed_sequence_into_pyobject<I>( iter: I, py: Python<'py>, _: Token, ) -> Result<Bound<'py, PyAny>, PyErr>

where Self: Reference, I: IntoIterator<Item = Self> + AsRef<[<Self as Reference>::BaseType]>, I::IntoIter: ExactSizeIterator<Item = Self>,

Converts sequence of Self into a Python object. Used to specialize &[u8] and Cow<[u8]> as a sequence of bytes into a bytes object.

#[doc(hidden)]

const SEQUENCE_OUTPUT_TYPE: PyStaticExpr = _

Available on crate feature experimental-inspect only.

The output type of IntoPyObject::owned_sequence_into_pyobject and IntoPyObject::borrowed_sequence_into_pyobject

impl<'py> Iterator for Bound<'py, PyIterator>

fn next(&mut self) -> Option<Self::Item>

Retrieves the next item from an iterator.

Returns None when the iterator is exhausted. If an exception occurs, returns Some(Err(..)). Further next() calls after an exception occurs are likely to repeatedly result in the same exception.

type Item = Result<Bound<'py, PyAny>, PyErr>

The type of the elements being iterated over.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

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

Advances the iterator and returns an array containing the next N values.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

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

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

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

Creates a new iterator which places a copy of separator between items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

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

Creates a new iterator which places an item generated by separator between items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

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

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

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

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

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

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

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

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

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

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements.

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

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

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

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

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<'py> Mul for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the * operator.

fn mul(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the * operation.

impl<'py> Mul for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the * operator.

fn mul(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the * operation.

impl<'py> Mul<&Bound<'py, PyComplex>> for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the * operator.

fn mul(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the * operation.

impl<'py> Mul<Bound<'py, PyComplex>> for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the * operator.

fn mul(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the * operation.

impl<'py> Neg for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn neg(self) -> Bound<'py, PyComplex>

Performs the unary - operation.

impl<'py> Neg for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn neg(self) -> Bound<'py, PyComplex>

Performs the unary - operation.

impl PartialEq<&Bound<'_, PyBool>> for bool

Compare bool with &Bound<PyBool>

fn eq(&self, other: &&Bound<'_, PyBool>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&Bound<'_, PyBytes>> for [u8]

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &&Bound<'_, PyBytes>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&Bound<'_, PyFloat>> for f64

fn eq(&self, other: &&Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&Bound<'_, PyFloat>> for f32

fn eq(&self, other: &&Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&Bound<'_, PyString>> for str

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &&Bound<'_, PyString>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&[u8]> for Bound<'_, PyBytes>

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &&[u8]) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&bool> for Bound<'_, PyBool>

Compare Bound<PyBool> with &bool.

fn eq(&self, other: &&bool) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&f32> for Bound<'_, PyFloat>

fn eq(&self, other: &&f32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&f64> for Bound<'_, PyFloat>

fn eq(&self, other: &&f64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for Bound<'_, PyString>

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &&str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyBool>> for bool

Compare bool with Bound<PyBool>

fn eq(&self, other: &Bound<'_, PyBool>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyBool>> for &bool

Compare &bool with Bound<PyBool>

fn eq(&self, other: &Bound<'_, PyBool>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyBytes>> for [u8]

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &Bound<'_, PyBytes>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyBytes>> for &[u8]

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &Bound<'_, PyBytes>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyFloat>> for f64

fn eq(&self, other: &Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyFloat>> for &f64

fn eq(&self, other: &Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyFloat>> for f32

fn eq(&self, other: &Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyFloat>> for &f32

fn eq(&self, other: &Bound<'_, PyFloat>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for i8

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for u8

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for i16

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for u16

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for i32

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for u32

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for i64

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for u64

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for i128

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for u128

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for isize

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyInt>> for usize

fn eq(&self, other: &Bound<'_, PyInt>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyString>> for str

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &Bound<'_, PyString>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Bound<'_, PyString>> for &str

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &Bound<'_, PyString>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<[u8]> for Bound<'_, PyBytes>

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &[u8]) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<[u8]> for &Bound<'_, PyBytes>

Compares whether the Python bytes object is equal to the u8.

In some cases Python equality might be more appropriate; see the note on PyBytes.

fn eq(&self, other: &[u8]) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<bool> for Bound<'_, PyBool>

Compare Bound<PyBool> with bool.

fn eq(&self, other: &bool) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<bool> for &Bound<'_, PyBool>

Compare &Bound<PyBool> with bool.

fn eq(&self, other: &bool) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for Bound<'_, PyFloat>

fn eq(&self, other: &f32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for &Bound<'_, PyFloat>

fn eq(&self, other: &f32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for Bound<'_, PyFloat>

fn eq(&self, other: &f64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for &Bound<'_, PyFloat>

fn eq(&self, other: &f64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for Bound<'_, PyInt>

fn eq(&self, other: &i8) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for Bound<'_, PyInt>

fn eq(&self, other: &i16) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for Bound<'_, PyInt>

fn eq(&self, other: &i32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Bound<'_, PyInt>

fn eq(&self, other: &i64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i128> for Bound<'_, PyInt>

fn eq(&self, other: &i128) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<isize> for Bound<'_, PyInt>

fn eq(&self, other: &isize) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for Bound<'_, PyString>

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for &Bound<'_, PyString>

Compares whether the data in the Python string is equal to the given UTF8.

In some cases Python equality might be more appropriate; see the note on PyString.

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for Bound<'_, PyInt>

fn eq(&self, other: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for Bound<'_, PyInt>

fn eq(&self, other: &u16) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for Bound<'_, PyInt>

fn eq(&self, other: &u32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for Bound<'_, PyInt>

fn eq(&self, other: &u64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u128> for Bound<'_, PyInt>

fn eq(&self, other: &u128) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<usize> for Bound<'_, PyInt>

fn eq(&self, other: &usize) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny>

fn add<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self + other.

fn sub<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self - other.

fn mul<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self * other.

fn matmul<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self @ other.

fn div<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self / other.

fn floor_div<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self // other.

fn rem<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self % other.

fn lshift<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self << other.

fn rshift<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self >> other.

fn bitand<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self & other.

fn bitor<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self | other.

fn bitxor<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes self ^ other.

fn divmod<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Computes divmod(self, other).

fn pow<O1, O2>(&self, other: O1, modulus: O2) -> PyResult<Bound<'py, PyAny>>

where O1: IntoPyObject<'py>, O2: IntoPyObject<'py>,

Computes self ** other % modulus (pow(self, other, modulus)). py.None() may be passed for the modulus.

fn is<T: AsRef<Py<PyAny>>>(&self, other: T) -> bool

Returns whether self and other point to the same object. To compare the equality of two objects (the == operator), use eq.

fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>

where N: IntoPyObject<'py, Target = PyString>,

Determines whether this object has the given attribute.

fn getattr<N>(&self, attr_name: N) -> PyResult<Bound<'py, PyAny>>

where N: IntoPyObject<'py, Target = PyString>,

Retrieves an attribute value.

fn getattr_opt<N>(&self, attr_name: N) -> PyResult<Option<Bound<'py, PyAny>>>

where N: IntoPyObject<'py, Target = PyString>,

Retrieves an attribute value optionally.

fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>

where N: IntoPyObject<'py, Target = PyString>, V: IntoPyObject<'py>,

Sets an attribute value.

fn delattr<N>(&self, attr_name: N) -> PyResult<()>

where N: IntoPyObject<'py, Target = PyString>,

Deletes an attribute.

fn compare<O>(&self, other: O) -> PyResult<Ordering>

where O: IntoPyObject<'py>,

Returns an Ordering between self and other.

fn rich_compare<O>( &self, other: O, compare_op: CompareOp, ) -> PyResult<Bound<'py, PyAny>>

where O: IntoPyObject<'py>,

Tests whether two Python objects obey a given CompareOp.

fn neg(&self) -> PyResult<Bound<'py, PyAny>>

Computes the negative of self.

fn pos(&self) -> PyResult<Bound<'py, PyAny>>

Computes the positive of self.

fn abs(&self) -> PyResult<Bound<'py, PyAny>>

Computes the absolute of self.

fn bitnot(&self) -> PyResult<Bound<'py, PyAny>>

Computes ~self.

fn lt<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is less than another.

fn le<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is less than or equal to another.

fn eq<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is equal to another.

fn ne<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is not equal to another.

fn gt<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is greater than another.

fn ge<O>(&self, other: O) -> PyResult<bool>

where O: IntoPyObject<'py>,

Tests whether this object is greater than or equal to another.

fn is_callable(&self) -> bool

Determines whether this object appears callable.

fn call<A>( &self, args: A, kwargs: Option<&Bound<'py, PyDict>>, ) -> PyResult<Bound<'py, PyAny>>

where A: PyCallArgs<'py>,

Calls the object.

fn call0(&self) -> PyResult<Bound<'py, PyAny>>

Calls the object without arguments.

fn call1<A>(&self, args: A) -> PyResult<Bound<'py, PyAny>>

where A: PyCallArgs<'py>,

Calls the object with only positional arguments.

fn call_method<N, A>( &self, name: N, args: A, kwargs: Option<&Bound<'py, PyDict>>, ) -> PyResult<Bound<'py, PyAny>>

where N: IntoPyObject<'py, Target = PyString>, A: PyCallArgs<'py>,

Calls a method on the object.

fn call_method0<N>(&self, name: N) -> PyResult<Bound<'py, PyAny>>

where N: IntoPyObject<'py, Target = PyString>,

Calls a method on the object without arguments.

fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<Bound<'py, PyAny>>

where N: IntoPyObject<'py, Target = PyString>, A: PyCallArgs<'py>,

Calls a method on the object with only positional arguments.

fn is_truthy(&self) -> PyResult<bool>

Returns whether the object is considered to be true.

fn is_none(&self) -> bool

Returns whether the object is considered to be None.

fn is_empty(&self) -> PyResult<bool>

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

fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>

where K: IntoPyObject<'py>,

Gets an item from the collection.

fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>

where K: IntoPyObject<'py>, V: IntoPyObject<'py>,

Sets a collection item value.

fn del_item<K>(&self, key: K) -> PyResult<()>

where K: IntoPyObject<'py>,

Deletes an item from the collection.

fn try_iter(&self) -> PyResult<Bound<'py, PyIterator>>

Takes an object and returns an iterator for it. Returns an error if the object is not iterable.

fn get_type(&self) -> Bound<'py, PyType>

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

fn get_type_ptr(&self) -> *mut PyTypeObject

Returns the Python type pointer for this object.

fn extract<'a, T>(&'a self) -> Result<T, T::Error>

where T: FromPyObject<'a, 'py>,

Extracts some type from the Python object.

fn get_refcnt(&self) -> isize

👎Deprecated since 0.29.0:

use pyo3::ffi::Py_REFCNT(obj.as_ptr()) instead

Returns the reference count for the Python object.

fn repr(&self) -> PyResult<Bound<'py, PyString>>

Computes the “repr” representation of self.

fn str(&self) -> PyResult<Bound<'py, PyString>>

Computes the “str” representation of self.

fn hash(&self) -> PyResult<isize>

Retrieves the hash code of self.

fn len(&self) -> PyResult<usize>

Returns the length of the sequence or mapping.

fn dir(&self) -> PyResult<Bound<'py, PyList>>

Returns the list of attributes of this object.

fn is_instance(&self, ty: &Bound<'py, PyAny>) -> PyResult<bool>

Checks whether this object is an instance of type ty.

fn is_exact_instance(&self, ty: &Bound<'py, PyAny>) -> bool

Checks whether this object is an instance of exactly type ty (not a subclass).

fn is_instance_of<T: PyTypeCheck>(&self) -> bool

Checks whether this object is an instance of type T.

fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool

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

fn contains<V>(&self, value: V) -> PyResult<bool>

where V: IntoPyObject<'py>,

Determines if self contains value.

fn py_super(&self) -> PyResult<Bound<'py, PySuper>>

Return a proxy object that delegates method calls to a parent or sibling class of type.

impl<'py> PyBoolMethods<'py> for Bound<'py, PyBool>

fn is_true(&self) -> bool

Gets whether this boolean is true.

impl<'py> PyByteArrayMethods<'py> for Bound<'py, PyByteArray>

fn len(&self) -> usize

Gets the length of the bytearray.

fn is_empty(&self) -> bool

Checks if the bytearray is empty.

fn data(&self) -> *mut u8

Gets the start of the buffer containing the contents of the bytearray.

unsafe fn as_bytes(&self) -> &[u8]

Extracts a slice of the ByteArray’s entire buffer.

unsafe fn as_bytes_mut(&self) -> &mut [u8]

Extracts a mutable slice of the ByteArray’s entire buffer.

fn to_vec(&self) -> Vec<u8>

Copies the contents of the bytearray to a Rust vector.

fn resize(&self, len: usize) -> PyResult<()>

Resizes the bytearray object to the new length len.

impl<'py> PyBytesMethods<'py> for Bound<'py, PyBytes>

fn as_bytes(&self) -> &[u8]

Gets the Python string as a byte slice.

impl<'py> PyCallArgs<'py> for Bound<'py, PyTuple>

fn call( self, function: Borrowed<'_, 'py, PyAny>, kwargs: Borrowed<'_, 'py, PyDict>, token: Token, ) -> PyResult<Bound<'py, PyAny>>

fn call_positional( self, function: Borrowed<'_, 'py, PyAny>, token: Token, ) -> PyResult<Bound<'py, PyAny>>

#[doc(hidden)]

fn call_method_positional( self, object: Borrowed<'_, 'py, PyAny>, method_name: Borrowed<'_, 'py, PyString>, _: Token, ) -> PyResult<Bound<'py, PyAny>>

impl<'py> PyCallArgs<'py> for &Bound<'py, PyTuple>

fn call( self, function: Borrowed<'_, 'py, PyAny>, kwargs: Borrowed<'_, 'py, PyDict>, token: Token, ) -> PyResult<Bound<'py, PyAny>>

fn call_positional( self, function: Borrowed<'_, 'py, PyAny>, token: Token, ) -> PyResult<Bound<'py, PyAny>>

#[doc(hidden)]

fn call_method_positional( self, object: Borrowed<'_, 'py, PyAny>, method_name: Borrowed<'_, 'py, PyString>, _: Token, ) -> PyResult<Bound<'py, PyAny>>

impl<'py> PyCapsuleMethods<'py> for Bound<'py, PyCapsule>

fn set_context(&self, context: *mut c_void) -> PyResult<()>

Sets the context pointer in the capsule.

fn context(&self) -> PyResult<*mut c_void>

Gets the current context stored in the capsule. If there is no context, the pointer will be null.

fn pointer_checked(&self, name: Option<&CStr>) -> PyResult<NonNull<c_void>>

Gets the raw pointer stored in this capsule.

fn is_valid_checked(&self, name: Option<&CStr>) -> bool

Checks that the capsule name matches name and that the pointer is not null.

fn name(&self) -> PyResult<Option<CapsuleName>>

Retrieves the name of this capsule, if set.

impl<'py> PyCodeMethods<'py> for Bound<'py, PyCode>

fn run( &self, globals: Option<&Bound<'py, PyDict>>, locals: Option<&Bound<'py, PyDict>>, ) -> PyResult<Bound<'py, PyAny>>

Runs code object.

impl<'py> PyComplexMethods<'py> for Bound<'py, PyComplex>

fn real(&self) -> c_double

Returns the real part of the complex number.

fn imag(&self) -> c_double

Returns the imaginary part of the complex number.

fn abs(&self) -> c_double

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

Returns |self|.

fn pow(&self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

Returns self raised to the power of other.

impl PyDateAccess for Bound<'_, PyDate>

Available on non-Py_LIMITED_API only.

fn get_year(&self) -> i32

Returns the year, as a positive int.

fn get_month(&self) -> u8

Returns the month, as an int from 1 through 12.

fn get_day(&self) -> u8

Returns the day, as an int from 1 through 31.

impl PyDateAccess for Bound<'_, PyDateTime>

Available on non-Py_LIMITED_API only.

fn get_year(&self) -> i32

Returns the year, as a positive int.

fn get_month(&self) -> u8

Returns the month, as an int from 1 through 12.

fn get_day(&self) -> u8

Returns the day, as an int from 1 through 31.

impl PyDeltaAccess for Bound<'_, PyDelta>

Available on non-Py_LIMITED_API only.

fn get_days(&self) -> i32

Returns the number of days, as an int from -999999999 to 999999999.

fn get_seconds(&self) -> i32

Returns the number of seconds, as an int from 0 through 86399.

fn get_microseconds(&self) -> i32

Returns the number of microseconds, as an int from 0 through 999999.

impl<'py> PyDictMethods<'py> for Bound<'py, PyDict>

fn copy(&self) -> PyResult<Bound<'py, PyDict>>

Returns a new dictionary that contains the same key-value pairs as self.

fn clear(&self)

Empties an existing dictionary of all key-value pairs.

fn len(&self) -> usize

Return the number of items in the dictionary.

fn is_empty(&self) -> bool

Checks if the dict is empty, i.e. len(self) == 0.

fn contains<K>(&self, key: K) -> PyResult<bool>

where K: IntoPyObject<'py>,

Determines if the dictionary contains the specified key.

fn get_item<K>(&self, key: K) -> PyResult<Option<Bound<'py, PyAny>>>

where K: IntoPyObject<'py>,

Gets an item from the dictionary.

fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>

where K: IntoPyObject<'py>, V: IntoPyObject<'py>,

Sets an item value.

fn del_item<K>(&self, key: K) -> PyResult<()>

where K: IntoPyObject<'py>,

Deletes an item.

fn keys(&self) -> Bound<'py, PyList>

Returns a list of dict keys.

fn values(&self) -> Bound<'py, PyList>

Returns a list of dict values.

fn items(&self) -> Bound<'py, PyList>

Returns a list of dict items.

fn iter(&self) -> BoundDictIterator<'py>

Returns an iterator of (key, value) pairs in this dictionary.

fn locked_for_each<F>(&self, f: F) -> PyResult<()>

where F: Fn(Bound<'py, PyAny>, Bound<'py, PyAny>) -> PyResult<()>,

Iterates over the contents of this dictionary while holding a critical section on the dict. This is useful when the GIL is disabled and the dictionary is shared between threads. It is not guaranteed that the dictionary will not be modified during iteration when the closure calls arbitrary Python code that releases the critical section held by the iterator. Otherwise, the dictionary will not be modified during iteration.

fn as_mapping(&self) -> &Bound<'py, PyMapping>

Returns self cast as a PyMapping.

fn into_mapping(self) -> Bound<'py, PyMapping>

Returns self cast as a PyMapping.

fn update(&self, other: &Bound<'_, PyMapping>) -> PyResult<()>

Update this dictionary with the key/value pairs from another.

fn update_if_missing(&self, other: &Bound<'_, PyMapping>) -> PyResult<()>

Add key/value pairs from another dictionary to this one only when they do not exist in this.

fn set_default<K, V>(&self, key: K, default_value: V) -> PyResult<bool>

where K: IntoPyObject<'py>, V: IntoPyObject<'py>,

Inserts default_value into this dictionary with a key of key if the key is not already present in the dictionary. If the key was inserted, returns Ok(true), otherwise returns Ok(false), indicating the key was already present. If an error happens, returns PyErr. This function uses PyDict_SetDefaultRef internally.

fn set_default_with_result<K, V>( &self, key: K, default_value: V, ) -> PyResult<(bool, Bound<'py, PyAny>)>

where K: IntoPyObject<'py>, V: IntoPyObject<'py>,

Inserts default_value into this dictionary with a key of key if the key is not already present in the dictionary. If the key was inserted, returns Ok((true, result)), otherwise returns Ok((false, result)) where result is the value associated with key after this function finishes. If an error happens, returns PyErr. This function uses PyDict_SetDefaultRef internally.

impl<'py> PyFloatMethods<'py> for Bound<'py, PyFloat>

fn value(&self) -> c_double

Gets the value of this float.

impl<'py> PyFrameMethods<'py> for Bound<'py, PyFrame>

Available on non-GraalPy and non-Py_LIMITED_API and non-PyPy only.

fn line_number(&self) -> i32

Returns the line number of the current instruction in the frame.

fn outer(&self) -> Option<Bound<'py, PyFrame>>

Available on Py_3_9 only.

Gets this frame’s next outer frame if there is one

fn code(&self) -> Bound<'py, PyCode>

Available on Py_3_10, or Py_3_9 and non-Py_LIMITED_API only.

Gets the frame code

fn var(&self, name: &CStr) -> PyResult<Bound<'py, PyAny>>

Available on Py_3_12 only.

Gets the variable name of this frame.

fn builtins(&self) -> Bound<'py, PyDict>

Available on Py_3_11 only.

Gets this frame’s f_builtins attribute

fn globals(&self) -> Bound<'py, PyDict>

Available on Py_3_11 only.

Gets this frame’s f_globals attribute

fn locals(&self) -> Bound<'py, PyAny>

Available on Py_3_11 only.

Gets this frame’s f_locals attribute

impl<'py> PyFrozenSetMethods<'py> for Bound<'py, PyFrozenSet>

fn len(&self) -> usize

Returns the number of items in the set.

fn contains<K>(&self, key: K) -> PyResult<bool>

where K: IntoPyObject<'py>,

Determines if the set contains the specified key.

fn iter(&self) -> BoundFrozenSetIterator<'py>

Returns an iterator of values in this set.

fn is_empty(&self) -> bool

Checks if set is empty.

impl<'a, 'holder, 'py, T> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder Bound<'py, T>

where T: PyTypeCheck + 'a + 'py,

const INPUT_TYPE: PyStaticExpr = T::TYPE_HINT

Available on crate feature experimental-inspect only.

Provides the type hint information for which Python types are allowed.

type Holder = Option<Borrowed<'a, 'py, T>>

type Error = CastError<'a, 'py>

fn extract( obj: Borrowed<'a, 'py, PyAny>, holder: &'holder mut Self::Holder, ) -> Result<Self, Self::Error>

impl<'py> PyListMethods<'py> for Bound<'py, PyList>

fn len(&self) -> usize

Returns the length of the list.

fn is_empty(&self) -> bool

Checks if the list is empty.

fn as_sequence(&self) -> &Bound<'py, PySequence>

Returns self cast as a PySequence.

fn into_sequence(self) -> Bound<'py, PySequence>

Returns self cast as a PySequence.

fn get_item(&self, index: usize) -> PyResult<Bound<'py, PyAny>>

Gets the list item at the specified index.

Example

use pyo3::{prelude::*, types::PyList};
Python::attach(|py| {
    let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
    let obj = list.get_item(0);
    assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 2);
});

fn get_slice(&self, low: usize, high: usize) -> Bound<'py, PyList>

Takes the slice self[low:high] and returns it as a new list.

Indices must be nonnegative, and out-of-range indices are clipped to self.len().

fn set_item<I>(&self, index: usize, item: I) -> PyResult<()>

where I: IntoPyObject<'py>,

Sets the item at the specified index.

Raises IndexError if the index is out of range.

fn del_item(&self, index: usize) -> PyResult<()>

Deletes the indexth element of self.

This is equivalent to the Python statement del self[i].

fn set_slice( &self, low: usize, high: usize, seq: &Bound<'_, PyAny>, ) -> PyResult<()>

Assigns the sequence seq to the slice of self from low to high.

This is equivalent to the Python statement self[low:high] = v.

fn del_slice(&self, low: usize, high: usize) -> PyResult<()>

Deletes the slice from low to high from self.

This is equivalent to the Python statement del self[low:high].

fn append<I>(&self, item: I) -> PyResult<()>

where I: IntoPyObject<'py>,

Appends an item to the list.

fn insert<I>(&self, index: usize, item: I) -> PyResult<()>

where I: IntoPyObject<'py>,

Inserts an item at the specified index.

If index >= self.len(), inserts at the end.

fn contains<V>(&self, value: V) -> PyResult<bool>

where V: IntoPyObject<'py>,

Determines if self contains value.

This is equivalent to the Python expression value in self.

fn index<V>(&self, value: V) -> PyResult<usize>

where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value.

This is equivalent to the Python expression self.index(value).

fn iter(&self) -> BoundListIterator<'py>

Returns an iterator over this list’s items.

fn locked_for_each<F>(&self, closure: F) -> PyResult<()>

where F: Fn(Bound<'py, PyAny>) -> PyResult<()>,

Iterates over a list while holding a critical section, calling a closure on each item

fn sort(&self) -> PyResult<()>

Sorts the list in-place. Equivalent to the Python expression l.sort().

fn reverse(&self) -> PyResult<()>

Reverses the list in-place. Equivalent to the Python expression l.reverse().

fn to_tuple(&self) -> Bound<'py, PyTuple>

Return a new tuple containing the contents of the list; equivalent to the Python expression tuple(list).

This method is equivalent to self.as_sequence().to_tuple() and faster than PyTuple::new(py, this_list).

unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny>

Gets the list item at the specified index without checking bounds or synchronizing access. Undefined behavior if index is out of bounds.

impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping>

fn len(&self) -> PyResult<usize>

Returns the number of objects in the mapping.

fn is_empty(&self) -> PyResult<bool>

Returns whether the mapping is empty.

fn contains<K>(&self, key: K) -> PyResult<bool>

where K: IntoPyObject<'py>,

Determines if the mapping contains the specified key.

fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>

where K: IntoPyObject<'py>,

Gets the item in self with key key.

fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>

where K: IntoPyObject<'py>, V: IntoPyObject<'py>,

Sets the item in self with key key.

fn del_item<K>(&self, key: K) -> PyResult<()>

where K: IntoPyObject<'py>,

Deletes the item with key key.

fn keys(&self) -> PyResult<Bound<'py, PyList>>

Returns a list containing all keys in the mapping.

fn values(&self) -> PyResult<Bound<'py, PyList>>

Returns a list containing all values in the mapping.

fn items(&self) -> PyResult<Bound<'py, PyList>>

Returns a list of all (key, value) pairs in the mapping.

impl<'py, 'a> PyMappingProxyMethods<'py, 'a> for Bound<'py, PyMappingProxy>

fn is_empty(&self) -> PyResult<bool>

Checks if the mappingproxy is empty, i.e. len(self) == 0.

fn keys(&self) -> PyResult<Bound<'py, PyList>>

Returns a list containing all keys in the mapping.

fn values(&self) -> PyResult<Bound<'py, PyList>>

Returns a list containing all values in the mapping.

fn items(&self) -> PyResult<Bound<'py, PyList>>

Returns a list of tuples of all (key, value) pairs in the mapping.

fn as_mapping(&self) -> &Bound<'py, PyMapping>

Returns self cast as a PyMapping.

fn try_iter(&'a self) -> PyResult<BoundMappingProxyIterator<'py, 'a>>

Takes an object and returns an iterator for it. Returns an error if the object is not iterable.

impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule>

fn dict(&self) -> Bound<'py, PyDict>

Returns the module’s __dict__ attribute, which contains the module’s symbol table.

fn index(&self) -> PyResult<Bound<'py, PyList>>

Returns the index (the __all__ attribute) of the module, creating one if needed.

fn name(&self) -> PyResult<Bound<'py, PyString>>

Returns the name (the __name__ attribute) of the module.

fn filename(&self) -> PyResult<Bound<'py, PyString>>

Returns the filename (the __file__ attribute) of the module.

fn add<N, V>(&self, name: N, value: V) -> PyResult<()>

where N: IntoPyObject<'py, Target = PyString>, V: IntoPyObject<'py>,

Adds an attribute to the module.

fn add_class<T>(&self) -> PyResult<()>

where T: PyClass,

Adds a new class to the module.

fn add_wrapped<T>(&self, wrapper: &impl Fn(Python<'py>) -> T) -> PyResult<()>

where T: IntoPyCallbackOutput<'py, Py<PyAny>>,

Adds a function or a (sub)module to a module, using the functions name as name.

fn add_submodule(&self, module: &Bound<'_, PyModule>) -> PyResult<()>

Adds a submodule to a module.

fn add_function(&self, fun: Bound<'_, PyCFunction>) -> PyResult<()>

Add a function to a module.

fn gil_used(&self, gil_used: bool) -> PyResult<()>

Declare whether or not this module supports running with the GIL disabled

impl<'py> PyRangeMethods<'py> for Bound<'py, PyRange>

fn start(&self) -> PyResult<isize>

Returns the start of the range.

fn stop(&self) -> PyResult<isize>

Returns the exclusive end of the range.

fn step(&self) -> PyResult<isize>

Returns the step of the range.

impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence>

fn len(&self) -> PyResult<usize>

Returns the number of objects in sequence.

fn is_empty(&self) -> PyResult<bool>

Returns whether the sequence is empty.

fn concat( &self, other: &Bound<'_, PySequence>, ) -> PyResult<Bound<'py, PySequence>>

Returns the concatenation of self and other.

fn repeat(&self, count: usize) -> PyResult<Bound<'py, PySequence>>

Returns the result of repeating a sequence object count times.

fn in_place_concat( &self, other: &Bound<'_, PySequence>, ) -> PyResult<Bound<'py, PySequence>>

Concatenates self and other, in place if possible.

fn in_place_repeat(&self, count: usize) -> PyResult<Bound<'py, PySequence>>

Repeats the sequence object count times and updates self, if possible.

fn get_item(&self, index: usize) -> PyResult<Bound<'py, PyAny>>

Returns the indexth element of the Sequence.

fn get_slice( &self, begin: usize, end: usize, ) -> PyResult<Bound<'py, PySequence>>

Returns the slice of sequence object between begin and end.

fn set_item<I>(&self, i: usize, item: I) -> PyResult<()>

where I: IntoPyObject<'py>,

Assigns object item to the ith element of self.

fn del_item(&self, i: usize) -> PyResult<()>

Deletes the ith element of self.

fn set_slice(&self, i1: usize, i2: usize, v: &Bound<'_, PyAny>) -> PyResult<()>

Assigns the sequence v to the slice of self from i1 to i2.

fn del_slice(&self, i1: usize, i2: usize) -> PyResult<()>

Deletes the slice from i1 to i2 from self.

fn count<V>(&self, value: V) -> PyResult<usize>

where V: IntoPyObject<'py>,

Available on non-PyPy only.

Returns the number of occurrences of value in self, that is, return the number of keys for which self[key] == value.

fn contains<V>(&self, value: V) -> PyResult<bool>

where V: IntoPyObject<'py>,

Determines if self contains value.

fn index<V>(&self, value: V) -> PyResult<usize>

where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value.

fn to_list(&self) -> PyResult<Bound<'py, PyList>>

Returns a fresh list based on the Sequence.

fn to_tuple(&self) -> PyResult<Bound<'py, PyTuple>>

Returns a fresh tuple based on the Sequence.

impl<'py> PySetMethods<'py> for Bound<'py, PySet>

fn clear(&self)

Removes all elements from the set.

fn len(&self) -> usize

Returns the number of items in the set.

fn contains<K>(&self, key: K) -> PyResult<bool>

where K: IntoPyObject<'py>,

Determines if the set contains the specified key.

fn discard<K>(&self, key: K) -> PyResult<bool>

where K: IntoPyObject<'py>,

Removes the element from the set if it is present.

fn add<K>(&self, key: K) -> PyResult<()>

where K: IntoPyObject<'py>,

Adds an element to the set.

fn pop(&self) -> Option<Bound<'py, PyAny>>

Removes and returns an arbitrary element from the set.

fn iter(&self) -> BoundSetIterator<'py>

Returns an iterator of values in this set.

fn is_empty(&self) -> bool

Checks if set is empty.

impl<'py> PySliceMethods<'py> for Bound<'py, PySlice>

fn indices(&self, length: isize) -> PyResult<PySliceIndices>

Retrieves the start, stop, and step indices from the slice object, assuming a sequence of length length, and stores the length of the slice in its slicelength member.

impl<'py> PyStringMethods<'py> for Bound<'py, PyString>

fn to_str(&self) -> PyResult<&str>

Available on Py_3_10 or non-Py_LIMITED_API only.

Gets the Python string as a Rust UTF-8 string slice.

fn to_cow(&self) -> PyResult<Cow<'_, str>>

Converts the PyString into a Rust string, avoiding copying when possible.

fn to_string_lossy(&self) -> Cow<'_, str>

Converts the PyString into a Rust string.

fn encode_utf8(&self) -> PyResult<Bound<'py, PyBytes>>

Encodes this string as a Python bytes object, using UTF-8 encoding.

unsafe fn data(&self) -> PyResult<PyStringData<'_>>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

Obtains the raw data backing the Python string.

impl PyTimeAccess for Bound<'_, PyDateTime>

Available on non-Py_LIMITED_API only.

fn get_hour(&self) -> u8

Returns the hour, as an int from 0 through 23.

fn get_minute(&self) -> u8

Returns the minute, as an int from 0 through 59.

fn get_second(&self) -> u8

Returns the second, as an int from 0 through 59.

fn get_microsecond(&self) -> u32

Returns the microsecond, as an int from 0 through 999999.

fn get_fold(&self) -> bool

Returns whether this date is the later of two moments with the same representation, during a repeated interval.

impl PyTimeAccess for Bound<'_, PyTime>

Available on non-Py_LIMITED_API only.

fn get_hour(&self) -> u8

Returns the hour, as an int from 0 through 23.

fn get_minute(&self) -> u8

Returns the minute, as an int from 0 through 59.

fn get_second(&self) -> u8

Returns the second, as an int from 0 through 59.

fn get_microsecond(&self) -> u32

Returns the microsecond, as an int from 0 through 999999.

fn get_fold(&self) -> bool

Returns whether this date is the later of two moments with the same representation, during a repeated interval.

impl<'py> PyTracebackMethods<'py> for Bound<'py, PyTraceback>

fn format(&self) -> PyResult<String>

Formats the traceback as a string.

impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple>

fn len(&self) -> usize

Gets the length of the tuple.

fn is_empty(&self) -> bool

Checks if the tuple is empty.

fn as_sequence(&self) -> &Bound<'py, PySequence>

Returns self cast as a PySequence.

fn into_sequence(self) -> Bound<'py, PySequence>

Returns self cast as a PySequence.

fn get_slice(&self, low: usize, high: usize) -> Bound<'py, PyTuple>

Takes the slice self[low:high] and returns it as a new tuple.

fn get_item(&self, index: usize) -> PyResult<Bound<'py, PyAny>>

Gets the tuple item at the specified index.

fn get_borrowed_item<'a>( &'a self, index: usize, ) -> PyResult<Borrowed<'a, 'py, PyAny>>

Like get_item, but returns a borrowed object, which is a slight performance optimization by avoiding a reference count change.

unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny>

Gets the tuple item at the specified index without checking bounds. Undefined behavior if index is out of bounds.

unsafe fn get_borrowed_item_unchecked<'a>( &'a self, index: usize, ) -> Borrowed<'a, 'py, PyAny>

Like get_item_unchecked, but returns a borrowed object, which is a slight performance optimization by avoiding a reference count change.

fn as_slice(&self) -> &[Bound<'py, PyAny>]

Available on neither GraalPy nor Py_LIMITED_API.

Returns self as a slice of objects.

fn contains<V>(&self, value: V) -> PyResult<bool>

where V: IntoPyObject<'py>,

Determines if self contains value.

fn index<V>(&self, value: V) -> PyResult<usize>

where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value.

fn iter(&self) -> BoundTupleIterator<'py>

Returns an iterator over the tuple items.

fn iter_borrowed<'a>(&'a self) -> BorrowedTupleIterator<'a, 'py>

Like iter, but produces an iterator which returns borrowed objects, which is a slight performance optimization by avoiding a reference count changes.

fn to_list(&self) -> Bound<'py, PyList>

Return a new list containing the contents of this tuple; equivalent to the Python expression list(tuple).

impl<'py> PyTypeMethods<'py> for Bound<'py, PyType>

fn as_type_ptr(&self) -> *mut PyTypeObject

Retrieves the underlying FFI pointer associated with this Python object.

fn name(&self) -> PyResult<Bound<'py, PyString>>

Gets the name of the PyType.

fn qualname(&self) -> PyResult<Bound<'py, PyString>>

Gets the qualified name of the PyType.

fn module(&self) -> PyResult<Bound<'py, PyString>>

Gets the name of the module defining the PyType.

fn fully_qualified_name(&self) -> PyResult<Bound<'py, PyString>>

Gets the fully qualified name of the PyType.

fn is_subclass(&self, other: &Bound<'_, PyAny>) -> PyResult<bool>

Checks whether self is a subclass of other.

Equivalent to the Python expression issubclass(self, other).

fn is_subclass_of<T>(&self) -> PyResult<bool>

where T: PyTypeInfo,

Checks whether self is a subclass of type T.

Equivalent to the Python expression issubclass(self, T), if the type T is known at compile time.

fn mro(&self) -> Bound<'py, PyTuple>

Return the method resolution order for this type.

fn bases(&self) -> Bound<'py, PyTuple>

Return Python bases

impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyDateTime>

fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>>

Returns the tzinfo (which may be None).

impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyTime>

fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>>

Returns the tzinfo (which may be None).

impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakref>

fn upgrade(&self) -> Option<Bound<'py, PyAny>>

Upgrade the weakref to a Bound PyAny reference to the target object if possible.

fn upgrade_as<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeCheck,

Upgrade the weakref to a direct Bound object reference.

unsafe fn upgrade_as_unchecked<T>(&self) -> Option<Bound<'py, T>>

Upgrade the weakref to a direct Bound object reference unchecked. The type of the recovered object is not checked before casting, this could lead to unexpected behavior. Use only when absolutely certain the type can be guaranteed. The weakref may still return None.

fn upgrade_as_exact<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeInfo,

Upgrade the weakref to a exact direct Bound object reference.

impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakrefProxy>

fn upgrade(&self) -> Option<Bound<'py, PyAny>>

Upgrade the weakref to a Bound PyAny reference to the target object if possible.

fn upgrade_as<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeCheck,

Upgrade the weakref to a direct Bound object reference.

unsafe fn upgrade_as_unchecked<T>(&self) -> Option<Bound<'py, T>>

Upgrade the weakref to a direct Bound object reference unchecked. The type of the recovered object is not checked before casting, this could lead to unexpected behavior. Use only when absolutely certain the type can be guaranteed. The weakref may still return None.

fn upgrade_as_exact<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeInfo,

Upgrade the weakref to a exact direct Bound object reference.

impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakrefReference>

fn upgrade(&self) -> Option<Bound<'py, PyAny>>

Upgrade the weakref to a Bound PyAny reference to the target object if possible.

fn upgrade_as<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeCheck,

Upgrade the weakref to a direct Bound object reference.

unsafe fn upgrade_as_unchecked<T>(&self) -> Option<Bound<'py, T>>

Upgrade the weakref to a direct Bound object reference unchecked. The type of the recovered object is not checked before casting, this could lead to unexpected behavior. Use only when absolutely certain the type can be guaranteed. The weakref may still return None.

fn upgrade_as_exact<T>(&self) -> PyResult<Option<Bound<'py, T>>>

where T: PyTypeInfo,

Upgrade the weakref to a exact direct Bound object reference.

impl Sealed for Bound<'_, PyAny>

impl Sealed for Bound<'_, PyBool>

impl Sealed for Bound<'_, PyByteArray>

impl Sealed for Bound<'_, PyBytes>

impl Sealed for Bound<'_, PyCapsule>

impl Sealed for Bound<'_, PyComplex>

impl Sealed for Bound<'_, PyDict>

impl Sealed for Bound<'_, PyFloat>

impl Sealed for Bound<'_, PyFrozenSet>

impl Sealed for Bound<'_, PyList>

impl Sealed for Bound<'_, PyMapping>

impl Sealed for Bound<'_, PyMappingProxy>

impl Sealed for Bound<'_, PyModule>

impl Sealed for Bound<'_, PyRange>

impl Sealed for Bound<'_, PySequence>

impl Sealed for Bound<'_, PySet>

impl Sealed for Bound<'_, PySlice>

impl Sealed for Bound<'_, PyString>

impl Sealed for Bound<'_, PyTraceback>

impl Sealed for Bound<'_, PyFrame>

Available on non-GraalPy and non-Py_LIMITED_API and non-PyPy only.

impl Sealed for Bound<'_, PyTuple>

impl Sealed for Bound<'_, PyType>

impl Sealed for Bound<'_, PyWeakref>

impl Sealed for Bound<'_, PyWeakrefProxy>

impl Sealed for Bound<'_, PyWeakrefReference>

impl<'py> Sealed for Bound<'py, PyModule>

impl<'py> Sealed for &Bound<'py, PyModule>

impl Sealed for Bound<'_, PyTuple>

impl Sealed for &Bound<'_, PyTuple>

impl<T> Sealed for Bound<'_, T>

impl<'py, T: PyTypeCheck + 'py> Sealed<false> for &Bound<'py, T>

impl<'py> Sub for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn sub(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the - operation.

impl<'py> Sub for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn sub(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the - operation.

impl<'py> Sub<&Bound<'py, PyComplex>> for Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn sub(self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the - operation.

impl<'py> Sub<Bound<'py, PyComplex>> for &Bound<'py, PyComplex>

Available on neither GraalPy nor Py_LIMITED_API nor PyPy.

type Output = Bound<'py, PyComplex>

The resulting type after applying the - operator.

fn sub(self, other: Bound<'py, PyComplex>) -> Bound<'py, PyComplex>

Performs the - operation.

impl<'a, 'py, T: PyClass> TryFrom<&'a Bound<'py, T>> for PyClassGuard<'a, T>

type Error = PyBorrowError

The type returned in the event of a conversion error.

fn try_from(value: &'a Bound<'py, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, 'py, T: PyClass<Frozen = False>> TryFrom<&'a Bound<'py, T>> for PyClassGuardMut<'a, T>

type Error = PyBorrowMutError

The type returned in the event of a conversion error.

fn try_from(value: &'a Bound<'py, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'py> TryFrom<&Bound<'py, PyAny>> for Bound<'py, PyByteArray>

fn try_from(value: &Bound<'py, PyAny>) -> Result<Self, Self::Error>

Creates a new Python bytearray object from another Python object that implements the buffer protocol.

type Error = PyErr

The type returned in the event of a conversion error.

impl<'py> TryFrom<&Bound<'py, PyAny>> for Bound<'py, PyMemoryView>

fn try_from(value: &Bound<'py, PyAny>) -> Result<Self, Self::Error>

Creates a new Python memoryview object from another Python object that implements the buffer protocol.

type Error = PyErr

The type returned in the event of a conversion error.

impl<'py, T: PyClass> TryFrom<&Bound<'py, T>> for PyRef<'py, T>

type Error = PyBorrowError

The type returned in the event of a conversion error.

fn try_from(value: &Bound<'py, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'py, T: PyClass<Frozen = False>> TryFrom<&Bound<'py, T>> for PyRefMut<'py, T>

type Error = PyBorrowMutError

The type returned in the event of a conversion error.

fn try_from(value: &Bound<'py, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Bound<'_, PyString>> for PyBackedStr

type Error = PyErr

The type returned in the event of a conversion error.

fn try_from(py_string: Bound<'_, PyString>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'py> TryFrom<Bound<'py, PyRange>> for Bound<'py, PySlice>

type Error = PyErr

The type returned in the event of a conversion error.

fn try_from(range: Bound<'py, PyRange>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'py> TryFrom<PyBytesWriter<'py>> for Bound<'py, PyBytes>

type Error = PyErr

The type returned in the event of a conversion error.

fn try_from(value: PyBytesWriter<'py>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'py> TryInto<Bound<'py, PyString>> for PyUnicodeWriter<'py>

Available on Py_3_14 and non-Py_LIMITED_API only.

type Error = PyErr

The type returned in the event of a conversion error.

fn try_into(self) -> PyResult<Bound<'py, PyString>>

Performs the conversion.

impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Bound<'py, PyModule>

fn wrap_pyfunction( self, function_def: &'static PyFunctionDef, ) -> PyResult<Bound<'py, PyCFunction>>

impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for &Bound<'py, PyModule>

fn wrap_pyfunction( self, function_def: &'static PyFunctionDef, ) -> PyResult<Bound<'py, PyCFunction>>

impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Borrowed<'_, 'py, PyModule>

fn wrap_pyfunction( self, function_def: &'static PyFunctionDef, ) -> PyResult<Bound<'py, PyCFunction>>

impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for &Borrowed<'_, 'py, PyModule>

fn wrap_pyfunction( self, function_def: &'static PyFunctionDef, ) -> PyResult<Bound<'py, PyCFunction>>

impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Python<'py>

fn wrap_pyfunction( self, function_def: &'static PyFunctionDef, ) -> PyResult<Bound<'py, PyCFunction>>