Struct PyModuleDef 

pub struct PyModuleDef {
    pub name: &'static PyStrInterned,
    pub doc: Option<&'static PyStrInterned>,
    pub methods: &'static [PyMethodDef],
    pub slots: PyModuleSlots,
}

Fields

name: &'static PyStrInterned

doc: Option<&'static PyStrInterned>

methods: &'static [PyMethodDef]

slots: PyModuleSlots

Implementations

impl PyModuleDef

pub fn create_module( &'static self, vm: &VirtualMachine, ) -> PyResult<PyRef<PyModule>>

Create a module from this definition (Phase 1 of multi-phase init).

This performs:

1. Create module object (using create slot if provided)
2. Initialize module dict from def
3. Add methods to module

Does NOT add to sys.modules or call exec slot.

pub fn exec_module( &'static self, vm: &VirtualMachine, module: &Py<PyModule>, ) -> PyResult<()>

Execute the module’s exec slot (Phase 2 of multi-phase init).

Calls the exec slot if present. Returns Ok(()) if no exec slot.

Trait Implementations

impl Debug for PyModuleDef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MaybeTraverse for PyModuleDef

const HAS_TRAVERSE: bool = false

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = false

if has clear implementation for circular reference resolution (tp_clear)

fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>)

fn try_clear(&mut self, out: &mut Vec<PyObjectRef>)

impl PyClassDef for PyModuleDef

const NAME: &'static str = "module"

const MODULE_NAME: Option<&'static str> = None

const TP_NAME: &'static str = "module"

const DOC: Option<&'static str>

const BASICSIZE: usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

const ITEMSIZE: usize = 0

impl StaticType for PyModuleDef

fn static_cell() -> &'static StaticCell<PyTypeRef>

fn static_metaclass() -> &'static Py<PyType>

fn static_baseclass() -> &'static Py<PyType>

fn static_type() -> &'static Py<PyType>

fn init_manually(typ: PyTypeRef) -> &'static Py<PyType>