compio::tls::py_dynamic_openssl::pyo3::prelude

Struct Bound

pub struct Bound<'py, T>(/* private fields */);

Available on crate feature tls only.

Expand description

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.

Implementations§

§

impl<'py, T> Bound<'py, T>
where T: PyClass,

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

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(&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(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(&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(self) -> Result<Bound<'py, U>, CastIntoError<'py>>
where U: PyTypeInfo,

Like cast_exact but takes ownership of self.

pub unsafe fn cast_unchecked(&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(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, ) -> Bound<'py, PyAny>

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<Bound<'py, PyAny>>

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, ) -> Result<Bound<'py, PyAny>, PyErr>

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 unsafe fn from_borrowed_ptr( py: Python<'py>, ptr: *mut PyObject, ) -> Bound<'py, PyAny>

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<Bound<'py, PyAny>>

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, ) -> Result<Bound<'py, PyAny>, PyErr>

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

§

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 std::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 as PyClassImpl>::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 obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
    assert!(obj.as_super().pyrepr().is_ok());
})

pub fn into_super(self) -> Bound<'py, <T as PyClassImpl>::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 obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
    assert!(obj.into_super().pyrepr().is_ok());
})

§

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, PyIterator>

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

Available on non-PyPy and Py_3_10 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.

§

fn clone(&self) -> Bound<'_, T>

Returns a duplicate of the value. Read more

Creates an iterator from a value. Read more

§

The type returned in the event of a conversion error.

§

fn into_pyobject( self, _py: Python<'py>, ) -> Result<<&'a Bound<'py, T> as IntoPyObject<'py>>::Output, <&'a Bound<'py, T> as IntoPyObject<'py>>::Error>

Performs the conversion.

§

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

§

type Target = T

The Python output type

§

1.0.0 · Source§

fn count(self) -> usize
where Self: Sized,

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

1.0.0 · Source§

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

Consumes the iterator, returning the last element. Read more

Source §

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

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

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)

fn fuse(self) -> Fuse<Self>
where Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · Source§

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. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

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

1.0.0 · Source§

fn collect(self) -> B
where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection. Read more

Source §

fn try_collect( &mut self, ) -> <<Self::Item as Try>::Residual as Residual>::TryType
where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual, 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. Read more

Source §

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. Read more

1.0.0 · Source§

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. Read more

Source §

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where T: 'a, Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool,

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

Reorders the elements of this iterator in-place according to the given predicate, such that all those that return true precede all those that return false. Returns the number of true elements found. Read more

Source §

fn is_partitioned(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. Read more

1.27.0 · Source§

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. Read more

1.27.0 · Source§

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. Read more

1.0.0 · Source§

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. Read more

1.51.0 · Source§

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. Read more

Source §

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. Read more

1.0.0 · Source§

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. Read more

1.0.0 · Source§

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. Read more

1.0.0 · Source§

fn find(&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. Read more

1.30.0 · Source§

fn find_map<B, F>(&mut self, f: F) -> Option
where Self: Sized, F: FnMut(Self::Item) -> Option,

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

Source §

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)

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

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

1.11.0 · Source§

fn sum<S>(self) -> S
where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator. Read more

1.11.0 · Source§

§

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

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

1.0.0 · Source§

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 ==.

1.0.0 · Source§

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>

Gets the current context stored in the capsule. If there is no context, the pointer will be null. Read more

§

unsafe fn reference<T>(&self) -> &T

👎Deprecated since 0.27.0:

to be removed, see pointer_checked()

Determines if the set contains the specified key. Read more

§

fn iter(&self) -> BoundFrozenSetIterator<'py> ⓘ

Returns an iterator of values in this set.

§

fn is_empty(&self) -> bool

Checks if set is empty.

§

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) -> Result<Bound<'py, PyAny>, PyErr>

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);
});

§

unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny>

Available on non-Py_LIMITED_API only.

Gets the list item at the specified index. Undefined behavior on bad index. Use with caution.

Appends an item to the list.

§

fn insert(&self, index: usize, item: I) -> Result<(), PyErr>
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) -> Result<bool, PyErr>
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) -> Result<usize, PyErr>
where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value.

§

Declare whether or not this module supports running with the GIL disabled Read more

§

impl<'py> PyRangeMethods<'py> for Bound<'py, PyRange>

§

fn start(&self) -> Result<isize, PyErr>

Returns the start of the range.

§

fn stop(&self) -> Result<isize, PyErr>

Returns the exclusive end of the range.

§

fn step(&self) -> Result<isize, PyErr>

Returns the step of the range.

§

