Trait IntoPyObject

Source

pub trait IntoPyObject<'py>: Sized {
    type Target;
    type Output: BoundObject<'py, Self::Target>;
    type Error: Into<PyErr>;

    // Required method
    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>;

    // Provided methods
    fn type_output() -> TypeInfo { ... }
    #[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> { ... }
    #[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> { ... }
}

Expand description

Defines a conversion from a Rust type to a Python object, which may fail.

This trait has #[derive(IntoPyObject)] to automatically implement it for simple types and #[derive(IntoPyObjectRef)] to implement the same for references.

It functions similarly to std’s TryInto trait, but requires a GIL token as an argument.

The into_pyobject method is designed for maximum flexibility and efficiency; it

allows for a concrete Python type to be returned (the Target associated type)
allows for the smart pointer containing the Python object to be either Bound<'py, Self::Target> or Borrowed<'a, 'py, Self::Target> to avoid unnecessary reference counting overhead
allows for a custom error type to be returned in the event of a conversion error to avoid unnecessarily creating a Python exception

§See also

The IntoPyObjectExt trait, which provides convenience methods for common usages of IntoPyObject which erase type information and convert errors to PyErr.

Required Associated Types§

Source

type Output: BoundObject<'py, Self::Target>

The smart pointer type to use.

This will usually be [Bound<'py, Target>], but in special cases [Borrowed<'a, 'py, Target>] can be used to minimize reference counting overhead.

Source

type Error: Into<PyErr>

The type returned in the event of a conversion error.

Required Methods§

Source

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

Performs the conversion.

Provided Methods§

Source

fn type_output() -> TypeInfo

Available on crate feature experimental-inspect only.

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

For example, Vec<u32> would return List[int]. The default implementation returns Any, which is correct for any type.

For most types, the return value for this method will be identical to that of FromPyObject::type_input. It may be different for some types, such as Dict, to allow duck-typing: functions return Dict but take Mapping as argument.

Source

#[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.

Source

#[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.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait IntoPyObjectCopy item path

§See also

Required Associated Types§

type Target

type Output: BoundObject<'py, Self::Target>

type Error: Into<PyErr>

Required Methods§

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

Provided Methods§

fn type_output() -> TypeInfo

#[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>,

#[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>,

Dyn Compatibility§

Implementations on Foreign Types§

impl<'a, 'py, A> IntoPyObject<'py> for &'a SmallVec<A>where A: Array, &'a A::Item: IntoPyObject<'py>, A::Item: 'a,

type Target = PyAny

type Output = Bound<'py, <&'a SmallVec<A> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, K> IntoPyObject<'py> for &'a BTreeSet<K>where &'a K: IntoPyObject<'py> + Ord, K: 'a,

type Target = PySet

type Output = Bound<'py, <&'a BTreeSet<K> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>where &'a K: IntoPyObject<'py> + Eq + Hash, K: 'a, H: BuildHasher,

type Target = PySet

type Output = Bound<'py, <&'a HashSet<K, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>where &'a K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

type Target = PySet

type Output = Bound<'py, <&'a HashSet<K, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'a, 'py, K, V> IntoPyObject<'py> for &'a BTreeMap<K, V>where &'a K: IntoPyObject<'py> + Eq, &'a V: IntoPyObject<'py>, K: 'a, V: 'a,

type Target = PyDict

type Output = Bound<'py, <&'a BTreeMap<K, V> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, K: 'a, V: 'a, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <&'a HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <&'a HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a IndexMap<K, V, H>where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <&'a IndexMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'a, 'py, L, R> IntoPyObject<'py> for &'a Either<L, R>where &'a L: IntoPyObject<'py>, &'a R: IntoPyObject<'py>,

type Target = PyAny

type Output = Bound<'py, <&'a Either<L, R> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'a, 'py, T0> IntoPyObject<'py> for &'a (T0,)where &'a T0: IntoPyObject<'py>, T0: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0,) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1> IntoPyObject<'py> for &'a (T0, T1)where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, T0: 'a, T1: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2> IntoPyObject<'py> for &'a (T0, T1, T2)where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2) as IntoPyObject<'py>>::Target>

type Error = PyErr

Trait IntoPyObject

#[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>,

#[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>,

impl<'a, 'py, A> IntoPyObject<'py> for &'a SmallVec<A>
where A: Array, &'a A::Item: IntoPyObject<'py>, A::Item: 'a,

impl<'a, 'py, K> IntoPyObject<'py> for &'a BTreeSet<K>
where &'a K: IntoPyObject<'py> + Ord, K: 'a,

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>
where &'a K: IntoPyObject<'py> + Eq + Hash, K: 'a, H: BuildHasher,

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>
where &'a K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

impl<'a, 'py, K, V> IntoPyObject<'py> for &'a BTreeMap<K, V>
where &'a K: IntoPyObject<'py> + Eq, &'a V: IntoPyObject<'py>, K: 'a, V: 'a,

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>
where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, K: 'a, V: 'a, H: BuildHasher,

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>
where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a IndexMap<K, V, H>
where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

impl<'a, 'py, L, R> IntoPyObject<'py> for &'a Either<L, R>
where &'a L: IntoPyObject<'py>, &'a R: IntoPyObject<'py>,

impl<'a, 'py, T0> IntoPyObject<'py> for &'a (T0,)
where &'a T0: IntoPyObject<'py>, T0: 'a,

impl<'a, 'py, T0, T1> IntoPyObject<'py> for &'a (T0, T1)
where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, T0: 'a, T1: 'a,

impl<'a, 'py, T0, T1, T2> IntoPyObject<'py> for &'a (T0, T1, T2)
where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a,

impl<'a, 'py, T0, T1, T2, T3> IntoPyObject<'py> for &'a (T0, T1, T2, T3)
where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a,

impl<'a, 'py, T0, T1, T2, T3, T4> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4)
where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a,

impl<'a, 'py, T> IntoPyObject<'py> for &'a Option<T>
where &'a T: IntoPyObject<'py>,