Add PyRange wrapper (#5117)

* Add `PyRange` wrapper with conversions to/from `std::ops::Range`

* `IntoPyObject` for `RangeFull` `RangeFrom` `RangeTo` `RangeToInclusive`

* Remove conversions & address comments

Author: bschoenmaeckers

newsfragments/5117.added.md

@@ -0,0 +1 @@
+Add `PyRange` wrapper.

src/sealed.rs

@@ -1,7 +1,7 @@
 use crate::types::{
     PyBool, PyByteArray, PyBytes, PyCapsule, PyComplex, PyDict, PyFloat, PyFrozenSet, PyList,
-    PyMapping, PyMappingProxy, PyModule, PySequence, PySet, PySlice, PyString, PyTraceback,
-    PyTuple, PyType, PyWeakref, PyWeakrefProxy, PyWeakrefReference,
+    PyMapping, PyMappingProxy, PyModule, PyRange, PySequence, PySet, PySlice, PyString,
+    PyTraceback, PyTuple, PyType, PyWeakref, PyWeakrefProxy, PyWeakrefReference,
 };
 use crate::{ffi, Bound, PyAny, PyResult};
 
@@ -35,6 +35,7 @@ impl Sealed for Bound<'_, PyList> {}
 impl Sealed for Bound<'_, PyMapping> {}
 impl Sealed for Bound<'_, PyMappingProxy> {}
 impl Sealed for Bound<'_, PyModule> {}
+impl Sealed for Bound<'_, PyRange> {}
 impl Sealed for Bound<'_, PySequence> {}
 impl Sealed for Bound<'_, PySet> {}
 impl Sealed for Bound<'_, PySlice> {}

src/types/mod.rs

@@ -38,6 +38,7 @@ pub use self::notimplemented::PyNotImplemented;
 pub use self::num::PyInt;
 #[cfg(not(any(PyPy, GraalPy)))]
 pub use self::pysuper::PySuper;
+pub use self::range::{PyRange, PyRangeMethods};
 pub use self::sequence::{PySequence, PySequenceMethods};
 pub use self::set::{PySet, PySetMethods};
 pub use self::slice::{PySlice, PySliceIndices, PySliceMethods};
@@ -246,6 +247,7 @@ mod notimplemented;
 mod num;
 #[cfg(not(any(PyPy, GraalPy)))]
 mod pysuper;
+pub(crate) mod range;
 pub(crate) mod sequence;
 pub(crate) mod set;
 pub(crate) mod slice;

src/types/range.rs

@@ -0,0 +1,92 @@
+use crate::sealed::Sealed;
+use crate::types::PyAnyMethods;
+use crate::{ffi, Bound, PyAny, PyResult, PyTypeInfo, Python};
+
+/// Represents a Python `range`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyRange>`][crate::Py] or [`Bound<'py, PyRange>`][Bound].
+///
+/// For APIs available on `range` objects, see the [`PyRangeMethods`] trait which is implemented for
+/// [`Bound<'py, PyRange>`][Bound].
+#[repr(transparent)]
+pub struct PyRange(PyAny);
+
+pyobject_native_type_core!(PyRange, pyobject_native_static_type_object!(ffi::PyRange_Type), #checkfunction=ffi::PyRange_Check);
+
+impl<'py> PyRange {
+    /// Creates a new Python `range` object with a default step of 1.
+    pub fn new(py: Python<'py>, start: isize, stop: isize) -> PyResult<Bound<'py, Self>> {
+        Self::new_with_step(py, start, stop, 1)
+    }
+
+    /// Creates a new Python `range` object with a specified step.
+    pub fn new_with_step(
+        py: Python<'py>,
+        start: isize,
+        stop: isize,
+        step: isize,
+    ) -> PyResult<Bound<'py, Self>> {
+        unsafe {
+            Ok(Self::type_object(py)
+                .call1((start, stop, step))?
+                .downcast_into_unchecked())
+        }
+    }
+}
+
+/// Implementation of functionality for [`PyRange`].
+///
+/// These methods are defined for the `Bound<'py, PyRange>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyRange")]
+pub trait PyRangeMethods<'py>: Sealed {
+    /// Returns the start of the range.
+    fn start(&self) -> PyResult<isize>;
+
+    /// Returns the exclusive end of the range.
+    fn stop(&self) -> PyResult<isize>;
+
+    /// Returns the step of the range.
+    fn step(&self) -> PyResult<isize>;
+}
+
+impl<'py> PyRangeMethods<'py> for Bound<'py, PyRange> {
+    fn start(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "start"))?.extract()
+    }
+
+    fn stop(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "stop"))?.extract()
+    }
+
+    fn step(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "step"))?.extract()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_py_range_new() {
+        Python::with_gil(|py| {
+            let range = PyRange::new(py, isize::MIN, isize::MAX).unwrap();
+            assert_eq!(range.start().unwrap(), isize::MIN);
+            assert_eq!(range.stop().unwrap(), isize::MAX);
+            assert_eq!(range.step().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_py_range_new_with_step() {
+        Python::with_gil(|py| {
+            let range = PyRange::new_with_step(py, 1, 10, 2).unwrap();
+            assert_eq!(range.start().unwrap(), 1);
+            assert_eq!(range.stop().unwrap(), 10);
+            assert_eq!(range.step().unwrap(), 2);
+        });
+    }
+}

src/types/slice.rs

@@ -2,6 +2,7 @@ use crate::err::{PyErr, PyResult};
 use crate::ffi;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::types::any::PyAnyMethods;
+use crate::types::{PyRange, PyRangeMethods};
 use crate::{Bound, IntoPyObject, PyAny, Python};
 use std::convert::Infallible;
 
@@ -140,6 +141,19 @@ impl<'py> IntoPyObject<'py> for &PySliceIndices {
     }
 }
 
+impl<'py> TryFrom<Bound<'py, PyRange>> for Bound<'py, PySlice> {
+    type Error = PyErr;
+
+    fn try_from(range: Bound<'py, PyRange>) -> Result<Self, Self::Error> {
+        Ok(PySlice::new(
+            range.py(),
+            range.start()?,
+            range.stop()?,
+            range.step()?,
+        ))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;