Migrate all pytests modules to declarative modules and adds stubs (#5735)

Author: Tpt

pytests/src/awaitable.rs

@@ -5,82 +5,80 @@
 //! when awaited, see guide examples related to pyo3-async-runtimes for ways
 //! to suspend tasks and await results.
 
-use pyo3::exceptions::PyStopIteration;
 use pyo3::prelude::*;
 
-#[pyclass]
-#[derive(Debug)]
-pub(crate) struct IterAwaitable {
-    result: Option<PyResult<Py<PyAny>>>,
-}
-
-#[pymethods]
-impl IterAwaitable {
-    #[new]
-    fn new(result: Py<PyAny>) -> Self {
-        IterAwaitable {
-            result: Some(Ok(result)),
-        }
-    }
+#[pymodule]
+pub mod awaitable {
+    use pyo3::exceptions::PyStopIteration;
+    use pyo3::prelude::*;
 
-    fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
-        pyself
+    #[pyclass]
+    #[derive(Debug)]
+    pub(crate) struct IterAwaitable {
+        result: Option<PyResult<Py<PyAny>>>,
     }
 
-    fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
-        pyself
-    }
+    #[pymethods]
+    impl IterAwaitable {
+        #[new]
+        fn new(result: Py<PyAny>) -> Self {
+            IterAwaitable {
+                result: Some(Ok(result)),
+            }
+        }
 
-    fn __next__(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
-        match self.result.take() {
-            Some(res) => match res {
-                Ok(v) => Err(PyStopIteration::new_err(v)),
-                Err(err) => Err(err),
-            },
-            _ => Ok(py.None()),
+        fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
+            pyself
         }
-    }
-}
 
-#[pyclass]
-pub(crate) struct FutureAwaitable {
-    #[pyo3(get, set, name = "_asyncio_future_blocking")]
-    py_block: bool,
-    result: Option<PyResult<Py<PyAny>>>,
-}
+        fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
+            pyself
+        }
 
-#[pymethods]
-impl FutureAwaitable {
-    #[new]
-    fn new(result: Py<PyAny>) -> Self {
-        FutureAwaitable {
-            py_block: false,
-            result: Some(Ok(result)),
+        fn __next__(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+            match self.result.take() {
+                Some(res) => match res {
+                    Ok(v) => Err(PyStopIteration::new_err(v)),
+                    Err(err) => Err(err),
+                },
+                _ => Ok(py.None()),
+            }
         }
     }
 
-    fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
-        pyself
+    #[pyclass]
+    pub(crate) struct FutureAwaitable {
+        #[pyo3(get, set, name = "_asyncio_future_blocking")]
+        py_block: bool,
+        result: Option<PyResult<Py<PyAny>>>,
     }
 
-    fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
-        pyself
-    }
+    #[pymethods]
+    impl FutureAwaitable {
+        #[new]
+        fn new(result: Py<PyAny>) -> Self {
+            FutureAwaitable {
+                py_block: false,
+                result: Some(Ok(result)),
+            }
+        }
 
-    fn __next__(mut pyself: PyRefMut<'_, Self>) -> PyResult<PyRefMut<'_, Self>> {
-        match pyself.result {
-            Some(_) => match pyself.result.take().unwrap() {
-                Ok(v) => Err(PyStopIteration::new_err(v)),
-                Err(err) => Err(err),
-            },
-            _ => Ok(pyself),
+        fn __await__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
+            pyself
         }
-    }
-}
 
-#[pymodule]
-pub fn awaitable(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<IterAwaitable>()?;
-    m.add_class::<FutureAwaitable>()?;
-    Ok(())
+        fn __iter__(pyself: PyRef<'_, Self>) -> PyRef<'_, Self> {
+            pyself
+        }
+
+        fn __next__(mut pyself: PyRefMut<'_, Self>) -> PyResult<PyRefMut<'_, Self>> {
+            match pyself.result {
+                Some(_) => match pyself.result.take().unwrap() {
+                    Ok(v) => Err(PyStopIteration::new_err(v)),
+                    Err(err) => Err(err),
+                },
+                _ => Ok(pyself),
+            }
+        }
+    }
 }

pytests/src/datetime.rs

@@ -204,25 +204,12 @@ impl TzClass {
 }
 
 #[pymodule]
-pub fn datetime(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(make_date, m)?)?;
-    m.add_function(wrap_pyfunction!(get_date_tuple, m)?)?;
-    m.add_function(wrap_pyfunction!(date_from_timestamp, m)?)?;
-    m.add_function(wrap_pyfunction!(make_time, m)?)?;
-    m.add_function(wrap_pyfunction!(get_time_tuple, m)?)?;
-    m.add_function(wrap_pyfunction!(make_delta, m)?)?;
-    m.add_function(wrap_pyfunction!(get_delta_tuple, m)?)?;
-    m.add_function(wrap_pyfunction!(make_datetime, m)?)?;
-    m.add_function(wrap_pyfunction!(get_datetime_tuple, m)?)?;
-    m.add_function(wrap_pyfunction!(datetime_from_timestamp, m)?)?;
-    m.add_function(wrap_pyfunction!(get_datetime_tzinfo, m)?)?;
-    m.add_function(wrap_pyfunction!(get_time_tzinfo, m)?)?;
-
-    m.add_function(wrap_pyfunction!(time_with_fold, m)?)?;
-    m.add_function(wrap_pyfunction!(get_time_tuple_fold, m)?)?;
-    m.add_function(wrap_pyfunction!(get_datetime_tuple_fold, m)?)?;
-
-    m.add_class::<TzClass>()?;
-
-    Ok(())
+pub mod datetime {
+    #[pymodule_export]
+    use super::{
+        date_from_timestamp, datetime_from_timestamp, get_date_tuple, get_datetime_tuple,
+        get_datetime_tuple_fold, get_datetime_tzinfo, get_delta_tuple, get_time_tuple,
+        get_time_tuple_fold, get_time_tzinfo, make_date, make_datetime, make_delta, make_time,
+        time_with_fold, TzClass,
+    };
 }

pytests/src/dict_iter.rs

@@ -1,42 +1,41 @@
-use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
 
 #[pymodule]
-pub fn dict_iter(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<DictSize>()?;
-    Ok(())
-}
-
-#[pyclass]
-pub struct DictSize {
-    expected: u32,
-}
+pub mod dict_iter {
+    use pyo3::exceptions::PyRuntimeError;
+    use pyo3::prelude::*;
+    use pyo3::types::PyDict;
 
-#[pymethods]
-impl DictSize {
-    #[new]
-    fn new(expected: u32) -> Self {
-        DictSize { expected }
+    #[pyclass]
+    pub struct DictSize {
+        expected: u32,
     }
 
-    fn iter_dict(&mut self, _py: Python<'_>, dict: &Bound<'_, PyDict>) -> PyResult<u32> {
-        let mut seen = 0u32;
-        for (sym, values) in dict {
-            seen += 1;
-            println!(
-                "{:4}/{:4} iterations:{}=>{}",
-                seen, self.expected, sym, values
-            );
+    #[pymethods]
+    impl DictSize {
+        #[new]
+        fn new(expected: u32) -> Self {
+            DictSize { expected }
         }
 
-        if seen == self.expected {
-            Ok(seen)
-        } else {
-            Err(PyErr::new::<PyRuntimeError, _>(format!(
-                "Expected {} iterations - performed {}",
-                self.expected, seen
-            )))
+        fn iter_dict(&mut self, _py: Python<'_>, dict: &Bound<'_, PyDict>) -> PyResult<u32> {
+            let mut seen = 0u32;
+            for (sym, values) in dict {
+                seen += 1;
+                println!(
+                    "{:4}/{:4} iterations:{}=>{}",
+                    seen, self.expected, sym, values
+                );
+            }
+
+            if seen == self.expected {
+                Ok(seen)
+            } else {
+                Err(PyErr::new::<PyRuntimeError, _>(format!(
+                    "Expected {} iterations - performed {}",
+                    self.expected, seen
+                )))
+            }
         }
     }
 }

pytests/src/lib.rs

@@ -1,23 +1,22 @@
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use pyo3::wrap_pymodule;
 
-pub mod awaitable;
-pub mod buf_and_str;
-pub mod comparisons;
+mod awaitable;
+mod buf_and_str;
+mod comparisons;
 mod consts;
-pub mod datetime;
-pub mod dict_iter;
-pub mod enums;
+mod datetime;
+mod dict_iter;
+mod enums;
 mod exception;
-pub mod misc;
-pub mod objstore;
-pub mod othermod;
-pub mod path;
-pub mod pyclasses;
-pub mod pyfunctions;
-pub mod sequence;
-pub mod subclassing;
+mod misc;
+mod objstore;
+mod othermod;
+mod path;
+mod pyclasses;
+mod pyfunctions;
+mod sequence;
+mod subclassing;
 
 #[pymodule]
 mod pyo3_pytests {
@@ -26,29 +25,23 @@ mod pyo3_pytests {
     #[cfg(any(not(Py_LIMITED_API), Py_3_11))]
     #[pymodule_export]
     use buf_and_str::buf_and_str;
+
+    #[cfg(not(Py_LIMITED_API))]
+    #[pymodule_export]
+    use datetime::datetime;
+
     #[pymodule_export]
     use {
-        comparisons::comparisons, consts::consts, enums::enums, exception::exception,
-        pyclasses::pyclasses, pyfunctions::pyfunctions, subclassing::subclassing,
+        awaitable::awaitable, comparisons::comparisons, consts::consts, dict_iter::dict_iter,
+        enums::enums, exception::exception, misc::misc, objstore::objstore, othermod::othermod,
+        path::path, pyclasses::pyclasses, pyfunctions::pyfunctions, sequence::sequence,
+        subclassing::subclassing,
     };
 
     // Inserting to sys.modules allows importing submodules nicely from Python
     // e.g. import pyo3_pytests.buf_and_str as bas
     #[pymodule_init]
     fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
-        m.add_wrapped(wrap_pymodule!(awaitable::awaitable))?;
-        #[cfg(not(Py_LIMITED_API))]
-        m.add_wrapped(wrap_pymodule!(datetime::datetime))?;
-        m.add_wrapped(wrap_pymodule!(dict_iter::dict_iter))?;
-        m.add_wrapped(wrap_pymodule!(misc::misc))?;
-        m.add_wrapped(wrap_pymodule!(objstore::objstore))?;
-        m.add_wrapped(wrap_pymodule!(othermod::othermod))?;
-        m.add_wrapped(wrap_pymodule!(path::path))?;
-        m.add_wrapped(wrap_pymodule!(sequence::sequence))?;
-
-        // Inserting to sys.modules allows importing submodules nicely from Python
-        // e.g. import pyo3_pytests.buf_and_str as bas
-
         let sys = PyModule::import(m.py(), "sys")?;
         let sys_modules = sys.getattr("modules")?.cast_into::<PyDict>()?;
         sys_modules.set_item("pyo3_pytests.awaitable", m.getattr("awaitable")?)?;

pytests/src/misc.rs

@@ -55,11 +55,10 @@ fn get_item_and_run_callback(dict: Bound<'_, PyDict>, callback: Bound<'_, PyAny>
 }
 
 #[pymodule]
-pub fn misc(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(issue_219, m)?)?;
-    m.add_function(wrap_pyfunction!(hammer_attaching_in_thread, m)?)?;
-    m.add_function(wrap_pyfunction!(get_type_fully_qualified_name, m)?)?;
-    m.add_function(wrap_pyfunction!(accepts_bool, m)?)?;
-    m.add_function(wrap_pyfunction!(get_item_and_run_callback, m)?)?;
-    Ok(())
+pub mod misc {
+    #[pymodule_export]
+    use super::{
+        accepts_bool, get_item_and_run_callback, get_type_fully_qualified_name,
+        hammer_attaching_in_thread, issue_219,
+    };
 }

pytests/src/objstore.rs

@@ -1,24 +1,24 @@
 use pyo3::prelude::*;
 
-#[pyclass]
-#[derive(Default)]
-pub struct ObjStore {
-    obj: Vec<Py<PyAny>>,
-}
+#[pymodule]
+pub mod objstore {
+    use pyo3::prelude::*;
 
-#[pymethods]
-impl ObjStore {
-    #[new]
-    fn new() -> Self {
-        ObjStore::default()
+    #[pyclass]
+    #[derive(Default)]
+    pub struct ObjStore {
+        obj: Vec<Py<PyAny>>,
     }
 
-    fn push(&mut self, obj: &Bound<'_, PyAny>) {
-        self.obj.push(obj.clone().unbind());
-    }
-}
+    #[pymethods]
+    impl ObjStore {
+        #[new]
+        fn new() -> Self {
+            ObjStore::default()
+        }
 
-#[pymodule]
-pub fn objstore(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<ObjStore>()
+        fn push(&mut self, obj: &Bound<'_, PyAny>) {
+            self.obj.push(obj.clone().unbind());
+        }
+    }
 }