
Module Objects
**************

There are only a few functions special to module objects.

PyTypeObject PyModule_Type

   This instance of ``PyTypeObject`` represents the Python module
   type.  This is exposed to Python programs as ``types.ModuleType``.

int PyModule_Check(PyObject *p)

   Return true if *p* is a module object, or a subtype of a module
   object.

int PyModule_CheckExact(PyObject *p)

   Return true if *p* is a module object, but not a subtype of
   ``PyModule_Type``.

PyObject* PyModule_New(const char *name)
    Return value: New reference.

   Return a new module object with the ``__name__`` attribute set to
   *name*. Only the module's ``__doc__`` and ``__name__`` attributes
   are filled in; the caller is responsible for providing a
   ``__file__`` attribute.

PyObject* PyModule_GetDict(PyObject *module)
    Return value: Borrowed reference.

   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__``.

char* PyModule_GetName(PyObject *module)

   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.

char* PyModule_GetFilename(PyObject *module)

   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 string, raise ``SystemError`` and return *NULL*.

void* PyModule_GetState(PyObject *module)

   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``.

PyModuleDef* PyModule_GetDef(PyObject *module)

   Return a pointer to the ``PyModuleDef`` struct from which the
   module was created, or *NULL* if the module wasn't created with
   ``PyModule_Create()``.


Initializing C modules
======================

These functions are usually used in the module initialization
function.

PyObject* PyModule_Create(PyModuleDef *module)

   Create a new module object, given the definition in *module*.  This
   behaves like ``PyModule_Create2()`` with *module_api_version* set
   to ``PYTHON_API_VERSION``.

PyObject* PyModule_Create2(PyModuleDef *module, int module_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.

PyModuleDef

   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.

   PyModuleDef_Base m_base

      Always initialize this member to ``PyModuleDef_HEAD_INIT``.

   char* m_name

      Name for the new module.

   char* m_doc

      Docstring for the module; usually a docstring variable created
      with ``PyDoc_STRVAR()`` is used.

   Py_ssize_t m_size

      If the module object needs additional memory, this should be set
      to the number of bytes to allocate; a pointer to the block of
      memory can be retrieved with ``PyModule_GetState()``.  If no
      memory is needed, set this to ``-1``.

      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.

   PyMethodDef* m_methods

      A pointer to a table of module-level functions, described by
      ``PyMethodDef`` values.  Can be *NULL* if no functions are
      present.

   inquiry m_reload

      Currently unused, should be *NULL*.

   traverseproc m_traverse

      A traversal function to call during GC traversal of the module
      object, or *NULL* if not needed.

   inquiry m_clear

      A clear function to call during GC clearing of the module
      object, or *NULL* if not needed.

   freefunc m_free

      A function to call during deallocation of the module object, or
      *NULL* if not needed.

int PyModule_AddObject(PyObject *module, const char *name, PyObject *value)

   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.

int PyModule_AddIntConstant(PyObject *module, const char *name, long value)

   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.

int PyModule_AddStringConstant(PyObject *module, const char *name, const char *value)

   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.

int PyModule_AddIntMacro(PyObject *module, macro)

   Add an int constant to *module*. The name and the value are taken
   from *macro*. For example ``PyModule_AddConstant(module, AF_INET)``
   adds the int constant *AF_INET* with the value of *AF_INET* to
   *module*. Return ``-1`` on error, ``0`` on success.

int PyModule_AddStringMacro(PyObject *module, macro)

   Add a string constant to *module*.
