def get_module_doc():
"""Gives the module documentation object."""
context = pdoc.Context()
module = pdoc.Module(temptree, context=context)
pdoc.link_inheritance(context=context)
return module
def docs(outdir="."):
"""Auto-generate documentation for wsp-tools in html.
**Parameters**
* **outdir** : _string_ <br />
The directory to write the output documentation. <br />
Default is "./".
"""
modules = ['wsp_tools']
context = pdoc.Context()
modules = [pdoc.Module(mod, context=context) for mod in modules]
pdoc.link_inheritance(context)
def recursive_htmls(mod):
yield mod.url(), mod.html()
for submod in mod.submodules():
yield from recursive_htmls(submod)
for mod in modules:
for module_url, html in recursive_htmls(mod):
output_url = Path(outdir).expanduser().joinpath(module_url)
if not Path(output_url).parent.exists():
Path(output_url).parent.mkdir(parents=True)
with open(output_url, "w+") as f:
f.write(html)
print("Documentation for wsp-tools written to: \n{}:".format(
Path(outdir).joinpath(modules[0].url())))
def get_module_doc():
"""Gives the module documentation object."""
context = pdoc.Context()
module = pdoc.Module(pytest_notimplemented, context=context)
pdoc.link_inheritance(context=context)
return module
def generate_docs(docs_dir: str):
"""
python callable that creates docs like docs/textwalker.html, docs/patternparser.py
Args:
docs_dir: location to output docs to
"""
if not os.path.exists(docs_dir):
print(f'{docs_dir} does not exist; creating dir')
os.mkdir(docs_dir)
mod_names = [
"textwalker", "textwalker.textwalker", "textwalker.pattern_parser",
"textwalker.utils"
]
context = pdoc.Context()
modules = [pdoc.Module(mod, context=context) for mod in mod_names]
pdoc.link_inheritance(context)
for module in modules:
if module.name == "textwalker":
filepath = os.path.join(docs_dir, 'index.html')
else:
pkg, modname = module.name.split('.')
filename = f'{modname}.html'
filepath = os.path.join(docs_dir, filename)
with open(filepath, 'w', encoding='utf-8') as fp:
fp.write(module.html())
print(f'wrote docs for module {module.name} to {filepath}')
def get_package_modules(src: str = DEFAULT_PACKAGE_DIRECTORY) -> list:
# Public submodules are auto-imported
context = pdoc.Context()
modules = [pdoc.Module(mod, context=context) for mod in [
src,
]]
pdoc.link_inheritance(context)
return modules
def test_pdoc3():
modules = ["test_pdoc3_docstring_parser"]
context = pdoc.Context()
modules = [pdoc.Module(mod, context=context) for mod in modules]
pdoc.link_inheritance(context)
#
for module in modules:
for function in module.functions():
na = function.name
mo = function.module
ob = function.obj
do = function.docstring
ih = function.inherits
fd = function.funcdef()
pa = function.params(annotate=True)
ra = function.return_annotation()
pass
html = module.html()
def __init__(self, path, destination, name="docs", templates=None):
"""Set notes templates. Initialize `pdoc` linker.
Parameters
----------
path : pathlib.Path
path to directory containing `.py` files with notes
templates : pathlib.Path or None, optional
path to directory containing customized templates which will be
used to create `html` notes (default is `None`)
"""
self.destination = destination
self.name = name
self.set_templates(templates)
context = pdoc.Context()
source = str(path / destination.name)
self.module = pdoc.Module(source, context=context)
pdoc.link_inheritance(context)
def _api_modules():
def _recursive_htmls(mod):
yield mod.name, mod.html()
for submod in mod.submodules():
yield from _recursive_htmls(submod)
modules = ["pyatv"]
context = pdoc.Context()
modules = [
pdoc.Module(mod, context=context, docfilter=_filter_func) for mod in modules
]
pdoc.link_inheritance(context)
for mod in modules:
for module_name, html in _recursive_htmls(mod):
splitted = module_name.split(".")
splitted[-1] = splitted[-1] + ".html"
output_file = os.path.join("docs", "api", *splitted)
yield output_file, html
"""scrapli.docs.generate"""
import pdoc
from pdoc import _render_template, tpl_lookup
context = pdoc.Context()
module = pdoc.Module("scrapli", context=context)
pdoc.link_inheritance(context)
tpl_lookup.directories.insert(0, "docs/generate")
doc_map = {
"scrapli.driver.base.base_driver": {"path": "driver/base/base_driver", "content": None},
"scrapli.driver.base.sync_driver": {"path": "driver/base/sync_driver", "content": None},
"scrapli.driver.base.async_driver": {"path": "driver/base/async_driver", "content": None},
"scrapli.driver.generic.base_driver": {"path": "driver/generic/base_driver", "content": None},
"scrapli.driver.generic.sync_driver": {"path": "driver/generic/sync_driver", "content": None},
"scrapli.driver.generic.async_driver": {"path": "driver/generic/async_driver", "content": None},
"scrapli.driver.network.base_driver": {"path": "driver/network/base_driver", "content": None},
"scrapli.driver.network.sync_driver": {"path": "driver/network/sync_driver", "content": None},
"scrapli.driver.network.async_driver": {"path": "driver/network/async_driver", "content": None},
"scrapli.driver.core.arista_eos.base_driver": {
"path": "driver/core/arista_eos/base_driver",
"content": None,
},
"scrapli.driver.core.arista_eos.sync_driver": {
"path": "driver/core/arista_eos/sync_driver",
"content": None,
},
"scrapli.driver.core.arista_eos.async_driver": {
"path": "driver/core/arista_eos/async_driver",
"content": None,
},
with open("aux.py", "w") as aux:
aux.write("from clingo import *\nfrom abc import *\nfrom typing import *\n")
for _, name, obj in SUB:
parse_class(aux, name, obj.__doc__)
import aux
return aux
clingo.ast.__spec__ = importlib.machinery.ModuleSpec("clingo.ast", None)
clingo.__pdoc__ = {}
for key, name, obj in SUB:
clingo.__pdoc__[key] = re.sub(r"```python.*?class ({}(\([^)]*\))?):.*?```".format(name), "", obj.__doc__, flags=re.MULTILINE|re.DOTALL)
pdoc.tpl_lookup.directories.insert(0, './templates')
ctx = pdoc.Context()
cmod = pdoc.Module(clingo, context=ctx)
amod = pdoc.Module(clingo.ast, supermodule=cmod, context=ctx)
xmod = parse_aux()
cmod.doc["Application"] = pdoc.Class("Application", cmod, xmod.Application)
cmod.doc["Observer"] = pdoc.Class("Observer", cmod, xmod.Observer)
cmod.doc["Propagator"] = pdoc.Class("Propagator", cmod, xmod.Propagator)
cmod.doc["ast"] = amod
cmod.doc["__version__"] = pdoc.Variable("__version__", cmod, "__version__: str\n\nVersion of the clingo module (`'{}'`).".format(clingo.__version__))
cmod.doc["Infimum"] = pdoc.Variable("Infimum", cmod, '''Infimum: Symbol\n\nRepresents a symbol of type `clingo.SymbolType.Infimum`.''')
cmod.doc["Supremum"] = pdoc.Variable("Supremum", cmod, '''Supremum: Symbol\n\nRepresents a symbol of type `clingo.SymbolType.Supremum`.''')
pdoc.link_inheritance(ctx)
prefix = "../clingo/python-api/{}".format(".".join(clingo.__version__.split(".")[:2]))
def load_toplevel(toplevel_name):
context = pdoc.Context()
toplevel = pdoc.Module(toplevel_name, context=context)
pdoc.link_inheritance(context)
return toplevel
