Trait IntoPyObject

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 method
    fn type_output() -> TypeInfo { ... }
}

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

type Target

The Python output type

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.

type Error: Into<PyErr>

The type returned in the event of a conversion error.

Required Methods

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

Performs the conversion.

Provided Methods

fn type_output() -> TypeInfo

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.

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.

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>

fn type_output() -> TypeInfo

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,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3) 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, 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,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4) 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, 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>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5) 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, 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>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6) 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, T3, T4, T5, T6, T7> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7)

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>, &'a T7: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7) 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, T3, T4, T5, T6, T7, T8> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)

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>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8) 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, T3, T4, T5, T6, T7, T8, T9> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

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>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) 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, T3, T4, T5, T6, T7, T8, T9, T10> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

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>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>, &'a T10: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) 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, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

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>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>, &'a T10: IntoPyObject<'py>, &'a T11: IntoPyObject<'py>, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a,

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) 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, T> IntoPyObject<'py> for &'a Option<T>

where &'a T: IntoPyObject<'py>,

type Target = PyAny

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

type Error = <&'a T as IntoPyObject<'py>>::Error

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

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

where &'a T: IntoPyObject<'py>, T: 'a,

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

Turns &[u8] into PyBytes, all other Ts will be turned into a PyList

type Target = PyAny

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

type Error = PyErr

fn type_output() -> TypeInfo

impl<'a, 'py, T> IntoPyObject<'py> for &'a Vec<T>

where &'a T: IntoPyObject<'py>, T: 'a,

type Target = PyAny

type Output = Bound<'py, <&'a Vec<T> 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, T> IntoPyObject<'py> for &&'a T

where &'a T: IntoPyObject<'py>,

type Target = <&'a T as IntoPyObject<'py>>::Target

type Output = <&'a T as IntoPyObject<'py>>::Output

type Error = <&'a T as IntoPyObject<'py>>::Error

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

impl<'a, 'py, T, const N: usize> IntoPyObject<'py> for &'a [T; N]

where &'a T: IntoPyObject<'py>,

type Target = PyAny

type Output = Bound<'py, <&'a [T; N] as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &&str

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &&OsStr

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &&Path

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &Cow<'_, str>

type Target = PyString

type Output = Bound<'py, <&Cow<'_, str> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &Cow<'_, OsStr>

type Target = PyString

type Output = Bound<'py, <&Cow<'_, OsStr> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &Cow<'_, Path>

type Target = PyString

type Output = Bound<'py, <&Cow<'_, Path> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &IpAddr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &bool

type Target = PyBool

type Output = Borrowed<'py, 'py, <&bool as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &char

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &f32

type Target = PyFloat

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &f64

type Target = PyFloat

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &isize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &str

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &usize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &String

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &Ipv4Addr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ipv6Addr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Duration

type Target = PyDelta

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &OsStr

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &OsString

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &Path

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &PathBuf

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &SystemTime

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &NaiveDate

type Target = PyDate

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &NaiveDateTime

type Target = PyDateTime

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &NaiveTime

type Target = PyTime

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &FixedOffset

type Target = PyTzInfo

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Utc

type Target = PyTzInfo

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &BigInt

type Target = PyInt

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &BigUint

type Target = PyInt

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Complex<f32>

type Target = PyComplex

type Output = Bound<'py, <&Complex<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &Complex<f64>

type Target = PyComplex

type Output = Bound<'py, <&Complex<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for &Ratio<i8>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i8> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ratio<i16>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i16> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ratio<i32>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i32> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ratio<i64>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i64> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ratio<isize>

type Target = PyAny

type Output = Bound<'py, <&Ratio<isize> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Ratio<BigInt>

type Target = PyAny

type Output = Bound<'py, <&Ratio<BigInt> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &NonZeroI8

type Target = PyInt

type Output = Bound<'py, <&NonZero<i8> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI16

type Target = PyInt

type Output = Bound<'py, <&NonZero<i16> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI32

type Target = PyInt

type Output = Bound<'py, <&NonZero<i32> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI64

type Target = PyInt

type Output = Bound<'py, <&NonZero<i64> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI128

type Target = PyInt

type Output = Bound<'py, <&NonZero<i128> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroIsize

