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.

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

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

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

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

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

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