Move py fn wrapper argument expansion to associated function.

Suggestion by @kngwyu.

Additionally replace some `expect` calls with error handling.

pyo3-derive-backend/src/module.rs

@@ -194,13 +194,7 @@ pub fn add_fn_to_module(
             args: impl Into<pyo3::derive_utils::WrapPyFunctionArguments<'a>>
         ) -> pyo3::PyObject {
             let arg = args.into();
-            let (py, maybe_module) = match arg {
-                pyo3::derive_utils::WrapPyFunctionArguments::Python(py) => (py, None),
-                pyo3::derive_utils::WrapPyFunctionArguments::PyModule(module) => {
-                    let py = <pyo3::types::PyModule as pyo3::PyNativeType>::py(module);
-                    (py, Some(module))
-                }
-            };
+            let (py, maybe_module) = arg.into_py_and_maybe_module();
             #wrapper
 
             let _def = pyo3::class::PyMethodDef {

src/derive_utils.rs

@@ -215,6 +215,18 @@ pub enum WrapPyFunctionArguments<'a> {
     PyModule(&'a PyModule),
 }
 
+impl<'a> WrapPyFunctionArguments<'a> {
+    pub fn into_py_and_maybe_module(self) -> (Python<'a>, Option<&'a PyModule>) {
+        match self {
+            WrapPyFunctionArguments::Python(py) => (py, None),
+            WrapPyFunctionArguments::PyModule(module) => {
+                let py = module.py();
+                (py, Some(module))
+            }
+        }
+    }
+}
+
 impl<'a> From<Python<'a>> for WrapPyFunctionArguments<'a> {
     fn from(py: Python<'a>) -> WrapPyFunctionArguments<'a> {
         WrapPyFunctionArguments::Python(py)

src/types/module.rs

@@ -199,10 +199,8 @@ impl PyModule {
     /// [add_function] and [add_module] functions instead.**
     pub fn add_wrapped<'a>(&'a self, wrapper: &impl Fn(Python<'a>) -> PyObject) -> PyResult<()> {
         let function = wrapper(self.py());
-        let name = function
-            .getattr(self.py(), "__name__")
-            .expect("A function or module must have a __name__");
-        self.add(name.extract(self.py()).unwrap(), function)
+        let name = function.getattr(self.py(), "__name__")?;
+        self.add(name.extract(self.py())?, function)
     }
 
     /// Adds a (sub)module to a module.
@@ -214,10 +212,8 @@ impl PyModule {
     /// ```
     pub fn add_module<'a>(&'a self, wrapper: &impl Fn(Python<'a>) -> PyObject) -> PyResult<()> {
         let function = wrapper(self.py());
-        let name = function
-            .getattr(self.py(), "__name__")
-            .expect("A module must have a __name__");
-        self.add(name.extract(self.py()).unwrap(), function)
+        let name = function.getattr(self.py(), "__name__")?;
+        self.add(name.extract(self.py())?, function)
     }
 
     /// Adds a function to a module, using the functions __name__ as name.
@@ -235,9 +231,7 @@ impl PyModule {
     /// ```
     pub fn add_function<'a>(&'a self, wrapper: &impl Fn(&'a Self) -> PyObject) -> PyResult<()> {
         let function = wrapper(self);
-        let name = function
-            .getattr(self.py(), "__name__")
-            .expect("A function or module must have a __name__");
-        self.add(name.extract(self.py()).unwrap(), function)
+        let name = function.getattr(self.py(), "__name__")?;
+        self.add(name.extract(self.py())?, function)
     }
 }