__init__ (
        self,
        verbose=False,
        parser=DocTestParser(),
        recurse=True,
        _namefilter=None,
        exclude_empty=True,
        )

Create a new doctest finder.

The optional argument `parser` specifies a class or function that should be used to create new DocTest objects (or objects that implement the same interface as DocTest). The signature for this factory function should match the signature of the DocTest constructor.

If the optional argument `recurse` is false, then `find` will only examine the given object, and not any contained objects.

If the optional argument `exclude_empty` is false, then `find` will include tests for objects with empty docstrings.

_filter (
        self,
        obj,
        prefix,
        base,
        )

Return true if the given object should not be examined.

_find (
        self,
        tests,
        obj,
        name,
        module,
        source_lines,
        globs,
        seen,
        )

Find tests for the given object and any contained objects, and add them to `tests`.

_find_lineno (
        self,
        obj,
        source_lines,
        )

Return a line number of the given object's docstring. Note: this method assumes that the object has a docstring.

_from_module (
        self,
        module,
        object,
        )

Return true if the given object is defined in the given module.

_get_test (
        self,
        obj,
        name,
        module,
        globs,
        source_lines,
        )

Return a DocTest for the given object, if it defines a docstring; otherwise, return None.

find (
        self,
        obj,
        name=None,
        module=None,
        globs=None,
        extraglobs=None,
        )

Return a list of the DocTests that are defined by the given object's docstring, or by any of its contained objects' docstrings.

The optional parameter `module` is the module that contains the given object. If the module is not specified or is None, then the test finder will attempt to automatically determine the correct module. The object's module is used:

• As a default namespace, if `globs` is not specified. - To prevent the DocTestFinder from extracting DocTests from objects that are imported from other modules. - To find the name of the file containing the object. - To help find the line number of the object within its file.

Contained objects whose module does not match `module` are ignored.

If `module` is False, no attempt to find the module will be made. This is obscure, of use mostly in tests: if `module` is False, or is None but cannot be found automatically, then all objects are considered to belong to the (non-existent) module, so all contained objects will (recursively) be searched for doctests.

The globals for each DocTest is formed by combining `globs` and `extraglobs` (bindings in `extraglobs` override bindings in `globs`). A new copy of the globals dictionary is created for each DocTest. If `globs` is not specified, then it defaults to the module's `__dict__`, if specified, or {} otherwise. If `extraglobs` is not specified, then it defaults to {}.