Deletes the slice from i1 to i2 from self. Read more

§

fn count<V>(&self, value: V) -> Result<usize, PyErr>
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) -> Result<bool, PyErr>
where V: IntoPyObject<'py>,

Determines if self contains value. Read more

§

fn index<V>(&self, value: V) -> Result<usize, PyErr>
where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value. Read more

§

fn to_list(&self) -> Result<Bound<'py, PyList>, PyErr>

Returns a fresh list based on the Sequence.

§

fn to_tuple(&self) -> Result<Bound<'py, PyTuple>, PyErr>

Returns a fresh tuple based on the Sequence.

§

fn to_cow(&self) -> Result<Cow<'_, str>, PyErr>

Converts the PyString into a Rust string, avoiding copying when possible. Read more

§

fn to_string_lossy(&self) -> Cow<'_, str>

Converts the PyString into a Rust string. Read more

§

fn encode_utf8(&self) -> Result<Bound<'py, PyBytes>, PyErr>

Encodes this string as a Python bytes object, using UTF-8 encoding.

§

unsafe fn data(&self) -> Result<PyStringData<'_>, PyErr>

Available on neither Py_LIMITED_API nor GraalPy nor PyPy.

Determines if self contains value. Read more

§

fn index<V>(&self, value: V) -> Result<usize, PyErr>
where V: IntoPyObject<'py>,

Returns the first index i for which self[i] == value. Read more

§

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 change.

§

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

Return a new list containing the contents of this tuple; equivalent to the Python expression list(tuple). Read more

§

Return the method resolution order for this type. Read more

Upgrade the weakref to a direct Bound object reference. Read more

§

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. Read more

§

fn upgrade_as_exact<T>(&self) -> Result<Option<Bound<'py, T>>, PyErr>
where T: PyTypeInfo,

Upgrade the weakref to a exact direct Bound object reference. Read more

§

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. Read more

§

fn upgrade_as<T>(&self) -> Result<Option<Bound<'py, T>>, PyErr>
where T: PyTypeCheck,

Upgrade the weakref to a direct Bound object reference. Read more

§

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. Read more

§

fn upgrade_as_exact<T>(&self) -> Result<Option<Bound<'py, T>>, PyErr>
where T: PyTypeInfo,

Upgrade the weakref to a exact direct Bound object reference. Read more

§

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. Read more

§

fn upgrade_as<T>(&self) -> Result<Option<Bound<'py, T>>, PyErr>
where T: PyTypeCheck,

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

§

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

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl IntoIterator for I
where I: Iterator,

Source §

type Item = ::Item

The type of the elements being iterated over.

Source §

type IntoIter = I

Which kind of iterator are we turning this into?

Converts self into an owned Python object, dropping type information and unbinding it from the 'py lifetime.

§

