This instance of PyTypeObject represents the Python module type. This is exposed to Python programs as types.ModuleType.
Return true if p is a module object, or a subtype of a module object.
Return true if p is a module object, but not a subtype of PyModule_Type.
Return a new module object with the __name__ attribute set to name. The module’s __name__, __doc__, __package__, and __loader__ attributes are filled in (all but __name__ are set to None); the caller is responsible for providing a __file__ attribute.
New in version 3.3.
Changed in version 3.4: __package__ and __loader__ are set to None.
Similar to PyImport_NewObject(), but the name is an UTF-8 encoded string instead of a Unicode object.
Return the dictionary object that implements module‘s namespace; this object is the same as the __dict__ attribute of the module object. This function never fails. It is recommended extensions use other PyModule_*() and PyObject_*() functions rather than directly manipulate a module’s __dict__.
Return module‘s __name__ value. If the module does not provide one, or if it is not a string, SystemError is raised and NULL is returned.
New in version 3.3.
Similar to PyModule_GetNameObject() but return the name encoded to 'utf-8'.
Return the name of the file from which module was loaded using module‘s __file__ attribute. If this is not defined, or if it is not a unicode string, raise SystemError and return NULL; otherwise return a reference to a Unicode object.
New in version 3.2.
Similar to PyModule_GetFilenameObject() but return the filename encoded to ‘utf-8’.
Deprecated since version 3.2: PyModule_GetFilename() raises UnicodeEncodeError on unencodable filenames, use PyModule_GetFilenameObject() instead.
Single-phase initialization creates singleton modules that can store additional information as part of the interpreter, allow that state to be retrieved later with only a reference to the module definition, rather than to the module itself.
Return the “state” of the module, that is, a pointer to the block of memory allocated at module creation time, or NULL. See PyModuleDef.m_size.
Return a pointer to the PyModuleDef struct from which the module was created, or NULL if the module wasn’t created with PyModule_Create().
Returns the module object that was created from def for the current interpreter. This method requires that the module object has been attached to the interpreter state with PyState_AddModule() beforehand. In case the corresponding module object is not found or has not been attached to the interpreter state yet, it returns NULL.
Attaches the module object passed to the function to the interpreter state. This allows the module object to be accessible via PyState_FindModule().
New in version 3.3.
Removes the module object created from def from the interpreter state.
New in version 3.3.
This struct holds all information that is needed to create a module object. There is usually only one static variable of that type for each module, which is statically initialized and then passed to PyModule_Create() in the module initialization function.
Always initialize this member to PyModuleDef_HEAD_INIT.
Name for the new module.
Docstring for the module; usually a docstring variable created with PyDoc_STRVAR() is used.
Some modules allow re-initialization (calling their PyInit_* function more than once). These modules should keep their state in a per-module memory area that can be retrieved with PyModule_GetState().
This memory should be used, rather than static globals, to hold per-module state, since it is then safe for use in multiple sub-interpreters. It is freed when the module object is deallocated, after the m_free function has been called, if present.
Setting m_size to -1 means that the module can not be re-initialized because it has global state. Setting it to a non-negative value means that the module can be re-initialized and specifies the additional amount of memory it requires for its state.
See PEP 3121 for more details.
A pointer to a table of module-level functions, described by PyMethodDef values. Can be NULL if no functions are present.
An array of slot definitions for multi-phase initialization, terminated by a NULL entry.
A traversal function to call during GC traversal of the module object, or NULL if not needed.
A clear function to call during GC clearing of the module object, or NULL if not needed.
A function to call during deallocation of the module object, or NULL if not needed.
The module initialization function may create and return the module object directly. This is referred to as “single-phase initialization”, and uses one of the following two module creation functions:
Create a new module object, given the definition in module. This behaves like PyModule_Create2() with module_api_version set to PYTHON_API_VERSION.
Create a new module object, given the definition in module, assuming the API version module_api_version. If that version does not match the version of the running interpreter, a RuntimeWarning is emitted.
Note
Most uses of this function should be using PyModule_Create() instead; only use this if you are sure you need it.
Alternatively, the module initialization function may instead return a PyModuleDef instance with a non-empty m_slots array. This is referred to as “multi-phase initialization”, and PyModuleDef instance should be initialized with the following function:
Ensures a module definition is a properly initialized Python object that correctly reports its type and reference count.
The module initialization function (if using single phase initialization) or a function called from a module execution slot (if using multiphase initialization), can use the following functions to help initialize the module state:
Set the docstring for module to docstring. Return -1 on error, 0 on success.
Add the functions from the NULL terminated functions array to module. Refer to the PyMethodDef documentation for details on individual entries (due to the lack of a shared module namespace, module level “functions” implemented in C typically receive the module as their first parameter, making them similar to instance methods on Python classes).
Add an object to module as name. This is a convenience function which can be used from the module’s initialization function. This steals a reference to value. Return -1 on error, 0 on success.
Add an integer constant to module as name. This convenience function can be used from the module’s initialization function. Return -1 on error, 0 on success.
Add a string constant to module as name. This convenience function can be used from the module’s initialization function. The string value must be null-terminated. Return -1 on error, 0 on success.