Trait IntoPyObject

Source

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

    const OUTPUT_TYPE: PyStaticExpr = _;
    #[doc(hidden)]
    const SEQUENCE_OUTPUT_TYPE: PyStaticExpr = _;

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

    // Provided methods
    #[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 Python<'py> 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.

Provided Associated Constants§

Source

const OUTPUT_TYPE: PyStaticExpr = _

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::INPUT_TYPE. 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)]
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

Required Associated Types§

Source

type Target

The Python output type

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

#[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 IntoPyObject Copy item path

§See also

Provided Associated Constants§

const OUTPUT_TYPE: PyStaticExpr = _

#[doc(hidden)]const SEQUENCE_OUTPUT_TYPE: PyStaticExpr = _

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§

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

const OUTPUT_TYPE: PyStaticExpr = <&[A::Item]>::OUTPUT_TYPE

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>

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

const OUTPUT_TYPE: PyStaticExpr

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>

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

const OUTPUT_TYPE: PyStaticExpr

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, H> IntoPyObject<'py> for &'a HashSet<K, H>where &'a K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

const OUTPUT_TYPE: PyStaticExpr

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,

const OUTPUT_TYPE: PyStaticExpr

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>

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,

const OUTPUT_TYPE: PyStaticExpr

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 HashMap<K, V, H>where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

const OUTPUT_TYPE: PyStaticExpr

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,

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr

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>

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

const OUTPUT_TYPE: PyStaticExpr

type Target = PyTuple

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

Trait IntoPyObject

#[doc(hidden)]
const SEQUENCE_OUTPUT_TYPE: PyStaticExpr = _

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

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

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

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

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

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

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

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