Struct pyo3::types::PyDateTime
source · #[repr(transparent)]pub struct PyDateTime(_);
Py_LIMITED_API
only.Expand description
Bindings for datetime.datetime
Implementations§
source§impl PyDateTime
impl PyDateTime
sourcepub fn new<'p>(
py: Python<'p>,
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
microsecond: u32,
tzinfo: Option<&PyTzInfo>
) -> PyResult<&'p PyDateTime>
pub fn new<'p>(
py: Python<'p>,
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
microsecond: u32,
tzinfo: Option<&PyTzInfo>
) -> PyResult<&'p PyDateTime>
Creates a new datetime.datetime
object.
sourcepub fn new_with_fold<'p>(
py: Python<'p>,
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
microsecond: u32,
tzinfo: Option<&PyTzInfo>,
fold: bool
) -> PyResult<&'p PyDateTime>
pub fn new_with_fold<'p>(
py: Python<'p>,
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
microsecond: u32,
tzinfo: Option<&PyTzInfo>,
fold: bool
) -> PyResult<&'p PyDateTime>
Alternate constructor that takes a fold
parameter. A true
value for this parameter
signifies this this datetime is the later of two moments with the same representation,
during a repeated interval.
This typically occurs at the end of daylight savings time. Only valid if the represented time is ambiguous. See PEP 495 for more detail.
sourcepub fn from_timestamp<'p>(
py: Python<'p>,
timestamp: f64,
tzinfo: Option<&PyTzInfo>
) -> PyResult<&'p PyDateTime>
pub fn from_timestamp<'p>(
py: Python<'p>,
timestamp: f64,
tzinfo: Option<&PyTzInfo>
) -> PyResult<&'p PyDateTime>
Construct a datetime
object from a POSIX timestamp
This is equivalent to datetime.datetime.fromtimestamp
Methods from Deref<Target = PyAny>§
sourcepub fn is<T: AsPyPointer>(&self, other: &T) -> bool
pub fn is<T: AsPyPointer>(&self, other: &T) -> bool
Returns whether self
and other
point to the same object. To compare
the equality of two objects (the ==
operator), use eq
.
This is equivalent to the Python expression self is other
.
sourcepub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>where
N: IntoPy<Py<PyString>>,
pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>where
N: IntoPy<Py<PyString>>,
Determines whether this object has the given attribute.
This is equivalent to the Python expression hasattr(self, attr_name)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
sourcepub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
Retrieves an attribute value.
This is equivalent to the Python expression self.attr_name
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn version(sys: &PyModule) -> PyResult<&PyAny> {
sys.getattr(intern!(sys.py(), "version"))
}
sourcepub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
Sets an attribute value.
This is equivalent to the Python expression self.attr_name = value
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn set_answer(ob: &PyAny) -> PyResult<()> {
ob.setattr(intern!(ob.py(), "answer"), 42)
}
sourcepub fn delattr<N>(&self, attr_name: N) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
pub fn delattr<N>(&self, attr_name: N) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
Deletes an attribute.
This is equivalent to the Python statement del self.attr_name
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
sourcepub fn compare<O>(&self, other: O) -> PyResult<Ordering>where
O: ToPyObject,
pub fn compare<O>(&self, other: O) -> PyResult<Ordering>where
O: ToPyObject,
Returns an Ordering
between self
and other
.
This is equivalent to the following Python code:
if self == other:
return Equal
elif a < b:
return Less
elif a > b:
return Greater
else:
raise TypeError("PyAny::compare(): All comparisons returned false")
Examples
use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::cmp::Ordering;
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyFloat::new(py, 42_f64);
assert_eq!(a.compare(b)?, Ordering::Less);
Ok(())
})?;
It will return PyErr
for values that cannot be compared:
use pyo3::prelude::*;
use pyo3::types::{PyFloat, PyString};
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyString::new(py, "zero");
assert!(a.compare(b).is_err());
Ok(())
})?;
sourcepub fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<&PyAny>where
O: ToPyObject,
pub fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<&PyAny>where
O: ToPyObject,
Tests whether two Python objects obey a given CompareOp
.
lt
, le
, eq
, ne
,
gt
and ge
are the specialized versions
of this function.
Depending on the value of compare_op
, this is equivalent to one of the
following Python expressions:
compare_op | Python expression |
---|---|
CompareOp::Eq | self == other |
CompareOp::Ne | self != other |
CompareOp::Lt | self < other |
CompareOp::Le | self <= other |
CompareOp::Gt | self > other |
CompareOp::Ge | self >= other |
Examples
use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;
Python::with_gil(|py| -> PyResult<()> {
let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
assert!(a.rich_compare(b, CompareOp::Le)?.is_true()?);
Ok(())
})?;
sourcepub fn lt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn lt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is less than another.
This is equivalent to the Python expression self < other
.
sourcepub fn le<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn le<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is less than or equal to another.
This is equivalent to the Python expression self <= other
.
sourcepub fn eq<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn eq<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is equal to another.
This is equivalent to the Python expression self == other
.
sourcepub fn ne<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn ne<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is not equal to another.
This is equivalent to the Python expression self != other
.
sourcepub fn gt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn gt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is greater than another.
This is equivalent to the Python expression self > other
.
sourcepub fn ge<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn ge<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is greater than or equal to another.
This is equivalent to the Python expression self >= other
.
sourcepub fn is_callable(&self) -> bool
pub fn is_callable(&self) -> bool
Determines whether this object appears callable.
This is equivalent to Python’s callable()
function.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let builtins = PyModule::import(py, "builtins")?;
let print = builtins.getattr("print")?;
assert!(print.is_callable());
Ok(())
})?;
This is equivalent to the Python statement assert callable(print)
.
Note that unless an API needs to distinguish between callable and non-callable objects, there is no point in checking for callability. Instead, it is better to just do the call and handle potential exceptions.
sourcepub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
Calls the object.
This is equivalent to the Python expression self(*args, **kwargs)
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = fun.call(args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call0(&self) -> PyResult<&PyAny>
pub fn call0(&self) -> PyResult<&PyAny>
Calls the object without arguments.
This is equivalent to the Python expression self()
.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let module = PyModule::import(py, "builtins")?;
let help = module.getattr("help")?;
help.call0()?;
Ok(())
})?;
This is equivalent to the Python expression help()
.
sourcepub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
Calls the object with only positional arguments.
This is equivalent to the Python expression self(*args)
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let result = fun.call1(args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object.
This is equivalent to the Python expression self.name(*args, **kwargs)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = instance.call_method("method", args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
Calls a method on the object without arguments.
This is equivalent to the Python expression self.name()
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ()
assert kwargs == {}
return "called with no arguments"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let result = instance.call_method0("method")?;
assert_eq!(result.extract::<&str>()?, "called with no arguments");
Ok(())
})
sourcepub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object with only positional arguments.
This is equivalent to the Python expression self.name(*args)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let result = instance.call_method1("method", args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn is_true(&self) -> PyResult<bool>
pub fn is_true(&self) -> PyResult<bool>
Returns whether the object is considered to be true.
This is equivalent to the Python expression bool(self)
.
sourcepub fn is_none(&self) -> bool
pub fn is_none(&self) -> bool
Returns whether the object is considered to be None.
This is equivalent to the Python expression self is None
.
sourcepub fn is_empty(&self) -> PyResult<bool>
pub fn is_empty(&self) -> PyResult<bool>
Returns true if the sequence or mapping has a length of 0.
This is equivalent to the Python expression len(self) == 0
.
sourcepub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>where
K: ToPyObject,
pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>where
K: ToPyObject,
Gets an item from the collection.
This is equivalent to the Python expression self[key]
.
sourcepub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>where
K: ToPyObject,
V: ToPyObject,
pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>where
K: ToPyObject,
V: ToPyObject,
Sets a collection item value.
This is equivalent to the Python expression self[key] = value
.
sourcepub fn del_item<K>(&self, key: K) -> PyResult<()>where
K: ToPyObject,
pub fn del_item<K>(&self, key: K) -> PyResult<()>where
K: ToPyObject,
Deletes an item from the collection.
This is equivalent to the Python expression del self[key]
.
sourcepub fn iter(&self) -> PyResult<&PyIterator>
pub fn iter(&self) -> PyResult<&PyIterator>
Takes an object and returns an iterator for it.
This is typically a new iterator but if the argument is an iterator, this returns itself.
sourcepub fn get_type_ptr(&self) -> *mut PyTypeObject
pub fn get_type_ptr(&self) -> *mut PyTypeObject
Returns the Python type pointer for this object.
sourcepub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>>where
D: PyTryFrom<'a>,
👎Deprecated since 0.18.0: use the equivalent .downcast()
pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>>where
D: PyTryFrom<'a>,
Converts this PyAny
to a concrete Python type.
sourcepub fn downcast<'p, T>(&'p self) -> Result<&'p T, PyDowncastError<'_>>where
T: PyTryFrom<'p>,
pub fn downcast<'p, T>(&'p self) -> Result<&'p T, PyDowncastError<'_>>where
T: PyTryFrom<'p>,
Converts this PyAny
to a concrete Python type.
This can cast only to native Python types, not types implemented in Rust.
Examples
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyDict, PyList};
Python::with_gil(|py| {
let dict = PyDict::new(py);
assert!(dict.is_instance_of::<PyAny>().unwrap());
let any: &PyAny = dict.as_ref();
assert!(any.downcast::<PyDict>().is_ok());
assert!(any.downcast::<PyList>().is_err());
});
sourcepub unsafe fn downcast_unchecked<'p, T>(&'p self) -> &'p Twhere
T: PyTryFrom<'p>,
pub unsafe fn downcast_unchecked<'p, T>(&'p self) -> &'p Twhere
T: PyTryFrom<'p>,
Converts this PyAny
to a concrete Python type without checking validity.
Safety
Callers must ensure that the type is valid or risk type confusion.
sourcepub fn extract<'a, D>(&'a self) -> PyResult<D>where
D: FromPyObject<'a>,
pub fn extract<'a, D>(&'a self) -> PyResult<D>where
D: FromPyObject<'a>,
Extracts some type from the Python object.
This is a wrapper function around FromPyObject::extract()
.
sourcepub fn get_refcnt(&self) -> isize
pub fn get_refcnt(&self) -> isize
Returns the reference count for the Python object.
sourcepub fn repr(&self) -> PyResult<&PyString>
pub fn repr(&self) -> PyResult<&PyString>
Computes the “repr” representation of self.
This is equivalent to the Python expression repr(self)
.
sourcepub fn str(&self) -> PyResult<&PyString>
pub fn str(&self) -> PyResult<&PyString>
Computes the “str” representation of self.
This is equivalent to the Python expression str(self)
.
sourcepub fn hash(&self) -> PyResult<isize>
pub fn hash(&self) -> PyResult<isize>
Retrieves the hash code of self.
This is equivalent to the Python expression hash(self)
.
sourcepub fn len(&self) -> PyResult<usize>
pub fn len(&self) -> PyResult<usize>
Returns the length of the sequence or mapping.
This is equivalent to the Python expression len(self)
.
sourcepub fn dir(&self) -> &PyList
pub fn dir(&self) -> &PyList
Returns the list of attributes of this object.
This is equivalent to the Python expression dir(self)
.
sourcepub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>
pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>
Checks whether this object is an instance of type ty
.
This is equivalent to the Python expression isinstance(self, ty)
.
sourcepub fn is_instance_of<T: PyTypeInfo>(&self) -> PyResult<bool>
pub fn is_instance_of<T: PyTypeInfo>(&self) -> PyResult<bool>
Checks whether this object is an instance of type T
.
This is equivalent to the Python expression isinstance(self, T)
,
if the type T
is known at compile time.
sourcepub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
pub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
Determines if self contains value
.
This is equivalent to the Python expression value in self
.
Trait Implementations§
source§impl AsPyPointer for PyDateTime
impl AsPyPointer for PyDateTime
source§impl AsRef<PyAny> for PyDateTime
impl AsRef<PyAny> for PyDateTime
source§impl Debug for PyDateTime
impl Debug for PyDateTime
source§impl Deref for PyDateTime
impl Deref for PyDateTime
source§impl Display for PyDateTime
impl Display for PyDateTime
source§impl<'a> From<&'a PyDateTime> for &'a PyAny
impl<'a> From<&'a PyDateTime> for &'a PyAny
source§fn from(ob: &'a PyDateTime) -> Self
fn from(ob: &'a PyDateTime) -> Self
source§impl From<&PyDateTime> for Py<PyDateTime>
impl From<&PyDateTime> for Py<PyDateTime>
source§fn from(other: &PyDateTime) -> Self
fn from(other: &PyDateTime) -> Self
source§impl<'py> FromPyObject<'py> for &'py PyDateTime
impl<'py> FromPyObject<'py> for &'py PyDateTime
source§impl IntoPy<Py<PyDateTime>> for &PyDateTime
impl IntoPy<Py<PyDateTime>> for &PyDateTime
source§impl PyDateAccess for PyDateTime
impl PyDateAccess for PyDateTime
source§impl PyNativeType for PyDateTime
impl PyNativeType for PyDateTime
source§impl PyTimeAccess for PyDateTime
impl PyTimeAccess for PyDateTime
source§fn get_minute(&self) -> u8
fn get_minute(&self) -> u8
source§fn get_second(&self) -> u8
fn get_second(&self) -> u8
source§fn get_microsecond(&self) -> u32
fn get_microsecond(&self) -> u32
source§impl PyTypeInfo for PyDateTime
impl PyTypeInfo for PyDateTime
§type AsRefTarget = PyDateTime
type AsRefTarget = PyDateTime
source§fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject
fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject
source§fn is_type_of(ptr: &PyAny) -> bool
fn is_type_of(ptr: &PyAny) -> bool
object
is an instance of this type or a subclass of this type.source§fn type_object(py: Python<'_>) -> &PyType
fn type_object(py: Python<'_>) -> &PyType
source§fn is_exact_type_of(object: &PyAny) -> bool
fn is_exact_type_of(object: &PyAny) -> bool
object
is an instance of this type.source§impl PyTzInfoAccess for PyDateTime
impl PyTzInfoAccess for PyDateTime
source§impl ToPyObject for PyDateTime
impl ToPyObject for PyDateTime
impl PyLayout<PyDateTime> for PyDateTime_DateTime
impl PySizedLayout<PyDateTime> for PyDateTime_DateTime
Auto Trait Implementations§
impl !RefUnwindSafe for PyDateTime
impl !Send for PyDateTime
impl !Sync for PyDateTime
impl Unpin for PyDateTime
impl UnwindSafe for PyDateTime
Blanket Implementations§
source§impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
source§unsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresource§unsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresource§unsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresource§unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresource§unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>
unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>
PyObject
. Read moresource§unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
PyObject
. Read more