Allow setting the module name for a pyclass

examples/word-count/src/lib.rs

@@ -8,7 +8,7 @@ use std::fs;
 use std::path::PathBuf;
 
 /// Represents a file that can be searched
-#[pyclass]
+#[pyclass(module="word_count")]
 struct WordCounter {
     path: PathBuf,
 }

guide/src/class.md

@@ -104,6 +104,8 @@ If a custom class contains references to other Python objects that can be collec
 * `extends=BaseType` - Use a custom base class. The base `BaseType` must implement `PyTypeInfo`.
 * `subclass` - Allows Python classes to inherit from this class.
 * `dict` - Adds `__dict__` support, so that the instances of this type have a dictionary containing arbitrary instance variables.
+* `module="XXX"` - Set the name of the module the class will be shown as defined in. If not given, the class
+  will be a virtual member of the `builtins` module.
 
 ## Constructor
 

pyo3-derive-backend/src/pyclass.rs

@@ -15,6 +15,7 @@ pub struct PyClassArgs {
     pub name: Option<syn::Expr>,
     pub flags: Vec<syn::Expr>,
     pub base: syn::TypePath,
+    pub module: Option<syn::LitStr>,
 }
 
 impl Parse for PyClassArgs {
@@ -34,6 +35,7 @@ impl Default for PyClassArgs {
         PyClassArgs {
             freelist: None,
             name: None,
+            module: None,
             // We need the 0 as value for the constant we're later building using quote for when there
             // are no other flags
             flags: vec![parse_quote! {0}],
@@ -94,6 +96,29 @@ impl PyClassArgs {
                     ));
                 }
             },