type Target = PyInt

type Output = Bound<'py, <&NonZero<isize> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU8

type Target = PyInt

type Output = Bound<'py, <&NonZero<u8> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU16

type Target = PyInt

type Output = Bound<'py, <&NonZero<u16> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU32

type Target = PyInt

type Output = Bound<'py, <&NonZero<u32> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU64

type Target = PyInt

type Output = Bound<'py, <&NonZero<u64> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU128

type Target = PyInt

type Output = Bound<'py, <&NonZero<u128> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroUsize

type Target = PyInt

type Output = Bound<'py, <&NonZero<usize> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &Duration

type Target = PyDelta

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for &Decimal

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Cow<'_, str>

type Target = PyString

type Output = Bound<'py, <Cow<'_, str> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Cow<'_, OsStr>

type Target = PyString

type Output = Bound<'py, <Cow<'_, OsStr> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for Cow<'_, Path>

type Target = PyString

type Output = Bound<'py, <Cow<'_, Path> as IntoPyObject<'py>>::Target>

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for IpAddr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for bool

type Target = PyBool

type Output = Borrowed<'py, 'py, <bool as IntoPyObject<'py>>::Target>

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for char

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for f32

type Target = PyFloat

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for f64

type Target = PyFloat

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for isize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for ()

type Target = PyTuple

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for usize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for String

type Target = PyString

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Ipv4Addr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ipv6Addr

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Duration

type Target = PyDelta

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for OsString

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for PathBuf

type Target = PyString

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for SystemTime

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for NaiveDate

type Target = PyDate

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for NaiveDateTime

type Target = PyDateTime

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for NaiveTime

type Target = PyTime

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for FixedOffset

type Target = PyTzInfo

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Utc

type Target = PyTzInfo

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for BigInt

type Target = PyInt

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for BigUint

type Target = PyInt

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Complex<f32>

type Target = PyComplex

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for Complex<f64>

type Target = PyComplex

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

type Error = Infallible

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

impl<'py> IntoPyObject<'py> for Ratio<i8>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ratio<i16>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ratio<i32>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ratio<i64>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ratio<isize>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Ratio<BigInt>

type Target = PyAny

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for NonZeroI8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroIsize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU8

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU16

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU32

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU64

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU128

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroUsize

type Target = PyInt

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

type Error = Infallible

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

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Duration

type Target = PyDelta

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

type Error = PyErr

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

impl<'py> IntoPyObject<'py> for Decimal

type Target = PyAny

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

type Error = PyErr

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

impl<'py, A> IntoPyObject<'py> for SmallVec<A>

where A: Array, A::Item: IntoPyObject<'py>,

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

Turns [SmallVec<u8>] into PyBytes, all other Ts will be turned into a PyList

type Target = PyAny

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

type Error = PyErr

fn type_output() -> TypeInfo

impl<'py, K> IntoPyObject<'py> for BTreeSet<K>

where K: IntoPyObject<'py> + Ord,

type Target = PySet

type Output = Bound<'py, <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<'py, K, H> IntoPyObject<'py> for HashSet<K, H>

where K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

type Target = PySet

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

type Error = PyErr

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

impl<'py, K, S> IntoPyObject<'py> for HashSet<K, S>

where K: IntoPyObject<'py> + Eq + Hash, S: BuildHasher + Default,

type Target = PySet

type Output = Bound<'py, <HashSet<K, S> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, K, V> IntoPyObject<'py> for BTreeMap<K, V>

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

type Target = PyDict

type Output = Bound<'py, <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<'py, K, V, H> IntoPyObject<'py> for HashMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <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<'py, K, V, H> IntoPyObject<'py> for HashMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

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

type Error = PyErr

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

impl<'py, K, V, H> IntoPyObject<'py> for IndexMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

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

type Error = PyErr

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

impl<'py, L, R> IntoPyObject<'py> for Either<L, R>

where L: IntoPyObject<'py>, R: IntoPyObject<'py>,

type Target = PyAny

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

type Error = PyErr

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

impl<'py, T0> IntoPyObject<'py> for (T0,)

