def run_apidoc(_):
from sphinx.ext.apidoc import main
args = ['-M', '--no-toc', '-o', './synapse/autodocs', '../synapse', ]
ignores = ['../synapse/tests']
args.extend(ignores)
main(args)
def run_apidoc(_):
from sphinx.ext.apidoc import main
cur_dir = os.path.normpath(os.path.dirname(__file__))
output_path = os.path.join(cur_dir, 'api')
modules = os.path.normpath(os.path.join(cur_dir, "../hyperspy"))
main(['-e', '-f', '-P', '-o', output_path, modules])
def run_apidoc(_):
ignore_paths = []
argv = ["-f", "-T", "-e", "-M", "-o", ".", ".."] + ignore_paths
try: # Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError: # Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
def run_apidoc(_):
from sphinx.ext.apidoc import main
cur_dir = os.path.normpath(os.path.dirname(__file__))
output_path = os.path.join(cur_dir, '_apidoc')
modules = os.path.normpath(os.path.join(cur_dir, "../modules"))
exclusions = [
'../modules/isogeo_pysdk',
'../ui',
'../test',
]
main(['-e', '-f', '-M', '-o', output_path, modules] + exclusions)
def run_apidoc(_):
root = os.path.join('..', 'ample')
ignore_paths = [os.path.join(root, '*', 'tests')]
argv = ['-f', '-T', '-e', '-M', '-o', os.path.join('api', 'generated'), root] + ignore_paths
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
def run_apidoc(_):
"""Run apidoc."""
try:
from sphinx.ext.apidoc import main # sphinx => 1.7.0b1
except ImportError:
from sphinx.apidoc import main
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
cur_dir = os.path.abspath(os.path.dirname(__file__))
module = os.path.join(cur_dir, "..", project)
params = ['-e', '--force', '--separate', '--private', '--follow-links',
'-o', cur_dir, module]
main(params)
def run_apidoc(_):
"""This method is required by the setup method below."""
ignore_paths = ['opentimelineio_contrib.adapters', 'tests', 'setup.py']
# https://github.com/sphinx-doc/sphinx/blob/master/sphinx/ext/apidoc.py
argv = [
'--force',
'--no-toc',
# '--separate',
'--module-first',
'--output-dir',
'./api/modules',
'../opentimelineio'
] + ignore_paths
from sphinx.ext import apidoc
apidoc.main(argv)
def run_apidoc():
"""Run sphinx-apidoc"""
# Get location of Sphinx files
sphinx_source_dir = os.path.abspath(os.path.dirname(__file__))
repo_dir = os.path.abspath(os.path.join(sphinx_source_dir, os.path.pardir, os.path.pardir))
apidoc_dir = os.path.join(sphinx_source_dir, "api-doc")
# Include these modules
modules = ['fenapack']
for module in modules:
# Generate .rst files ready for autodoc
module_dir = os.path.join(repo_dir, module)
argv = [
"-f", # Overwrite existing files
#"-T", # Don't create a table of contents file
#"-P", # Include "_private" modules
#"-M", # Put module doc before submodule doc
"-d", "1", # Maximum depth of submodules to show in the TOC
"-o", apidoc_dir, # Directory to place all output
module_dir # Module directory
]
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.OPTIONS = [
"members",
"special-members",
#"private-members",
#"undoc-members",
"show-inheritance"
]
apidoc.main(argv)
def run_apidoc(_):
import os
print('run_apidoc: current dir is %s' % os.getcwd())
ignore_paths = [
os.path.join('oapackage', 'markup.py'),
'get_artifacts.py',
'untitled*.py', 'doxy2swig.py', 'setup.py'
]
ignore_paths = [os.path.join('..', file) for file in ignore_paths]
argv = [
"-f",
# "-T",
# "-e",
"-M",
"-o", ".",
os.path.join("..")
#os.path.join("..", 'oapackage')
] + ignore_paths
sphinxcmd = 'sphinx-apidoc ' + ' '.join(argv)
if rtd:
print(sphinxcmd)
if 1:
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError as ex:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
else:
subprocess.call('dir' , shell=True)
subprocess.call(sphinxcmd, shell=True)
def run_apidoc(_):
current_dir = os.path.abspath(os.path.dirname(__file__))
module = os.path.join(current_dir, "..", "dipper")
argv = [
"-f",
"-T",
"-e",
"-M",
"-o", current_dir,
module
]
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
shutil.rmtree(output_dir)
except FileNotFoundError:
pass
try:
import sphinx
from distutils.version import LooseVersion
cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
cmd_line = cmd_line_template.format(outputdir=output_dir, moduledir=module_dir)
args = cmd_line.split(" ")
if LooseVersion(sphinx.__version__) >= LooseVersion('1.7'):
args = args[1:]
apidoc.main(args)
except Exception as e:
print("Running `sphinx-apidoc` failed!\n{}".format(e))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo',
'sphinx.ext.autosummary', 'sphinx.ext.viewcode', 'sphinx.ext.coverage',
'sphinx.ext.doctest', 'sphinx.ext.ifconfig', 'sphinx.ext.mathjax',
'sphinx.ext.napoleon']
def run_apidoc(app):
from sphinx.ext.apidoc import main
module = os.path.abspath(os.path.join(app.srcdir, '..', 'labgrid'))
output = os.path.abspath(os.path.join(app.srcdir, 'modules'))
cmd = [module, '-a', '-M', '-H', 'Modules', '-o', output]
main(cmd)
def run_apidoc(_):
output_path = os.path.join(repo_root, 'docs', 'source', 'api')
apidoc.main(['-o', output_path, '-f', pkg_root])
caldera_root_dir = pathlib.Path('../../..').absolute()
sys.path.insert(0, str(caldera_root_dir))
from plugins.fieldmanual.utils.ability_csv import generate_ability_csv
# Call sphinx-apidoc to generate stub files from our source code.
# -o generated: output rst stubs to this directory
# --implicit-namespaces: will find modules in packages without explicit __init__.py
# --force: overwrite existing generated stubs
# ../app/: this is the directory where caldera lives
apidocs_argv = [
'-o', '_generated', '--implicit-namespaces', '--force',
str(caldera_root_dir / 'app')
]
apidoc.main(apidocs_argv)
# Export csv info to csv:
generate_ability_csv(caldera_root_dir, "_generated/abilities.csv")
# -- Project information -----------------------------------------------------
project = 'caldera'
copyright = '2020, The MITRE Corporation'
author = 'The MITRE Corporation'
master_doc = 'index'
# -- General configuration ---------------------------------------------------
extensions = [
'sphinx.ext.autodoc',
'recommonmark',
def RunSphinxAPIDoc(_):
"""Runs sphinx-apidoc to auto-generate documentation."""
current_directory = os.path.abspath(os.path.dirname(__file__))
module = os.path.join(current_directory, '..', 'l2tscaffolder')
api_directory = os.path.join(current_directory, 'sources', 'api')
apidoc.main(['-o', api_directory, module, '--force'])
def filtered_files(base, unfiltered_files_filename):
with open(unfiltered_files_filename) as f:
lines = [line.rstrip() for line in f]
# Skip comments and empty lines to get list of files we DON'T want to
# filter out; this is definitely complicated
unfiltered = set(
line for line in lines if not line.startswith("#") and line != "")
for root, _dirs, files in os.walk(base):
for filename in files:
if filename.endswith(".py") and not filename.startswith("_"):
full = root + "/" + filename
if full not in unfiltered:
yield full
_output_dir = os.path.abspath(".")
_unfiltered_files = os.path.abspath("../unfiltered-files.txt")
# Do the rst generation; remove files which aren't in git first!
for fl in os.listdir("."):
if (os.path.isfile(fl) and fl.endswith(".rst") and
fl not in ("index.rst", "modules.rst")):
os.remove(fl)
os.chdir("../..") # WARNING! RELATIVE FILENAMES CHANGE MEANING HERE!
apidoc.main([
'-o', _output_dir, _package_base,
"spinnman/messages/spinnaker_boot/boot_data/*",
# Special case: Don't want that empty package at all.
*filtered_files(_package_base, _unfiltered_files)])
import datetime
from pathlib import Path
from sphinx.ext import apidoc
copyright = f"{datetime.datetime.now().year}, Evrone"
# Auto generate documentation
if False:
apidoc.main([
'-f', # force overwrite
'-T', # no modules.rst toc
'-e', # Each module on it's own page
'-o',
str(Path(__file__).parent), # Output dir relative to "Sphinx root"
str(Path(__file__).parent.parent / 'toggl_python') # Source code root
])
def run_api_doc(_):
"""
Automatic API generator
This method is used to generate API automatically by importing all the
modules and sub-modules inside a package.
It is equivalent to run:
>>> sphinx-apidoc --force --no-toc --separate --module --output-dir api/ ../../ ../../cal_service
It is useful because it creates .rst files on the file.
NOTE
----
This does not work with PyCharm default build. If you want to trigger
this function, use the standard `$ make html` in the command line.
The .rst files will be generated. After that, you can use PyCharm's
build helper.
"""
build_packages = [
'astrodata',
'gemini_instruments'
]
current_path = os.getcwd()
relative_path = "../../../"
print("Current Path:", current_path)
for p in build_packages:
build_path = os.path.join(current_path, relative_path, p)
ignore_paths = [
'doc',
'test',
]
ignore_paths = [os.path.join(build_path, i) for i in ignore_paths]
argv = [
"--force",
"--no-toc",
# "--separate",
"--module",
"--output-dir", "api/",
build_path
] + ignore_paths
sys.path.insert(0, build_path)
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
def run_apidoc(_):
sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
cur_dir = os.path.abspath(os.path.dirname(__file__))
output_dir = os.path.join(cur_dir, "api")
module = os.path.join(cur_dir, "..", "src", "fastoad")
apidoc.main(["-d", "1", "-e", "-o", output_dir, module, "--force"])
def run_apidoc(_):
from sphinx.ext.apidoc import main
main(['-feTM', '-o', '_api', '../ckipnlp'])
def run_apidoc(_):
from sphinx.ext.apidoc import main
main(['-feTM', '-t', './_templates', '-o', '_api', '../ehn'])
'pyiron', 'One line description of project.', 'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
main(['-e', '-o', 'apidoc', '../pyiron', '--force'])
curdir = os.path.dirname(os.path.abspath(__file__))
if os.path.exists(os.path.join(curdir, 'source/notebooks')):
shutil.rmtree(os.path.join(curdir, 'source/notebooks'))
shutil.copytree(os.path.join(curdir, '..', 'notebooks'),
os.path.join(curdir, 'source/notebooks'))
if 'readthedocs.org' in curdir: # write config for readthedocs.org
with open(os.path.join(os.path.expanduser('~/.pyiron')), 'w') as f:
f.writelines([
'[DEFAULT]', 'TOP_LEVEL_DIRS = ' + os.path.join(curdir, '..'),
'RESOURCE_PATHS = ' + os.path.join(curdir, '..') + '/tests/static'
])
def builder_inited(app):
# type: (Sphinx) -> None
module_dir = app.config.apidoc_module_dir
output_dir = path.join(app.srcdir, app.config.apidoc_output_dir)
excludes = app.config.apidoc_excluded_paths
separate_modules = app.config.apidoc_separate_modules
toc_file = app.config.apidoc_toc_file
module_first = app.config.apidoc_module_first
extra_args = app.config.apidoc_extra_args
if toc_file and sphinx.version_info < (1, 8, 0):
logger.warning("'apidoc_toc_file' is only supported by Sphinx "
"1.8+; skipping API doc generation")
return
if not module_dir:
logger.warning("No 'apidoc_module_dir' specified; skipping API doc "
"generation")
return
# if the path is relative, make it relative to the 'conf.py' directory
if not path.isabs(module_dir):
module_dir = path.abspath(path.join(app.srcdir, module_dir))
if not path.exists(module_dir):
logger.warning(
"The path defined in 'apidoc_module_dir' does not "
"exist; skipping API doc generation; %s", module_dir)
return
# refactor this module so that we can call 'recurse_tree' like a sane
# person - at present there is way too much passing around of the
# 'optparse.Value' instance returned by 'optparse.parse_args'
def cmd_opts():
if _ignore_first_arg:
yield 'sphinxcontrib-apidoc'
yield '--force'
if separate_modules:
yield '--separate'
if isinstance(toc_file, bool) and toc_file is False:
yield '--no-toc'
elif toc_file:
yield '--tocfile'
yield toc_file
if module_first:
yield '--module-first'
yield '--output-dir'
yield output_dir
for arg in extra_args:
yield arg
yield module_dir
for exc in excludes:
yield path.abspath(path.join(module_dir, exc))
apidoc.main(list(cmd_opts()))
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if on_rtd:
os.environ['SPHINX_APIDOC_OPTIONS'] = ','.join(
['members', 'undoc-members', 'inherited-members', 'show-inheritance'])
import sphinx.ext.apidoc as apidoc
__location__ = os.path.join(
os.getcwd(), os.path.dirname(inspect.getfile(inspect.currentframe())))
output_dir = os.path.join(__location__, "../docs/api")
module_dir = os.path.join(__location__, "../pytesmo")
cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
cmd_line = cmd_line_template.format(outputdir=output_dir,
moduledir=module_dir)
print(cmd_line)
apidoc.main(cmd_line.split(" ")[1:])
__location__ = os.path.join(
os.getcwd(), os.path.dirname(inspect.getfile(inspect.currentframe())))
package = "pytesmo"
namespace = []
namespace_pkg = ".".join([namespace[-1], package]) if namespace else package
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# sys.path.insert(0, os.path.abspath('.'))
# -- General configuration -----------------------------------------------
import os
import shlex
import django
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
os.environ['DJANGO_SETTINGS_MODULE'] = 'example.settings'
django.setup()
# Auto-generate API documentation.
from sphinx.ext.apidoc import main
main([
'sphinx-apidoc', '-e', '-T', '-M', '-f', '-o', 'apidoc',
'../rest_framework_json_api'
])
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ['sphinx.ext.autodoc']
autodoc_member_order = 'bysource'
autodoc_inherit_docstrings = False
# Add any paths that contain templates here, relative to this directory.
def run_api_doc(_):
"""
Automatic API generator
This method is used to generate API automatically by importing all the
modules and sub-modules inside a package.
It is equivalent to run:
>>> sphinx-apidoc --force --no-toc --separate --module --output-dir api/ ../../ ../../cal_service
It is useful because it creates .rst files on the fly.
NOTE
----
This does not work with PyCharm default build. If you want to trigger
this function, use the standard `$ make html` in the command line.
The .rst files will be generated. After that, you can use PyCharm's
build helper.
"""
build_packages = [
#'gempy',
#'geminidr',
'recipe_system',
]
is_running_in_pycharm = "PYCHARM_HOSTED" in os.environ
if is_running_in_pycharm:
current_path = os.path.split(__file__)[0]
else:
current_path = os.getcwd()
relative_path = "../../../"
print("\n Am I running on PyCharm? {}".format(is_running_in_pycharm))
print(" Current Path: {}\n".format(current_path))
for p in build_packages:
build_path = os.path.normpath(
os.path.join(current_path, relative_path, p)
)
print('\n Building API using the following build_path: {}\n'.format(
build_path))
ignore_paths = [
'doc',
'test',
]
ignore_paths = [os.path.join(build_path, i) for i in ignore_paths]
api_path = os.path.normpath(os.path.join(current_path, 'api'))
argv = [
"--force",
"--no-toc",
"--module",
"--output-dir", api_path,
build_path
] + ignore_paths
sys.path.insert(0, build_path)
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
def run_apidoc(_):
from sphinx.ext.apidoc import main
main(['../pytest_kafka', '-o', 'source/', '-fMe'])
def _sphinx_tree(self):
source_dir = self._get_source_dir()
cmd = ['-H', 'Modules', '-o', source_dir, '.']
if apidoc_use_padding:
cmd.insert(0, 'apidoc')
apidoc.main(cmd + self.autodoc_tree_excludes)
def run_apidoc(_):
"""Adds the sphinx-apidoc command as a callback during the build process."""
main([
"-MTfe", "-t", f"{CURR_DIR}/template/api", "-o", f"{CURR_DIR}/api",
f"{ROOT_DIR}/{TOOL_CONFIG['name']}"
])
def filtered_files(base, unfiltered_files_filename):
with open(unfiltered_files_filename) as f:
lines = [line.rstrip() for line in f]
# Skip comments and empty lines to get list of files we DON'T want to
# filter out; this is definitely complicated
unfiltered = set(line for line in lines
if not line.startswith("#") and line != "")
for root, _dirs, files in os.walk(base):
for filename in files:
if filename.endswith(".py") and not filename.startswith("_"):
full = root + "/" + filename
if full not in unfiltered:
yield full
_output_dir = os.path.abspath(".")
_unfiltered_files = os.path.abspath("../unfiltered-files.txt")
# Do the rst generation; remove files which aren't in git first!
for fl in os.listdir("."):
if (os.path.isfile(fl) and fl.endswith(".rst")
and fl not in ("index.rst", "modules.rst")):
os.remove(fl)
os.chdir("../..") # WARNING! RELATIVE FILENAMES CHANGE MEANING HERE!
apidoc.main([
'-o', _output_dir, _package_base,
*filtered_files(_package_base, _unfiltered_files)
])
def run_apidoc(_):
ignore_paths = []
argv = [
"--force", "--module-first", "-o", "./modules", "../../our_package"
] + ignore_paths
apidoc.main(argv)
from kartothek import __version__ as version
package = "kartothek"
nitpicky = True
__location__ = os.path.join(
os.getcwd(), os.path.dirname(inspect.getfile(inspect.currentframe())))
# Generate module references
output_dir = os.path.abspath(os.path.join(__location__, "../docs/_rst"))
module_dir = os.path.abspath(os.path.join(__location__, "..", package))
apidoc_parameters = ["-f", "-e", "-o", output_dir, module_dir]
apidoc.main(apidoc_parameters)
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.append(
os.path.abspath(os.path.join(os.path.dirname(__file__), "sphinxext")))
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
"ignore_missing_refs",
"sphinx.ext.autodoc",
"sphinx.ext.intersphinx",
"sphinx.ext.todo",
"sphinx.ext.autosummary",
module_cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
module_cmd_line = module_cmd_line_template.format(outputdir=output_dir,
moduledir=module_dir)
module_args = module_cmd_line.split(" ")
test_cmd_line_template = "sphinx-apidoc -f -o {outputdir} {testdir} --tocfile tests"
test_cmd_line = test_cmd_line_template.format(outputdir=output_dir,
testdir=test_dir)
test_args = test_cmd_line.split(" ")
if parse_version(sphinx.__version__) >= parse_version('1.7'):
module_args = module_args[1:]
test_args = test_args[1:]
apidoc.main(module_args)
apidoc.main(test_args)
except Exception as e:
print("Running `sphinx-apidoc` failed!\n{}".format(e))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo',
'sphinx.ext.autosummary', 'sphinx.ext.viewcode', 'sphinx.ext.coverage',
'sphinx.ext.doctest', 'sphinx.ext.ifconfig', 'sphinx.ext.mathjax',
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Sphinx - Python documentation toolchain
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: Copyright 2007-2017 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import sys
if __name__ == '__main__':
from sphinx.ext.apidoc import main
sys.exit(main(sys.argv[1:]))
except FileNotFoundError:
pass
try:
import sphinx
from pkg_resources import parse_version
cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
cmd_line = cmd_line_template.format(
outputdir=output_dir, moduledir=module_dir)
args = cmd_line.split(" ")
if parse_version(sphinx.__version__) >= parse_version('1.7'):
args = args[1:]
apidoc.main(args)
except Exception as e:
print("Running `sphinx-apidoc` failed!\n{}".format(e))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx',
'sphinx.ext.todo', 'sphinx.ext.autosummary',
'sphinx.ext.viewcode', 'sphinx.ext.coverage',
'sphinx.ext.doctest', 'sphinx.ext.ifconfig',
'sphinx.ext.mathjax', 'sphinx.ext.napoleon',
def run_apidoc(_):
main([
"-f", "-o", "doc/source/reference", "octant/", "octant/tests/*.py",
"octant/front/parser.py"
])
def setup(app):
from sphinx.ext import apidoc
app.connect('builder-inited', lambda _: apidoc.main([
'-o', './api', '-d2', '-feMT', '../src/madgui',
]))
import sys
import django
from sphinx.ext.apidoc import main
from rest_framework_json_api import VERSION
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath(".."))
os.environ["DJANGO_SETTINGS_MODULE"] = "example.settings"
django.setup()
# Auto-generate API documentation.
main(["-o", "apidoc", "-f", "-e", "-T", "-M", "../rest_framework_json_api"])
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ["sphinx.ext.autodoc", "recommonmark"]
autodoc_member_order = "bysource"
autodoc_inherit_docstrings = False
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
def run_apidoc(_):
"""Generate API Documentation"""
ignore_paths = []
argv = ["-f", "-e", "-o", "apidoc", "../ceph"] + ignore_paths
apidoc.main(argv)
def run_api_doc(_):
"""
Automatic API generator
This method is used to generate API automatically by importing all the
modules and sub-modules inside a package.
It is equivalent to run:
>>> sphinx-apidoc --force --no-toc --separate --module --output-dir api/ ../../ ../../cal_service
It is useful because it creates .rst files on the fly.
NOTE
----
This does not work with PyCharm default build. If you want to trigger
this function, use the standard `$ make html` in the command line.
The .rst files will be generated. After that, you can use PyCharm's
build helper.
"""
build_packages = [
# 'gempy',
# 'geminidr',
'recipe_system',
]
is_running_in_pycharm = "PYCHARM_HOSTED" in os.environ
if is_running_in_pycharm:
current_path = os.path.split(__file__)[0]
else:
current_path = os.getcwd()
relative_path = "../../../"
print(("\n Am I running on PyCharm? {}".format(is_running_in_pycharm)))
print((" Current Path: {}\n".format(current_path)))
for p in build_packages:
build_path = os.path.normpath(
os.path.join(current_path, relative_path, p))
print(('\n Building API using the following build_path: {}\n'.format(
build_path)))
ignore_paths = [
'doc',
'test',
]
ignore_paths = [os.path.join(build_path, i) for i in ignore_paths]
api_path = os.path.normpath(os.path.join(current_path, 'api'))
argv = [
"--force", "--no-toc", "--module", "--output-dir", api_path,
build_path
] + ignore_paths
sys.path.insert(0, build_path)
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
def run_apidoc(_):
from sphinx.ext.apidoc import main
shutil.rmtree("api", ignore_errors=True)
main(["-f", "-o", "api", "../python/rikai"])
def createDocs(self,
docs_path: str = "",
mode: str = "build"): # pragma: no cover
"""Dokumentation erzeugen oder erneuern.
Parameters
----------
docs_path : str, optional
Pfad nach ui-docs. The default is "".
mode : str, optional
Mit rebuild komplett neu erzeugen sonst nur erneuern. The default is "build".
Returns
-------
bool
``True`` wenn erzeugt wurde, sonst ``False``.
"""
import sphinx.ext.apidoc as apidoc
import sphinx.cmd.build as build
if mode == "rebuild" and osp.isdir(docs_path):
from shutil import rmtree
try:
rmtree(docs_path)
except:
return False
# ohne docs_path vorlage aus helper/docs kopieren
if not osp.isdir(docs_path) or not osp.isdir(
osp.join(docs_path, "build")):
# conf und _static kopieren
from distutils.dir_util import copy_tree
# vorlage kopieren
#
from_path = osp.join(osp.dirname(osp.abspath(__file__)), "helper",
"sphinx")
if not osp.isdir(docs_path):
os.mkdir(docs_path)
# das soll eigentlich copy_tree machen
os.mkdir(osp.join(docs_path, "source"))
os.mkdir(osp.join(docs_path, "source", "_ext"))
os.mkdir(osp.join(docs_path, "source", "_static"))
try:
copy_tree(from_path, docs_path)
except:
logger.debug("ERROR copy_tree {} {}".format(
from_path, docs_path))
print("ERROR copy_tree {} {}".format(from_path, docs_path))
return False
# original docs auch kopieren
#
org_docs_from_path = osp.join(self._config.get("BASE_DIR", ""),
'docs')
if osp.isdir(org_docs_from_path):
org_docs_to = osp.join(docs_path, "source", "docs")
try:
copy_tree(org_docs_from_path, org_docs_to)
except:
logger.debug("ERROR copy_tree {} {}".format(
org_docs_from_path, docs_path))
# es wurde nichts angelegt - Fehlermeldung ausgeben
if not osp.isdir(docs_path):
print("### createDocs no path", docs_path)
return False
# ausführungs Pfad auf docs_path ändern
os.chdir(docs_path)
# ---- 1. rst Dateien in source erzeugen
api_cmd = [
'--force', # force
'-osource/', # destdir
'../', # module_path
'../tests*', # exclude_pattern tests
'../ui*' # weitere exclude_pattern
]
apidoc.main(api_cmd)
# ---- 2. html aus rst Dateien in build erzeugen
#
# get project information from main version file
import version as v
build_cmd = [
'source', 'build', '-Dcopyright={}'.format(v.__copyright__),
'-Dauthor={}'.format(v.__author__), '-Dproject={}'.format(
self._config.get("server.webserver.title", v.__project__)),
'-Dversion={}'.format(v.__version__),
'-Drelease={}'.format(v.__version__)
]
build.main(build_cmd)
return True
def _sphinx_tree(self):
source_dir = self._get_source_dir()
cmd = ['-H', 'Modules', '-o', source_dir, '.']
if apidoc_use_padding:
cmd.insert(0, 'apidoc')
apidoc.main(cmd + self.autodoc_tree_excludes)
# Since some parameters are sadly hardcoded, it follows some dirty editing:
conf_py = os.path.join(OUT_DIR, "conf.py")
with open(conf_py, "r+") as f: # open in read/write mode:
lines = f.readlines()
os.remove(conf_py)
# remove line, append text at beginning and at end:
try:
lines.pop(lines.index(REMOVE_LINE))
except ValueError:
print("WARNING: EXPECTED LINE DIDN'T EXIST:", REMOVE_LINE)
lines.insert(1, EXTRA_BEGIN + "\n")
lines.append(EXTRA_END + "\n")
# rewrite edited file to its original path
with open(conf_py, "w") as f:
f.writelines(lines)
# Another dirty hack: the cleanest way to create a fresh apidoc is removing
# the existing index.rst and running apidoc:
os.remove(os.path.join(OUT_DIR, "index.rst"))
apidoc_argv = ["-F", PACKAGE_NAME, "-o", OUT_DIR]
sphinx_apidoc.main(argv=apidoc_argv)
# Finally call sphinx build (in its make-mode variant):
build_output = os.path.join(OUT_DIR, "_build")
build_html_args = ["html", OUT_DIR, build_output]
sphinx_build.run_make_mode(args=build_html_args)
if BUILD_PDF:
build_pdf_args = ["latexpdf", OUT_DIR, build_output]
sphinx_build.run_make_mode(args=build_pdf_args)
def run_api_doc(_):
"""
Automatic API generator
This method is used to generate API automatically by importing all the
modules and sub-modules inside a package.
It is equivalent to run:
>>> sphinx-apidoc --force --no-toc --separate --module --output-dir api/ ../../ ../../cal_service
It is useful because it creates .rst files on the file.
NOTE
----
This does not work with PyCharm default build. If you want to trigger
this function, use the standard `$ make html` in the command line.
The .rst files will be generated. After that, you can use PyCharm's
build helper.
"""
build_packages = [
'astrodata',
'gemini_instruments'
]
current_path = os.getcwd()
relative_path = "../../../"
print("Current Path:", current_path)
for p in build_packages:
build_path = os.path.join(current_path, relative_path, p)
ignore_paths = [
'doc',
'test',
]
ignore_paths = [os.path.join(build_path, i) for i in ignore_paths]
argv = [
"--force",
"--no-toc",
# "--separate",
"--module",
"--output-dir", "api/",
build_path
] + ignore_paths
sys.path.insert(0, build_path)
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
# use apidoc to generate developer doc
try:
from sphinx.ext.apidoc import main
except ImportError:
from sphinx.apidoc import main
destdir = os.path.abspath(os.path.join(project_root, "doc", "_dvlpt"))
if not os.path.isdir(destdir):
os.makedirs(destdir)
main([
'-e', '-o', destdir, '-d', '4', '-s', source_suffix[1:], '--force', src_dir
])
# #}