+
+            "module" => match *assign.right {
+                syn::Expr::Lit(ref exp) => {
+                    match exp.lit {
+                        syn::Lit::Str(ref lit) => {
+                            self.module = Some(lit.clone());
+                        }
+                        _ => {
+                            return Err(syn::Error::new_spanned(
+                                *assign.right.clone(),
+                                "Wrong format for module",
+                            ));
+                        }
+                    }
+                },
+                _ => {
+                    return Err(syn::Error::new_spanned(
+                        *assign.right.clone(),
+                        "Wrong format for module",
+                    ));
+                }
+            }
+
             _ => {
                 return Err(syn::Error::new_spanned(
                     *assign.left.clone(),
@@ -298,6 +323,11 @@ fn impl_class(
     } else {
         quote! {0}
     };
+    let module = if let Some(m) = &attr.module {
+        quote! { Some(#m) }
+    } else {
+        quote! { None }
+    };
 
     let inventory_impl = impl_inventory(&cls);
 
@@ -310,6 +340,7 @@ fn impl_class(
             type BaseType = #base;
 
             const NAME: &'static str = #cls_name;
+            const MODULE: Option<&'static str> = #module;
             const DESCRIPTION: &'static str = #doc;
             const FLAGS: usize = #(#flags)|*;
 

src/type_object.rs

@@ -25,6 +25,9 @@ pub trait PyTypeInfo {
     /// Class name
     const NAME: &'static str;
 
+    /// Module name, if any
+    const MODULE: Option<&'static str>;
+
     /// Class doc string
     const DESCRIPTION: &'static str = "\0";
 
@@ -256,7 +259,7 @@ where
             let gil = Python::acquire_gil();
             let py = gil.python();
 
-            initialize_type::<Self>(py, None).unwrap_or_else(|_| {
+            initialize_type::<Self>(py, <Self as PyTypeInfo>::MODULE).unwrap_or_else(|_| {
                 panic!("An error occurred while initializing class {}", Self::NAME)
             });
         }

src/types/any.rs

@@ -23,7 +23,7 @@ use crate::{ffi, PyObject, PyRef, PyRefMut, PyTryFrom, PyTypeInfo};
 #[repr(transparent)]
 pub struct PyAny(PyObject);
 pyobject_native_type_named!(PyAny);
-pyobject_native_type_convert!(PyAny, ffi::PyBaseObject_Type, ffi::PyObject_Check);
+pyobject_native_type_convert!(PyAny, ffi::PyBaseObject_Type, Some("builtins"), ffi::PyObject_Check);
 
 impl PyAny {
     pub fn downcast_ref<T>(&self) -> Result<&T, PyDowncastError>

src/types/boolobject.rs

@@ -12,7 +12,7 @@ use crate::{IntoPyObject, PyTryFrom, ToPyObject};
 #[repr(transparent)]
 pub struct PyBool(PyObject);
 
-pyobject_native_type!(PyBool, ffi::PyBool_Type, ffi::PyBool_Check);
+pyobject_native_type!(PyBool, ffi::PyBool_Type, Some("builtins"), ffi::PyBool_Check);
 
 impl PyBool {
     /// Depending on `val`, returns `py.True()` or `py.False()`.

src/types/bytearray.rs

@@ -13,7 +13,7 @@ use std::slice;
 #[repr(transparent)]
 pub struct PyByteArray(PyObject);
 
-pyobject_native_type!(PyByteArray, ffi::PyByteArray_Type, ffi::PyByteArray_Check);
+pyobject_native_type!(PyByteArray, ffi::PyByteArray_Type, Some("builtins"), ffi::PyByteArray_Check);
 
 impl PyByteArray {
     /// Creates a new Python bytearray object.

src/types/complex.rs

@@ -12,7 +12,7 @@ use std::os::raw::c_double;
 #[repr(transparent)]
 pub struct PyComplex(PyObject);
 
-pyobject_native_type!(PyComplex, ffi::PyComplex_Type, ffi::PyComplex_Check);
+pyobject_native_type!(PyComplex, ffi::PyComplex_Type, Some("builtins"), ffi::PyComplex_Check);
 
 impl PyComplex {
     /// Creates a new Python `PyComplex` object, from its real and imaginary values.

src/types/datetime.rs

@@ -66,7 +66,7 @@ pub trait PyTimeAccess {
 
 /// Bindings around `datetime.date`
 pub struct PyDate(PyObject);
-pyobject_native_type!(PyDate, *PyDateTimeAPI.DateType, PyDate_Check);
+pyobject_native_type!(PyDate, *PyDateTimeAPI.DateType, Some("datetime"), PyDate_Check);
 
 impl PyDate {
     pub fn new<'p>(py: Python<'p>, year: i32, month: u8, day: u8) -> PyResult<&'p PyDate> {
@@ -116,7 +116,7 @@ impl PyDateAccess for PyDate {
 
 /// Bindings for `datetime.datetime`
 pub struct PyDateTime(PyObject);
-pyobject_native_type!(PyDateTime, *PyDateTimeAPI.DateTimeType, PyDateTime_Check);
+pyobject_native_type!(PyDateTime, *PyDateTimeAPI.DateTimeType, Some("datetime"), PyDateTime_Check);
 
 impl PyDateTime {
     pub fn new<'p>(
@@ -220,7 +220,7 @@ impl PyTimeAccess for PyDateTime {
 
 /// Bindings for `datetime.time`
 pub struct PyTime(PyObject);
-pyobject_native_type!(PyTime, *PyDateTimeAPI.TimeType, PyTime_Check);
+pyobject_native_type!(PyTime, *PyDateTimeAPI.TimeType, Some("datetime"), PyTime_Check);
 
 impl PyTime {
     pub fn new<'p>(
@@ -299,11 +299,11 @@ impl PyTimeAccess for PyTime {
 ///
 /// This is an abstract base class and should not be constructed directly.
 pub struct PyTzInfo(PyObject);
-pyobject_native_type!(PyTzInfo, *PyDateTimeAPI.TZInfoType, PyTZInfo_Check);
+pyobject_native_type!(PyTzInfo, *PyDateTimeAPI.TZInfoType, Some("datetime"), PyTZInfo_Check);
 
 /// Bindings for `datetime.timedelta`
 pub struct PyDelta(PyObject);
-pyobject_native_type!(PyDelta, *PyDateTimeAPI.DeltaType, PyDelta_Check);
+pyobject_native_type!(PyDelta, *PyDateTimeAPI.DeltaType, Some("datetime"), PyDelta_Check);
 
 impl PyDelta {
     pub fn new<'p>(

src/types/dict.rs

@@ -16,7 +16,7 @@ use std::{cmp, collections, hash, mem};
 #[repr(transparent)]
 pub struct PyDict(PyObject);
 
-pyobject_native_type!(PyDict, ffi::PyDict_Type, ffi::PyDict_Check);
+pyobject_native_type!(PyDict, ffi::PyDict_Type, Some("builtins"), ffi::PyDict_Check);
 
 impl PyDict {
     /// Creates a new empty dictionary.

src/types/floatob.rs

@@ -24,7 +24,7 @@ use std::os::raw::c_double;
 #[repr(transparent)]
 pub struct PyFloat(PyObject);
 
-pyobject_native_type!(PyFloat, ffi::PyFloat_Type, ffi::PyFloat_Check);
+pyobject_native_type!(PyFloat, ffi::PyFloat_Type, Some("builtins"), ffi::PyFloat_Check);
 
 impl PyFloat {
     /// Creates a new Python `float` object.

src/types/list.rs

@@ -16,7 +16,7 @@ use crate::{IntoPyObject, ToBorrowedObject, ToPyObject};
 #[repr(transparent)]
 pub struct PyList(PyObject);
 
-pyobject_native_type!(PyList, ffi::PyList_Type, ffi::PyList_Check);
+pyobject_native_type!(PyList, ffi::PyList_Type, Some("builtins"), ffi::PyList_Check);
 
 impl PyList {
     /// Construct a new list with the given elements.

src/types/mod.rs

@@ -79,9 +79,9 @@ macro_rules! pyobject_native_type_named (
 
 #[macro_export]
 macro_rules! pyobject_native_type (
-    ($name: ty, $typeobject: expr, $checkfunction: path $(,$type_param: ident)*) => {
+    ($name: ty, $typeobject: expr, $module: expr, $checkfunction: path $(,$type_param: ident)*) => {
         pyobject_native_type_named!($name $(,$type_param)*);
-        pyobject_native_type_convert!($name, $typeobject, $checkfunction $(,$type_param)*);
+        pyobject_native_type_convert!($name, $typeobject, $module, $checkfunction $(,$type_param)*);
 
         impl<'a, $($type_param,)*> ::std::convert::From<&'a $name> for &'a $crate::types::PyAny {
             fn from(ob: &'a $name) -> Self {
@@ -93,12 +93,13 @@ macro_rules! pyobject_native_type (
 
 #[macro_export]
 macro_rules! pyobject_native_type_convert(
-    ($name: ty, $typeobject: expr, $checkfunction: path $(,$type_param: ident)*) => {
+    ($name: ty, $typeobject: expr, $module: expr, $checkfunction: path $(,$type_param: ident)*) => {
         impl<$($type_param,)*> $crate::type_object::PyTypeInfo for $name {
             type Type = ();
             type BaseType = $crate::types::PyAny;
 
             const NAME: &'static str = stringify!($name);
+            const MODULE: Option<&'static str> = $module;
             const SIZE: usize = ::std::mem::size_of::<$crate::ffi::PyObject>();
             const OFFSET: isize = 0;
 

src/types/module.rs

@@ -25,7 +25,7 @@ use std::str;
 #[repr(transparent)]
 pub struct PyModule(PyObject);
 
-pyobject_native_type!(PyModule, ffi::PyModule_Type, ffi::PyModule_Check);
+pyobject_native_type!(PyModule, ffi::PyModule_Type, Some("builtins"), ffi::PyModule_Check);
 
 impl PyModule {
     /// Create a new module object with the `__name__` attribute set to name.

src/types/num.rs

@@ -123,7 +123,7 @@ pub(super) const IS_LITTLE_ENDIAN: c_int = 0;
 #[repr(transparent)]
 pub struct PyLong(PyObject);
 
-pyobject_native_type!(PyLong, ffi::PyLong_Type, ffi::PyLong_Check);
+pyobject_native_type!(PyLong, ffi::PyLong_Type, Some("builtins"), ffi::PyLong_Check);
 
 macro_rules! int_fits_c_long (
     ($rust_type:ty) => (

src/types/set.rs

@@ -18,8 +18,8 @@ pub struct PySet(PyObject);
 #[repr(transparent)]
 pub struct PyFrozenSet(PyObject);
 
-pyobject_native_type!(PySet, ffi::PySet_Type, ffi::PySet_Check);
-pyobject_native_type!(PyFrozenSet, ffi::PyFrozenSet_Type, ffi::PyFrozenSet_Check);
+pyobject_native_type!(PySet, ffi::PySet_Type, Some("builtins"), ffi::PySet_Check);
+pyobject_native_type!(PyFrozenSet, ffi::PyFrozenSet_Type, Some("builtins"), ffi::PyFrozenSet_Check);
 
 impl PySet {
     /// Creates a new set.

src/types/slice.rs

@@ -14,7 +14,7 @@ use std::os::raw::c_long;
 #[repr(transparent)]
 pub struct PySlice(PyObject);
 
-pyobject_native_type!(PySlice, ffi::PySlice_Type, ffi::PySlice_Check);
+pyobject_native_type!(PySlice, ffi::PySlice_Type, Some("builtins"), ffi::PySlice_Check);
 
 /// Represents a Python `slice` indices
 pub struct PySliceIndices {

src/types/string.rs

@@ -18,13 +18,13 @@ use std::{mem, str};
 #[repr(transparent)]
 pub struct PyString(PyObject);
 
-pyobject_native_type!(PyString, ffi::PyUnicode_Type, ffi::PyUnicode_Check);
+pyobject_native_type!(PyString, ffi::PyUnicode_Type, Some("builtins"), ffi::PyUnicode_Check);
 
 /// Represents a Python `byte` string.
 #[repr(transparent)]
 pub struct PyBytes(PyObject);
 
-pyobject_native_type!(PyBytes, ffi::PyBytes_Type, ffi::PyBytes_Check);
+pyobject_native_type!(PyBytes, ffi::PyBytes_Type, Some("builtins"), ffi::PyBytes_Check);
 
 impl PyString {
     /// Creates a new Python string object.

src/types/tuple.rs

@@ -17,7 +17,7 @@ use std::slice;
 #[repr(transparent)]
 pub struct PyTuple(PyObject);
 
-pyobject_native_type!(PyTuple, ffi::PyTuple_Type, ffi::PyTuple_Check);
+pyobject_native_type!(PyTuple, ffi::PyTuple_Type, Some("builtins"), ffi::PyTuple_Check);
 
 impl PyTuple {
     /// Construct a new tuple with the given elements.

src/types/typeobject.rs

@@ -16,7 +16,7 @@ use std::ffi::CStr;
 #[repr(transparent)]
 pub struct PyType(PyObject);
 
-pyobject_native_type!(PyType, ffi::PyType_Type, ffi::PyType_Check);
+pyobject_native_type!(PyType, ffi::PyType_Type, Some("builtins"), ffi::PyType_Check);
 
 impl PyType {
     #[inline]