fn into_pyobject_or_pyerr(self, py: Python<'py>) -> Result<Self::Output, PyErr>

Converts self into a Python object. Read more

Source §

impl IteratorRandom for I
where I: Iterator,

Source §

fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
where R: Rng + ?Sized,

fn group_by<K, F>(self, key: F) -> ChunkBy<K, Self, F>
where Self: Sized, F: FnMut(&Self::Item) -> K, K: PartialEq,

👎Deprecated since 0.13.0:

Use .chunk_by() instead

Available on crate feature use_alloc only.

See .chunk_by().

§

fn chunks(self, size: usize) -> IntoChunks<Self>
where Self: Sized,

Available on crate feature use_alloc only.

Return an iterable that can chunk the iterator. Read more

§

fn tuple_windows<T>(self) -> TupleWindows<Self, T>
where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple, <T as TupleCollect>::Item: Clone,

Return an iterator over all contiguous windows producing tuples of a specific size (up to 12). Read more

§

fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>
where Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator, T: TupleCollect + Clone, <T as TupleCollect>::Item: Clone,

Return an iterator over all windows, wrapping back to the first elements when the window would otherwise exceed the length of the iterator, producing tuples of a specific size (up to 12). Read more

§

fn tuples<T>(self) -> Tuples<Self, T>
where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,

Return an iterator that groups the items in tuples of a specific size (up to 12). Read more

§

fn tee(self) -> (Tee<Self>, Tee<Self>)
where Self: Sized, Self::Item: Clone,

Available on crate feature use_alloc only.

Return an iterator adaptor that iterates over the cartesian product of the element sets of two iterators self and J. Read more

§

fn multi_cartesian_product( self, ) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>
where Self: Sized, Self::Item: IntoIterator, <Self::Item as IntoIterator>::IntoIter: Clone, <Self::Item as IntoIterator>::Item: Clone,

Available on crate feature use_alloc only.

Return an iterator adaptor that borrows from this iterator and takes items while the closure accept returns true. Read more

§

fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>
where Self: Clone, F: FnMut(&Self::Item) -> bool,

Return an iterator adaptor that borrows from a Clone-able iterator to only pick off elements while the predicate accept returns true. Read more

§

fn take_while_inclusive<F>(self, accept: F) -> TakeWhileInclusive<Self, F>
where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns an iterator adaptor that consumes elements while the given predicate is true, including the element for which the predicate first returned false. Read more

§

fn while_some<A>(self) -> WhileSome<Self>
where Self: Sized + Iterator<Item = Option<A>>,

Return an iterator adaptor that filters Option<A> iterator elements and produces A. Stops on the first None encountered. Read more

§

Available on crate feature use_std only.

Check whether all elements are unique (non equal). Read more

§

§

fn tree_reduce<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

Accumulate the elements in the iterator in a tree-like manner. Read more

§

fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

👎Deprecated since 0.13.0:

Use .tree_reduce() instead

See .tree_reduce().

§

fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile
where Self: Sized, F: FnMut(B, Self::Item) -> FoldWhile,

An iterator method that applies a function, producing a single, final value. Read more

§

fn sum1<S>(self) -> Option<S>
where Self: Sized, S: Sum<Self::Item>,

Iterate over the entire iterator and add all the elements. Read more

§

Collect all iterator elements into one of two partitions. Unlike Iterator::partition, each partition may have a distinct type. Read more

§

Converts an iterator of tuples into a tuple of containers. Read more

§

fn try_len(&self) -> Result<usize, (usize, Option<usize>)>

Returns the length of the iterator if one exists. Otherwise return self.size_hint(). Read more

§

Drops the object pointed to by the given pointer. Read more

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more

§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more

§

Bound

Struct Bound Copy item path

Implementations§

impl<'py, T> Bound<'py, T>where T: PyClass,

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

§Examples

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

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

§Example: Casting to a specific Python object

§Example: Getting a reference to a pyclass

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

§Example

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

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

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

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

§Safety

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

§Safety

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

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

§Safety

§Panics

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

§Safety

pub unsafe fn from_owned_ptr_or_err( py: Python<'py>, ptr: *mut PyObject, ) -> Result<Bound<'py, PyAny>, PyErr>

§Safety

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

§Safety

§Panics

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

§Safety

pub unsafe fn from_borrowed_ptr_or_err( py: Python<'py>, ptr: *mut PyObject, ) -> Result<Bound<'py, PyAny>, PyErr>

§Safety

impl<'py, T> Bound<'py, T>where T: PyClass,

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

§Examples

§Panics

pub fn borrow_mut(&self) -> PyRefMut<'py, T>where T: PyClass<Frozen = False>,

§Examples

§Panics

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

pub fn try_borrow_mut(&self) -> Result<PyRefMut<'py, T>, PyBorrowMutError>where T: PyClass<Frozen = False>,

pub fn get(&self) -> &Twhere T: PyClass<Frozen = True> + Sync,

§Examples

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

§Example: Calling a method defined on the Bound base type

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

§Example: Calling a method defined on the Bound base type

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

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

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

§Safety

pub fn into_ptr(self) -> *mut PyObject

§Safety

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

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

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

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

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

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

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

Trait Implementations§

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

type Output = Bound<'py, PyComplex>

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

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

type Output = Bound<'py, PyComplex>

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

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

type Output = Bound<'py, PyComplex>

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

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

type Output = Bound<'py, PyComplex>

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

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

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

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

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

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

Struct Bound

impl<'py, T> Bound<'py, T>
where T: PyClass,

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

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

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

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

impl<'py, T> Bound<'py, T>
where T: PyClass,

pub fn borrow_mut(&self) -> PyRefMut<'py, T>
where T: PyClass<Frozen = False>,

pub fn try_borrow_mut(&self) -> Result<PyRefMut<'py, T>, PyBorrowMutError>
where T: PyClass<Frozen = False>,

pub fn get(&self) -> &T
where T: PyClass<Frozen = True> + Sync,

§Example: Calling a method defined on the `Bound` base type

§Example: Calling a method defined on the `Bound` base type

impl<'py, T> Deref for Bound<'py, T>
where T: DerefToPyAny,

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

impl<'py, T> From<Bound<'py, T>> for PyErr
where T: ToPyErr,

impl<'a, 'py, T> FromPyObject<'a, 'py> for Bound<'py, T>
where T: PyTypeCheck + 'a,

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