where T0: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(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<'py, T0, T1> IntoPyObject<'py> for (T0, T1)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(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<'py, T0, T1, T2> IntoPyObject<'py> for (T0, T1, T2)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>,

type Target = PyTuple

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

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3> IntoPyObject<'py> for (T0, T1, T2, T3)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>,

type Target = PyTuple

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

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4> IntoPyObject<'py> for (T0, T1, T2, T3, T4)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>,

type Target = PyTuple

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

type Error = PyErr

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

fn type_output() -> TypeInfo

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

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

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

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>, T10: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>, T10: IntoPyObject<'py>, T11: IntoPyObject<'py>,

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as IntoPyObject<'py>>::Target>

type Error = PyErr

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

fn type_output() -> TypeInfo

impl<'py, T> IntoPyObject<'py> for Cow<'_, [T]>

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

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

Turns Cow<[u8]> into PyBytes, all other Ts will be turned into a PyList

type Target = PyAny

type Output = Bound<'py, <Cow<'_, [T]> as IntoPyObject<'py>>::Target>

type Error = PyErr

impl<'py, T> IntoPyObject<'py> for Option<T>

where T: IntoPyObject<'py>,

type Target = PyAny

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

type Error = <T as IntoPyObject<'py>>::Error

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

impl<'py, T> IntoPyObject<'py> for Vec<T>

where T: IntoPyObject<'py>,

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

Turns Vec<u8> into PyBytes, all other Ts will be turned into a PyList

type Target = PyAny

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

type Error = PyErr

fn type_output() -> TypeInfo

impl<'py, T, const N: usize> IntoPyObject<'py> for [T; N]

where T: IntoPyObject<'py>,

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

Turns [u8; N] into PyBytes, all other Ts will be turned into a PyList

type Target = PyAny

type Output = Bound<'py, <[T; N] as IntoPyObject<'py>>::Target>

type Error = PyErr

impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for &Cell<T>

type Target = <T as IntoPyObject<'py>>::Target

type Output = <T as IntoPyObject<'py>>::Output

type Error = <T as IntoPyObject<'py>>::Error

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

impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for Cell<T>

type Target = <T as IntoPyObject<'py>>::Target

type Output = <T as IntoPyObject<'py>>::Output

type Error = <T as IntoPyObject<'py>>::Error

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

impl<'py, Tz: TimeZone> IntoPyObject<'py> for &DateTime<Tz>

type Target = PyDateTime

type Output = Bound<'py, <&DateTime<Tz> as IntoPyObject<'py>>::Target>

type Error = PyErr

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

impl<'py, Tz: TimeZone> IntoPyObject<'py> for DateTime<Tz>

type Target = PyDateTime

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

type Error = PyErr

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

Implementors

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

type Target = T

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

type Error = Infallible

impl<'a, 'py, T> IntoPyObject<'py> for &'a Py<T>

type Target = T

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

type Error = Infallible

impl<'a, 'py, T> IntoPyObject<'py> for &Borrowed<'a, 'py, T>

type Target = T

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

type Error = Infallible

impl<'a, 'py, T> IntoPyObject<'py> for Borrowed<'a, 'py, T>

type Target = T

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

type Error = Infallible

impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &'a PyRef<'py, T>

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for &'a PyRefMut<'py, T>

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyErr

type Target = PyBaseException

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyBackedBytes

type Target = PyBytes

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyBackedStr

type Target = PyAny

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PySliceIndices

type Target = PySlice

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for Coroutine

type Target = Coroutine

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

type Error = PyErr

impl<'py> IntoPyObject<'py> for PyErr

type Target = PyBaseException

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for PyBackedBytes

type Target = PyBytes

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for PyBackedStr

type Target = PyAny

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

type Error = Infallible

impl<'py> IntoPyObject<'py> for PySliceIndices

type Target = PySlice

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

type Error = Infallible

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

type Target = T

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

type Error = Infallible

impl<'py, T> IntoPyObject<'py> for Py<T>

type Target = T

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

type Error = Infallible

impl<'py, T: PyClass> IntoPyObject<'py> for PyRef<'py, T>

type Target = T

type Output = Bound<'py, T>

type Error = Infallible

impl<'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for PyRefMut<'py, T>

type Target = T

type Output = Bound<'py, T>

type Error = Infallible