diff --git a/ci/requirements.txt b/ci/requirements.txt index 37695fba67585adcd6fabc5adcaa1a05316891ba..64c0d6b7cded1485e406f03c20098857eeab249c 100644 --- a/ci/requirements.txt +++ b/ci/requirements.txt @@ -1,6 +1,6 @@ parameterized coverage git+https://gitlab.mpcdf.mpg.de/ift/pyHealpix.git -sphinx==1.6.7 +sphinx sphinx_rtd_theme numpydoc diff --git a/docs/better_apidoc.py b/docs/better_apidoc.py deleted file mode 100644 index 75fe8f4ee2a525a8f1920fc3945db90fcebde2cb..0000000000000000000000000000000000000000 --- a/docs/better_apidoc.py +++ /dev/null @@ -1,665 +0,0 @@ -# -*- coding: utf-8 -*- -""" - better apidoc - ~~~~~~~~~~~~~ - - Parses a directory tree looking for Python modules and packages and creates - ReST files appropriately to create code documentation with Sphinx. It also - creates a modules index (named modules.<suffix>). - - This is derived from the "sphinx-apidoc" script, which is: - Copyright 2007-2016 by the Sphinx team - http://www.sphinx-doc.org - - It extends "sphinx-apidoc" by the --template / -t option, which allows to - render the output ReST files based on arbitrary Jinja templates. - - :copyright: Copyright 2017 by Michael Goerz - :license: BSD, see LICENSE for details. -""" -from __future__ import print_function - -import os -import sys -import importlib -import optparse -from os import path -from six import binary_type -from fnmatch import fnmatch - -from jinja2 import FileSystemLoader, TemplateNotFound -from jinja2.sandbox import SandboxedEnvironment - -from sphinx.util.osutil import FileAvoidWrite, walk -#from sphinx import __display_version__ -from sphinx.quickstart import EXTENSIONS - -from sphinx.ext.autosummary import get_documenter -from sphinx.util.inspect import safe_getattr - -# Add documenters to AutoDirective registry -from sphinx.ext.autodoc import add_documenter, \ - ModuleDocumenter, ClassDocumenter, ExceptionDocumenter, DataDocumenter, \ - FunctionDocumenter, MethodDocumenter, AttributeDocumenter, \ - InstanceAttributeDocumenter -add_documenter(ModuleDocumenter) -add_documenter(ClassDocumenter) -add_documenter(ExceptionDocumenter) -add_documenter(DataDocumenter) -add_documenter(FunctionDocumenter) -add_documenter(MethodDocumenter) -add_documenter(AttributeDocumenter) -add_documenter(InstanceAttributeDocumenter) - -__version__ = '0.1.2' -__display_version__ = __version__ - -if False: - # For type annotation - from typing import Any, List, Tuple # NOQA - -# automodule options -if 'SPHINX_APIDOC_OPTIONS' in os.environ: - OPTIONS = os.environ['SPHINX_APIDOC_OPTIONS'].split(',') -else: - OPTIONS = [ - 'members', - 'undoc-members', - # 'inherited-members', # disabled because there's a bug in sphinx - 'show-inheritance', - ] - -INITPY = '__init__.py' -PY_SUFFIXES = set(['.py', '.pyx']) - - -def _warn(msg): - # type: (unicode) -> None - print('WARNING: ' + msg, file=sys.stderr) - - -def makename(package, module): - # type: (unicode, unicode) -> unicode - """Join package and module with a dot.""" - # Both package and module can be None/empty. - if package: - name = package - if module: - name += '.' + module - else: - name = module - return name - - -def write_file(name, text, opts): - # type: (unicode, unicode, Any) -> None - """Write the output file for module/package <name>.""" - fname = path.join(opts.destdir, '%s.%s' % (name, opts.suffix)) - if opts.dryrun: - print('Would create file %s.' % fname) - return - if not opts.force and path.isfile(fname): - print('File %s already exists, skipping.' % fname) - else: - print('Creating file %s.' % fname) - with FileAvoidWrite(fname) as f: - f.write(text) - - -def format_heading(level, text): - # type: (int, unicode) -> unicode - """Create a heading of <level> [1, 2 or 3 supported].""" - underlining = ['=', '-', '~', ][level - 1] * len(text) - return '%s\n%s\n\n' % (text, underlining) - - -def format_directive(module, package=None): - # type: (unicode, unicode) -> unicode - """Create the automodule directive and add the options.""" - directive = '.. automodule:: %s\n' % makename(package, module) - for option in OPTIONS: - directive += ' :%s:\n' % option - return directive - - -def create_module_file(package, module, opts): - # type: (unicode, unicode, Any) -> None - """Generate RST for a top-level module (i.e., not part of a package)""" - if not opts.noheadings: - text = format_heading(1, '%s module' % module) - else: - text = '' - # text += format_heading(2, ':mod:`%s` Module' % module) - text += format_directive(module, package) - - if opts.templates: - template_loader = FileSystemLoader(opts.templates) - template_env = SandboxedEnvironment(loader=template_loader) - try: - mod_ns = _get_mod_ns( - name=module, fullname=module, - includeprivate=opts.includeprivate) - template = template_env.get_template('module.rst') - text = template.render(**mod_ns) - except ImportError as e: - _warn('failed to import %r: %s' % (module, e)) - write_file(makename(package, module), text, opts) - - -def _get_members( - mod, typ=None, include_imported=False, as_refs=False, in__all__=False): - """Get (filtered) public/total members of the module or package `mod`. - - Args: - mod: object resulting from importing a module or package - typ: filter on members. If None, include all members. If one of - 'function', 'class', 'exception', 'data', only include members of - the matching type - include_imported: If True, also include members that are imports - as_refs: If True, return ReST-formatted reference strings for all - members, instead of just their names. In combinations with - `include_imported` or `in__all__`, these link to the original - location where the member is defined - in__all__: If True, return only members that are in ``mod.__all__`` - - Returns: - lists `public` and `items`. The lists contains the public and private + - public members, as strings. - - Note: - For data members, there is no way to tell whether they were imported or - defined locally (without parsing the source code). A module may define - one or both attributes - - __local_data__: list of names of data objects defined locally - __imported_data__: dict of names to ReST-formatted references of where - a data object originates - - If either one of these attributes is present, the member will be - classified accordingly. Otherwise, it will be classified as local if it - appeard in the __all__ list, or as imported otherwise - - """ - roles = {'function': 'func', 'module': 'mod', 'class': 'class', - 'exception': 'exc', 'data': 'data'} - # not included, because they cannot occur at modul level: - # 'method': 'meth', 'attribute': 'attr', 'instanceattribute': 'attr' - - def check_typ(typ, mod, member): - """Check if mod.member is of the desired typ""" - documenter = get_documenter(member, mod) - if typ is None: - return True - if typ == getattr(documenter, 'objtype', None): - return True - if hasattr(documenter, 'directivetype'): - return roles[typ] == getattr(documenter, 'directivetype') - - def is_local(mod, member, name): - """Check whether mod.member is defined locally in module mod""" - if hasattr(member, '__module__'): - return getattr(member, '__module__') == mod.__name__ - else: - # we take missing __module__ to mean the member is a data object - if hasattr(mod, '__local_data__'): - return name in getattr(mod, '__local_data__') - if hasattr(mod, '__imported_data__'): - return name not in getattr(mod, '__imported_data__') - else: - return name in getattr(mod, '__all__', []) - - if typ is not None and typ not in roles: - raise ValueError("typ must be None or one of %s" - % str(list(roles.keys()))) - items = [] - public = [] - all_list = getattr(mod, '__all__', []) - for name in dir(mod): - try: - member = safe_getattr(mod, name) - except AttributeError: - continue - if check_typ(typ, mod, member): - if in__all__ and name not in all_list: - continue - if include_imported or is_local(mod, member, name): - if as_refs: - documenter = get_documenter(member, mod) - role = roles.get(documenter.objtype, 'obj') - ref = _get_member_ref_str( - name, obj=member, role=role, - known_refs=getattr(mod, '__imported_data__', None)) - items.append(ref) - if not name.startswith('_'): - public.append(ref) - else: - items.append(name) - if not name.startswith('_'): - public.append(name) - return public, items - - -def _get_member_ref_str(name, obj, role='obj', known_refs=None): - """generate a ReST-formmated reference link to the given `obj` of type - `role`, using `name` as the link text""" - if known_refs is not None: - if name in known_refs: - return known_refs[name] - if hasattr(obj, '__name__'): - try: - ref = obj.__module__ + '.' + obj.__name__ - except AttributeError: - ref = obj.__name__ - except TypeError: # e.g. obj.__name__ is None - ref = name - else: - ref = name - return ":%s:`%s <%s>`" % (role, name, ref) - - -def _get_mod_ns(name, fullname, includeprivate): - """Return the template context of module identified by `fullname` as a - dict""" - ns = { # template variables - 'name': name, 'fullname': fullname, 'members': [], 'functions': [], - 'classes': [], 'exceptions': [], 'subpackages': [], 'submodules': [], - 'all_refs': [], 'members_imports': [], 'members_imports_refs': [], - 'data': [], 'doc':None} - p = 0 - if includeprivate: - p = 1 - mod = importlib.import_module(fullname) - ns['members'] = _get_members(mod)[p] - ns['functions'] = _get_members(mod, typ='function')[p] - ns['classes'] = _get_members(mod, typ='class')[p] - ns['exceptions'] = _get_members(mod, typ='exception')[p] - ns['all_refs'] = _get_members(mod, include_imported=True, in__all__=True, as_refs=True)[p] - ns['members_imports'] = _get_members(mod, include_imported=True)[p] - ns['members_imports_refs'] = _get_members(mod, include_imported=True, as_refs=True)[p] - ns['data'] = _get_members(mod, typ='data')[p] - ns['doc'] = mod.__doc__ - return ns - - -def create_package_file(root, master_package, subroot, py_files, opts, subs, is_namespace): - # type: (unicode, unicode, unicode, List[unicode], Any, List[unicode], bool) -> None - """Build the text of the file and write the file.""" - - use_templates = False - if opts.templates: - use_templates = True - template_loader = FileSystemLoader(opts.templates) - template_env = SandboxedEnvironment(loader=template_loader) - - fullname = makename(master_package, subroot) - - text = format_heading( - 1, ('%s package' if not is_namespace else "%s namespace") % fullname) - - if opts.modulefirst and not is_namespace: - text += format_directive(subroot, master_package) - text += '\n' - - # build a list of directories that are szvpackages (contain an INITPY file) - subs = [sub for sub in subs if path.isfile(path.join(root, sub, INITPY))] - # if there are some package directories, add a TOC for theses subpackages - if subs: - text += format_heading(2, 'Subpackages') - text += '.. toctree::\n\n' - for sub in subs: - text += ' %s.%s\n' % (makename(master_package, subroot), sub) - text += '\n' - - submods = [path.splitext(sub)[0] for sub in py_files - if not shall_skip(path.join(root, sub), opts) and - sub != INITPY] - - - if submods: - text += format_heading(2, 'Submodules') - if opts.separatemodules: - text += '.. toctree::\n\n' - for submod in submods: - modfile = makename(master_package, makename(subroot, submod)) - text += ' %s\n' % modfile - - # generate separate file for this module - if not opts.noheadings: - filetext = format_heading(1, '%s module' % modfile) - else: - filetext = '' - filetext += format_directive(makename(subroot, submod), - master_package) - if use_templates: - try: - mod_ns = _get_mod_ns( - name=submod, fullname=modfile, - includeprivate=opts.includeprivate) - template = template_env.get_template('module.rst') - filetext = template.render(**mod_ns) - except ImportError as e: - _warn('failed to import %r: %s' % (modfile, e)) - write_file(modfile, filetext, opts) - else: - for submod in submods: - modfile = makename(master_package, makename(subroot, submod)) - if not opts.noheadings: - text += format_heading(2, '%s module' % modfile) - text += format_directive(makename(subroot, submod), - master_package) - text += '\n' - text += '\n' - - if use_templates: - try: - package_ns = _get_mod_ns(name=subroot, fullname=fullname, - includeprivate=opts.includeprivate) - package_ns['subpackages'] = subs - package_ns['submodules'] = submods - - template = template_env.get_template('package.rst') - text = template.render(**package_ns) - - except ImportError as e: - _warn('failed to import %r: %s' % (fullname, e)) - else: - if not opts.modulefirst and not is_namespace: - text += format_heading(2, 'Module contents') - text += format_directive(subroot, master_package) - - write_file(makename(master_package, subroot), text, opts) - - -def create_modules_toc_file(modules, opts, name='modules'): - # type: (List[unicode], Any, unicode) -> None - """Create the module's index.""" - text = format_heading(1, '%s' % opts.header) - text += '.. toctree::\n' - text += ' :maxdepth: %s\n\n' % opts.maxdepth - - modules.sort() - prev_module = '' # type: unicode - for module in modules: - # look if the module is a subpackage and, if yes, ignore it - if module.startswith(prev_module + '.'): - continue - prev_module = module - text += ' %s\n' % module - - write_file(name, text, opts) - - -def shall_skip(module, opts): - # type: (unicode, Any) -> bool - """Check if we want to skip this module.""" - # skip if the file doesn't exist and not using implicit namespaces - if not opts.implicit_namespaces and not path.exists(module): - return True - - # skip it if there is nothing (or just \n or \r\n) in the file - if path.exists(module) and path.getsize(module) <= 2: - return True - - # skip if it has a "private" name and this is selected - filename = path.basename(module) - if filename != '__init__.py' and filename.startswith('_') and \ - not opts.includeprivate: - return True - return False - - -def recurse_tree(rootpath, excludes, opts): - # type: (unicode, List[unicode], Any) -> List[unicode] - """ - Look for every file in the directory tree and create the corresponding - ReST files. - """ - # check if the base directory is a package and get its name - if INITPY in os.listdir(rootpath): - root_package = rootpath.split(path.sep)[-1] - else: - # otherwise, the base is a directory with packages - root_package = None - - toplevels = [] - followlinks = getattr(opts, 'followlinks', False) - includeprivate = getattr(opts, 'includeprivate', False) - implicit_namespaces = getattr(opts, 'implicit_namespaces', False) - for root, subs, files in walk(rootpath, followlinks=followlinks): - # document only Python module files (that aren't excluded) - py_files = sorted(f for f in files - if path.splitext(f)[1] in PY_SUFFIXES and - not is_excluded(path.join(root, f), excludes)) - is_pkg = INITPY in py_files - is_namespace = INITPY not in py_files and implicit_namespaces - if is_pkg: - py_files.remove(INITPY) - py_files.insert(0, INITPY) - elif root != rootpath: - # only accept non-package at toplevel unless using implicit namespaces - if not implicit_namespaces: - del subs[:] - continue - # remove hidden ('.') and private ('_') directories, as well as - # excluded dirs - if includeprivate: - exclude_prefixes = ('.',) # type: Tuple[unicode, ...] - else: - exclude_prefixes = ('.', '_') - subs[:] = sorted(sub for sub in subs if not sub.startswith(exclude_prefixes) and - not is_excluded(path.join(root, sub), excludes)) - - if is_pkg or is_namespace: - # we are in a package with something to document - if subs or len(py_files) > 1 or not shall_skip(path.join(root, INITPY), opts): - subpackage = root[len(rootpath):].lstrip(path.sep).\ - replace(path.sep, '.') - # if this is not a namespace or - # a namespace and there is something there to document - if not is_namespace or len(py_files) > 0: - create_package_file(root, root_package, subpackage, - py_files, opts, subs, is_namespace) - toplevels.append(makename(root_package, subpackage)) - else: - # if we are at the root level, we don't require it to be a package - assert root == rootpath and root_package is None - if opts.templates: - sys.path.insert(0, rootpath) - for py_file in py_files: - if not shall_skip(path.join(rootpath, py_file), opts): - module = path.splitext(py_file)[0] - create_module_file(root_package, module, opts) - toplevels.append(module) - if opts.templates: - sys.path.pop(0) - - return toplevels - - -def normalize_excludes(rootpath, excludes): - # type: (unicode, List[unicode]) -> List[unicode] - """Normalize the excluded directory list.""" - return [path.abspath(exclude) for exclude in excludes] - - -def is_excluded(root, excludes): - # type: (unicode, List[unicode]) -> bool - """Check if the directory is in the exclude list. - - Note: by having trailing slashes, we avoid common prefix issues, like - e.g. an exlude "foo" also accidentally excluding "foobar". - """ - for exclude in excludes: - if fnmatch(root, exclude): - return True - return False - - -def main(argv=sys.argv): - # type: (List[str]) -> int - """Parse and check the command line arguments.""" - parser = optparse.OptionParser( - usage="""\ -usage: %prog [options] -o <output_path> <module_path> [exclude_pattern, ...] - -Look recursively in <module_path> for Python modules and packages and create -one reST file with automodule directives per package in the <output_path>. - -The <exclude_pattern>s can be file and/or directory patterns that will be -excluded from generation. - -Note: By default this script will not overwrite already created files.""") - - parser.add_option('-o', '--output-dir', action='store', dest='destdir', - help='Directory to place all output', default='') - parser.add_option('-d', '--maxdepth', action='store', dest='maxdepth', - help='Maximum depth of submodules to show in the TOC ' - '(default: 4)', type='int', default=4) - parser.add_option('-f', '--force', action='store_true', dest='force', - help='Overwrite existing files') - parser.add_option('-l', '--follow-links', action='store_true', - dest='followlinks', default=False, - help='Follow symbolic links. Powerful when combined ' - 'with collective.recipe.omelette.') - parser.add_option('-n', '--dry-run', action='store_true', dest='dryrun', - help='Run the script without creating files') - parser.add_option('-e', '--separate', action='store_true', - dest='separatemodules', - help='Put documentation for each module on its own page') - parser.add_option('-P', '--private', action='store_true', - dest='includeprivate', - help='Include "_private" modules') - parser.add_option('-T', '--no-toc', action='store_true', dest='notoc', - help='Don\'t create a table of contents file') - parser.add_option('-E', '--no-headings', action='store_true', - dest='noheadings', - help='Don\'t create headings for the module/package ' - 'packages (e.g. when the docstrings already contain ' - 'them). No effect in combination with -t') - parser.add_option('-M', '--module-first', action='store_true', - dest='modulefirst', - help='Put module documentation before submodule ' - 'documentation (no effect in combination with -t)') - parser.add_option('--implicit-namespaces', action='store_true', - dest='implicit_namespaces', - help='Interpret module paths according to PEP-0420 ' - 'implicit namespaces specification') - parser.add_option('-s', '--suffix', action='store', dest='suffix', - help='file suffix (default: rst)', default='rst') - parser.add_option('-F', '--full', action='store_true', dest='full', - help='Generate a full project with sphinx-quickstart') - parser.add_option('-a', '--append-syspath', action='store_true', - dest='append_syspath', - help='Append module_path to sys.path, used when --full is given') - parser.add_option("-t", "--templates", action="store", type="string", - dest="templates", default=None, - help="Custom template directory (default: %default). " - "Must contain template files package.rst and/or " - "module.rst") - parser.add_option('-H', '--doc-project', action='store', dest='header', - help='Project name (default: root module name)') - parser.add_option('-A', '--doc-author', action='store', dest='author', - type='str', - help='Project author(s), used when --full is given') - parser.add_option('-V', '--doc-version', action='store', dest='version', - help='Project version, used when --full is given') - parser.add_option('-R', '--doc-release', action='store', dest='release', - help='Project release, used when --full is given, ' - 'defaults to --doc-version') - parser.add_option('--version', action='store_true', dest='show_version', - help='Show version information and exit') - group = parser.add_option_group('Extension options') - for ext in EXTENSIONS: - group.add_option('--ext-' + ext, action='store_true', - dest='ext_' + ext, default=False, - help='enable %s extension' % ext) - - (opts, args) = parser.parse_args(argv[1:]) - - if opts.show_version: - #print('Sphinx (sphinx-apidoc) %s' % __display_version__) - print('better-apidoc %s' % __display_version__) - return 0 - - if not args: - parser.error('A package path is required.') - - rootpath, excludes = args[0], args[1:] - if not opts.destdir: - parser.error('An output directory is required.') - if opts.header is None: - opts.header = path.abspath(rootpath).split(path.sep)[-1] - if opts.suffix.startswith('.'): - opts.suffix = opts.suffix[1:] - if not path.isdir(rootpath): - print('%s is not a directory.' % rootpath, file=sys.stderr) - sys.exit(1) - if not path.isdir(opts.destdir): - if not opts.dryrun: - os.makedirs(opts.destdir) - rootpath = path.abspath(rootpath) - excludes = normalize_excludes(rootpath, excludes) - try: - modules = recurse_tree(rootpath, excludes, opts) - except TemplateNotFound as e: - print('Cannot find template in %s: %s' % - (opts.templates, e), file=sys.stderr) - sys.exit(1) - - if opts.full: - raise NotImplementedError("--full not supported") - # This would only make sense if this script was integrated in Sphinx - from sphinx import quickstart as qs - modules.sort() - prev_module = '' # type: unicode - text = '' - for module in modules: - if module.startswith(prev_module + '.'): - continue - prev_module = module - text += ' %s\n' % module - d = dict( - path = opts.destdir, - sep = False, - dot = '_', - project = opts.header, - author = opts.author or 'Author', - version = opts.version or '', - release = opts.release or opts.version or '', - suffix = '.' + opts.suffix, - master = 'index', - epub = True, - ext_autodoc = True, - ext_viewcode = True, - ext_todo = True, - makefile = True, - batchfile = True, - mastertocmaxdepth = opts.maxdepth, - mastertoctree = text, - language = 'en', - module_path = rootpath, - append_syspath = opts.append_syspath, - ) - enabled_exts = {'ext_' + ext: getattr(opts, 'ext_' + ext) - for ext in EXTENSIONS if getattr(opts, 'ext_' + ext)} - d.update(enabled_exts) - - if isinstance(opts.header, binary_type): - d['project'] = d['project'].decode('utf-8') - if isinstance(opts.author, binary_type): - d['author'] = d['author'].decode('utf-8') - if isinstance(opts.version, binary_type): - d['version'] = d['version'].decode('utf-8') - if isinstance(opts.release, binary_type): - d['release'] = d['release'].decode('utf-8') - - if not opts.dryrun: - qs.generate(d, silent=True, overwrite=opts.force) - elif not opts.notoc: - create_modules_toc_file(modules, opts) - return 0 - - -# So program can be started with "python -m sphinx.apidoc ..." -if __name__ == "__main__": - main() diff --git a/docs/generate.sh b/docs/generate.sh index 7ffc2cb909144274417b359d138c249225f66ce4..2235e40f308ce5facb43a5766b8002b22b51d681 100755 --- a/docs/generate.sh +++ b/docs/generate.sh @@ -1,4 +1,3 @@ rm -rf docs/build docs/source/mod sphinx-apidoc -l -e -d 2 -o docs/source/mod nifty4 -#python docs/better_apidoc.py -l -e -d 3 -t docs/generation-templates -o docs/source/mod nifty4 sphinx-build -b html docs/source/ docs/build/ diff --git a/docs/generation-templates/module.rst b/docs/generation-templates/module.rst deleted file mode 100644 index 785f59f930992d7222bd21dfd6df3bbd82325ae3..0000000000000000000000000000000000000000 --- a/docs/generation-templates/module.rst +++ /dev/null @@ -1,76 +0,0 @@ -{% if name %} -{{ name }} -{% for item in range(8 + name|length) -%}={%- endfor %} -{% else %} -{{ fullname }} -{% for item in range(8 + fullname|length) -%}={%- endfor %} -{% endif %} -({{ fullname }} module) - -.. currentmodule:: {{ fullname }} - -.. automodule:: {{ fullname }} - {% if members -%} - :members: {{ members|join(", ") }} - :undoc-members: - :show-inheritance: - :member-order: bysource - - Summary - ------- - - {%- if exceptions %} - - Exceptions: - - .. autosummary:: - :nosignatures: - {% for item in exceptions %} - {{ item }} - {%- endfor %} - {%- endif %} - - {%- if classes %} - - Classes: - - .. autosummary:: - :nosignatures: - {% for item in classes %} - {{ item }} - {%- endfor %} - {%- endif %} - - {%- if functions %} - - Functions: - - .. autosummary:: - :nosignatures: - {% for item in functions %} - {{ item }} - {%- endfor %} - {%- endif %} - {%- endif %} - - {%- if data %} - - Data: - - .. autosummary:: - :nosignatures: - {% for item in data %} - {{ item }} - {%- endfor %} - {%- endif %} - -{% if all_refs %} - ``__all__``: {{ all_refs|join(", ") }} -{%- endif %} - - -{% if members %} - Reference - --------- - -{%- endif %} diff --git a/docs/generation-templates/package.rst b/docs/generation-templates/package.rst deleted file mode 100644 index 490aa9506b1601410bab97ce89593038163d197b..0000000000000000000000000000000000000000 --- a/docs/generation-templates/package.rst +++ /dev/null @@ -1,103 +0,0 @@ -{% if name %} -{{ name }} -{% for item in range(8 + name|length) -%}={%- endfor %} -{% else %} -{{ fullname }} -{% for item in range(8 + fullname|length) -%}={%- endfor %} -{% endif %} -({{ fullname }} package) - -.. automodule:: {{ fullname }} - {% if members -%} - :members: {{ members|join(", ") }} - :undoc-members: - :show-inheritance: - {%- endif %} - - - {% if submodules %} - Submodules - ---------- - - .. toctree:: - :maxdepth: 1 - {% for item in submodules %} - {{ fullname }}.{{ item }} - {%- endfor %} - {%- endif -%} - - {% if subpackages %} - - - Subpackages - ----------- - - .. toctree:: - :maxdepth: 1 - {% for item in subpackages %} - {{ fullname }}.{{ item }} - {%- endfor %} - - - {%- endif %} - - {% if members %} - Summary - ------- - - {%- if exceptions %} - - Exceptions: - - .. autosummary:: - :nosignatures: - {% for item in exceptions %} - {{ item }} - {%- endfor %} - {%- endif %} - - {%- if classes %} - - Classes: - - .. autosummary:: - :nosignatures: - {% for item in classes %} - {{ item }} - {%- endfor %} - {%- endif %} - - {%- if functions %} - - Functions: - - .. autosummary:: - :nosignatures: - {% for item in functions %} - {{ item }} - {%- endfor %} - {%- endif %} - - {%- endif %} - - {%- if data %} - - Data: - - .. autosummary:: - :nosignatures: - {% for item in data %} - {{ item }} - {%- endfor %} - {%- endif %} - -{% if all_refs %} - ``__all__``: {{ all_refs|join(", ") }} -{%- endif %} - - -{% if members %} - Reference - --------- - -{%- endif %}