.. _l-functions:

Functions
=========

.. contents::
    :local:
    :depth: 1


Summary
+++++++

+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| function                                                                                                                            | class parent | truncated documentation                                                                                                                                                                            |
+=====================================================================================================================================+==============+====================================================================================================================================================================================================+
| :func:`GetLogFile <pyquickhelper.loghelper.flog.GetLogFile>`                                                                        |              | Returns a file name containing the log                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`GetPath <pyquickhelper.loghelper.flog.GetPath>`                                                                              |              | returns a path where the log file is stored.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`GetSepLine <pyquickhelper.loghelper.flog.GetSepLine>`                                                                        |              | Always returns ``\n``                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`IsEmptyString <pyquickhelper.loghelper.flog.IsEmptyString>`                                                                  |              | Empty string or not?                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`IsRepo <pyquickhelper.loghelper.repositories.pygit_helper.IsRepo>`                                                           |              | Says if it a repository :epkg:`GIT`.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`IsRepo <pyquickhelper.loghelper.repositories.pysvn_helper.IsRepo>`                                                           |              | says if it a repository SVN                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`NbImage <pyquickhelper.helpgen.utils_sphinx_config.NbImage>`                                                                 |              | Retrieves a name or a url of the image if it is not found in the local folder or a subfolder.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`Print <pyquickhelper.loghelper.flog.Print>`                                                                                  |              | if True, redirect everything which is displayed to the standard output                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_NbImage <pyquickhelper.helpgen.utils_sphinx_config._NbImage>`                                                               |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_NbImage_path <pyquickhelper.helpgen.utils_sphinx_config._NbImage_path>`                                                     |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`__get_version_from_version_txt <pyquickhelper.loghelper.repositories.pygit_helper.__get_version_from_version_txt>`           |              | Private function, tries to find a file ``version.txt`` which should contains the version number (if :epkg:`svn` is not ...                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`__get_version_from_version_txt <pyquickhelper.loghelper.repositories.pysvn_helper.__get_version_from_version_txt>`           |              | private function, tries to find a file ``version.txt`` which should contains the version number (if svn is not present) ...                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_attr_ <pyquickhelper.pycode.coverage_helper._attr_>`                                                                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_cache_url_to_file <pyquickhelper.ipythonhelper.run_notebook._cache_url_to_file>`                                            |              | Downloads file corresponding to url stored in *cache_urls*.                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_check_source <pyquickhelper.loghelper.flog._check_source>`                                                                  |              | Check the existence of a file, downloads it if not existing.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_check_sphinx_configuration <pyquickhelper.helpgen.sphinx_main._check_sphinx_configuration>`                                 |              | Operates some verification on the configuration.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_check_url_file <pyquickhelper.loghelper.flog._check_url_file>`                                                              |              | If *url* is an url, download the file and return the downloaded if it has already been downloaded, it is not downloaded ...                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_check_zip_file <pyquickhelper.loghelper.flog._check_zip_file>`                                                              |              | This function tests if a file is a zip file (extension zip), if it is the case, it unzips it into another file and return ...                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_clean_value <pyquickhelper.sphinxext.sphinx_image_extension._clean_value>`                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_clean_value <pyquickhelper.sphinxext.sphinx_video_extension._clean_value>`                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_dictionary_to_dataframe <pyquickhelper.texthelper.code_helper._dictionary_to_dataframe>`                                    |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_existing_dump <pyquickhelper.ipythonhelper.run_notebook._existing_dump>`                                                    |              | Loads an existing dump.                                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_extended_refactoring <pyquickhelper.pycode.utils_tests_helper._extended_refactoring>`                                       |              | Private function which does extra checkings when refactoring :epkg:`pyquickhelper`.                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_filter_out_warning <pyquickhelper.pycode.insetup_helper._filter_out_warning>`                                               |              | Filters out (import) warnings from error.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_first_more_recent <pyquickhelper.loghelper.flog._first_more_recent>`                                                        |              | Checks if the first file (opened url) is more recent of the second file (path).                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_LaTeXTranslator <pyquickhelper.helpgen.sphinxm_convert_doc_sphinx_helper._get_LaTeXTranslator>`                         |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_PyLinterRunV <pyquickhelper.pycode.utils_tests_helper._get_PyLinterRunV>`                                               |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_data <pyquickhelper.sphinxext.sphinx_ext_helper._get_data>`                                                             |              | Loads file ``objects.inv`` generated by extension :epkg:`sphinx.ext.intersphinx`.                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_dump_default_path <pyquickhelper.ipythonhelper.run_notebook._get_dump_default_path>`                                    |              | Proposes a default location to dump results about notebooks execution.                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_dump_default_path <pyquickhelper.pycode.setup_helper._get_dump_default_path>`                                           |              | Proposes a default location to dump results about unit tests execution.                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_file_txt <pyquickhelper.loghelper.flog._get_file_txt>`                                                                  |              | build a filename knowing an url, same name but in default_path                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_file_url <pyquickhelper.loghelper.flog._get_file_url>`                                                                  |              | build a filename knowing an url                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_html <pyquickhelper.ipythonhelper.interact._get_html>`                                                                  |              | Get the HTML representation of an object                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_get_password <pyquickhelper.server.filestore_fastapi._get_password>`                                                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_hash_url <pyquickhelper.filehelper.download_helper._hash_url>`                                                              |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_html_sidebyside <pyquickhelper.texthelper.text_diff._html_sidebyside>`                                                      |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_html_unsentencise <pyquickhelper.texthelper.text_diff._html_unsentencise>`                                                  |              | Joing a list of sentences into HTML for display                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_import_conf_extract_parameter <pyquickhelper.helpgen.sphinx_main._import_conf_extract_parameter>`                           |              | Imports the configuration file and extracts some of the parameters it defines. Fills the following lists.                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_mark_span <pyquickhelper.texthelper.text_diff._mark_span>`                                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_mark_text <pyquickhelper.texthelper.text_diff._mark_text>`                                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_markup_diff <pyquickhelper.texthelper.text_diff._markup_diff>`                                                              |              | Returns a and b with any differences processed by mark. Junk is ignored by the differ.                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_measure_documentation_append <pyquickhelper.texthelper.code_helper._measure_documentation_append>`                          |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_measure_documentation_ratio <pyquickhelper.texthelper.code_helper._measure_documentation_ratio>`                            |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_measure_documentation_update <pyquickhelper.texthelper.code_helper._measure_documentation_update>`                          |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modified_linux_jenkins <pyquickhelper.jenkinshelper.jenkins_server._modified_linux_jenkins>`                                |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modified_linux_jenkins_any <pyquickhelper.jenkinshelper.jenkins_server._modified_linux_jenkins_any>`                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modified_windows_jenkins <pyquickhelper.jenkinshelper.jenkins_server._modified_windows_jenkins>`                            |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modified_windows_jenkins_27 <pyquickhelper.jenkinshelper.jenkins_server._modified_windows_jenkins_27>`                      |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modified_windows_jenkins_any <pyquickhelper.jenkinshelper.jenkins_server._modified_windows_jenkins_any>`                    |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modifies_coverage_report <pyquickhelper.pycode.utils_tests._modifies_coverage_report>`                                      |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_modify_postcontents <pyquickhelper.sphinxext.sphinx_postcontents_extension._modify_postcontents>`                           |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_notebook_replacements <pyquickhelper.helpgen.post_process._notebook_replacements>`                                          |              | Makes some replacements in a notebook.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_optimization_criterion <pyquickhelper.imghelper.img_helper._optimization_criterion>`                                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_optimization_histogram_order <pyquickhelper.imghelper.img_helper._optimization_histogram_order>`                            |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_post_request <pyquickhelper.server.filestore_fastapi._post_request>`                                                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_preprocess_notebook <pyquickhelper.helpgen.process_notebooks._preprocess_notebook>`                                         |              | Preprocesses the content of a notebook.                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_print_loop_on_children <pyquickhelper.sphinxext.sphinx_tocdelay_extension._print_loop_on_children>`                         |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_private_migrating_doxygen_doc <pyquickhelper.helpgen.utils_sphinx_doc._private_migrating_doxygen_doc>`                      |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_private_process_one_file <pyquickhelper.helpgen.utils_sphinx_doc._private_process_one_file>`                                |              | Copies one file from the source to the documentation folder. It processes some comments in doxygen format (@ param, ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_private_test_style_src <pyquickhelper.pycode._pylint_common._private_test_style_src>`                                       |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_private_test_style_test <pyquickhelper.pycode._pylint_common._private_test_style_test>`                                     |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_private_unittest <pyquickhelper.sphinxext._private_for_unittest._private_unittest>`                                         |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_process_notebooks_in <pyquickhelper.helpgen.process_notebooks._process_notebooks_in>`                                       |              | The notebook conversion does not handle images from url for :epkg:`pdf` and :epkg:`docx`. They could be downloaded first ...                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_process_notebooks_in_private <pyquickhelper.helpgen.process_notebooks._process_notebooks_in_private>`                       |              | This function fails in nbconvert 6.0 when the conversion is called more than once. The conversion probably changes the ...                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_process_notebooks_in_private_cmd <pyquickhelper.helpgen.process_notebooks._process_notebooks_in_private_cmd>`               |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_process_pstats <pyquickhelper.pycode.profiling._process_pstats>`                                                            |              | Converts class `Stats <https://docs.python.org/3/library/ profile.html#pstats.Stats>`_ into something readable for ...                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_process_sphinx_in_private_cmd <pyquickhelper.helpgen.sphinx_main._process_sphinx_in_private_cmd>`                           |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_run_cmd_filter <pyquickhelper.pycode._pylint_common._run_cmd_filter>`                                                       |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_sentencize <pyquickhelper.texthelper.text_diff._sentencize>`                                                                |              | Split a string into a list of sentences                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_skip <pyquickhelper.helpgen.default_conf._skip>`                                                                            |              | To skip some functions, see `Skipping members <https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html>`_. ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_sversion <pyquickhelper.pycode.linux_scripts._sversion>`                                                                    |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_sversion <pyquickhelper.pycode.windows_scripts._sversion>`                                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_this_fLOG <pyquickhelper.loghelper.flog._this_fLOG>`                                                                        |              | Other name private to this module.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_tokenize <pyquickhelper.texthelper.text_diff._tokenize>`                                                                    |              | Split a string into tokens                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_unsentencise <pyquickhelper.texthelper.text_diff._unsentencise>`                                                            |              | Join a list of sentences into a string                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`_untokenize <pyquickhelper.texthelper.text_diff._untokenize>`                                                                |              | Join a list of tokens into a string                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_file_rst <pyquickhelper.helpgen.utils_sphinx_doc.add_file_rst>`                                                          |              | Creates a :epkg:`rst` file for every source file.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_link_to_notebook <pyquickhelper.helpgen.process_notebooks.add_link_to_notebook>`                                         |              | Adds a link to the notebook in :epkg:`HTML` format and does a little bit of cleaning for various format.                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_missing_development_version <pyquickhelper.pycode.utils_tests_helper.add_missing_development_version>`                   |              | Looks for development version of a given module and add paths to ``sys.path`` after having checked they are working. ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_missing_files <pyquickhelper.helpgen.sphinx_main_missing_html_files.add_missing_files>`                                  |              | Adds missing files for the documentation, ``moduletoc.html``, ``blogtoc.html``, ``searchbox.html``.                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_rst_links <pyquickhelper.texthelper.code_helper.add_rst_links>`                                                          |              | Replaces words by something like ``:epkg:'word'``.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`add_tag_for_slideshow <pyquickhelper.helpgen.process_notebooks.add_tag_for_slideshow>`                                       |              | Modifies a notebook to add tag for a slideshow.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`align_seqs <pyquickhelper.texthelper.text_diff.align_seqs>`                                                                  |              | Aligns two sequences of strings after comparing them.                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`apply_modification_template <pyquickhelper.helpgen.utils_sphinx_doc.apply_modification_template>`                            |              | See :func:`add_file_rst`.                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`apply_template <pyquickhelper.texthelper.templating.apply_template>`                                                         |              | Extend a string containing templating instructions. See :epkg:`mako` or :epkg:`jinja2`.                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`assert_almost_equal_detailed <pyquickhelper.pycode.unittestclass.assert_almost_equal_detailed>`                              |              | Calls :epkg:`numpy:testing:assert_almost_equal`. Add more informations in the exception message.                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`available_commands_list <pyquickhelper.pycode.setup_helper.available_commands_list>`                                         |              | Checks that on command handled by pyquickhelper is part of the arguments.                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`badge_notebook_coverage <pyquickhelper.ipythonhelper.run_notebook.badge_notebook_coverage>`                                  |              | Builds a badge reporting on the notebook coverage. It gives the proportion of run cells.                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`bigger_role <pyquickhelper.sphinxext.sphinx_bigger_extension.bigger_role>`                                                   |              | Defines custom role *bigger*. The following instructions defines buttons of size 20 (:bigger:`text`):                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_all_notebooks_coverage <pyquickhelper.helpgen.process_notebooks.build_all_notebooks_coverage>`                         |              | Creates a :epkg:`rst` page (gallery) with links to all notebooks and information about coverage. It relies on function ...                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_history <pyquickhelper.loghelper.history_helper.build_history>`                                                        |              | Returns an history of a module.                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_history_from_setup <pyquickhelper.pycode.setup_helper.build_history_from_setup>`                                       |              | Builds the history from :epkg:`github` and :epkg:`pypi`.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_notebooks_gallery <pyquickhelper.helpgen.process_notebooks.build_notebooks_gallery>`                                   |              | Creates a :epkg:`rst` page (gallery) with links to all notebooks. For each notebook, it creates a snippet.                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_rss <pyquickhelper.sphinxext.build_rss.build_rss>`                                                                     |              | Build a RSS file, the function keeps the blog post (HTML format) from the last month. The summary will only contains ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_thumbail_in_gallery <pyquickhelper.helpgen.process_notebooks.build_thumbail_in_gallery>`                               |              | Returns :epkg:`rst` code for a notebook.                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`build_venv_cmd <pyquickhelper.pycode.venv_helper.build_venv_cmd>`                                                            |              | Builds the command line for virtual env.                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`call_cli_function <pyquickhelper.cli.cli_helper.call_cli_function>`                                                          |              | Calls a function *f* given parsed arguments.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`call_github_api <pyquickhelper.loghelper.github_api.call_github_api>`                                                        |              | Calls `GitHub REST API <https://developer.github.com/v3/>`_.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`call_gui_function <pyquickhelper.cli.cli_helper.call_gui_function>`                                                          |              | Opens a GUI based on :epkg:`tkinter` which allows the user to run a command line through a windows. The function ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`call_pandoc <pyquickhelper.helpgen.pandoc_helper.call_pandoc>`                                                               |              | Call :epkg:`pandoc`.                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`change_file_status <pyquickhelper.filehelper.anyfhelper.change_file_status>`                                                 |              | Changes the status of all files inside a folder.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`change_style <pyquickhelper.texthelper.code_helper.change_style>`                                                            |              | Switches from *AaBb* into *aa_bb*.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check <pyquickhelper.check>`                                                                                                 |              | Checks the library is working. It raises an exception if it does not.                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check <pyquickhelper.filehelper.check>`                                                                                      |              | checks difflibjs is present                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check_log <pyquickhelper.loghelper.check_log>`                                                                               |              | check function noLOG                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check_pep8 <pyquickhelper.pycode.utils_tests_helper.check_pep8>`                                                             |              | Checks if :epkg:`PEP8`, the function calls command :epkg:`pycodestyle` on a specific folder.                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check_readme_syntax <pyquickhelper.pycode.venv_helper.check_readme_syntax>`                                                  |              | Checks the syntax of the file ``readme.rst`` which describes a python project.                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`check_typed_make_field <pyquickhelper.sphinxext.sphinx_docassert_extension.check_typed_make_field>`                          |              | Overwrites function #L197>`_. `make_field <https://github.com/sphinx-doc/sphinx/blob/master/sphinx/util/docfields.py ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`checksum_md5 <pyquickhelper.filehelper.file_info.checksum_md5>`                                                              |              | Computes MD5 for a file.                                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`choose_path <pyquickhelper.pycode.build_helper.choose_path>`                                                                 |              | Returns the first path which exists in the list.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean <pyquickhelper.pycode.utils_tests_private.clean>`                                                                      |              | Does the cleaning.                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_documentation_for_cli <pyquickhelper.cli.cli_helper.clean_documentation_for_cli>`                                      |              | Cleans the documentation before integrating into a command line documentation.                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_exts <pyquickhelper.pycode.clean_helper.clean_exts>`                                                                   |              | Cleans files in a folder and subfolders with a given extensions.                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_files <pyquickhelper.pycode.clean_helper.clean_files>`                                                                 |              | Cleans ``\r`` in files a folder and subfolders with a given extensions. Backslashes are replaces by ``/``. The regular ...                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_notebooks_for_numbers <pyquickhelper.pycode.setup_helper.clean_notebooks_for_numbers>`                                 |              | Upgrades notebooks to the latest format and cleans notebooks execution numbers and rearranges the JSON file.                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_readme <pyquickhelper.pycode.readme_helper.clean_readme>`                                                              |              | Clean instructions such as ``                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clean_space_for_setup <pyquickhelper.pycode.setup_helper.clean_space_for_setup>`                                             |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`cli_main_helper <pyquickhelper.cli.cli_helper.cli_main_helper>`                                                              |              | Implements the main commmand line for a module.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`clone <pyquickhelper.loghelper.repositories.pygit_helper.clone>`                                                             |              | Clones a :epkg:`git` repository.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`close_input_output <pyquickhelper.filehelper.encryption.close_input_output>`                                                 |              | Takes the output of :func:`open_input_output` and closes streams and return expected values.                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`code_stat <pyquickhelper.cli.code_cli.code_stat>`                                                                            |              | Returns statistics about the documentation of a module.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`compare_module_version <pyquickhelper.texthelper.version_helper.compare_module_version>`                                     |              | Compares two versions.                                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`compile_history <pyquickhelper.loghelper.history_helper.compile_history>`                                                    |              | Compile history and produces a :epkg:`rst` file.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`compile_latex_output_final <pyquickhelper.helpgen.sphinx_main_helper.compile_latex_output_final>`                            |              | Compiles the :epkg:`latex` documents.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`compress_cst <pyquickhelper.pycode.unittest_cst.compress_cst>`                                                               |              | Transforms a huge constant into a sequence of compressed binary strings.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`compute_truncated_documentation <pyquickhelper.helpgen.utils_sphinx_doc_helpers.compute_truncated_documentation>`            |              | Produces a truncated version of a docstring.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`concat_images <pyquickhelper.imghelper.img_helper.concat_images>`                                                            |              | Concatenates images into an image with several rows of images.                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`configure_backend <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.configure_backend>`                                |              | local function                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`content_as_binary <pyquickhelper.filehelper.ftp_transfer_files.content_as_binary>`                                           |              | determines if filename is binary or None before transfering it                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`convert_notebook <pyquickhelper.cli.notebook.convert_notebook>`                                                              |              | Converts a notebook into a specific format.                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`convert_pandoc_rst <pyquickhelper.helpgen.notebook_exporter.convert_pandoc_rst>`                                             |              | Overwrites `convert_pandoc <https://github.com/jupyter/nbconvert/blob/master/nbconvert/filters/pandoc.py>`_.                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`convert_sequence_into_batch_file <pyquickhelper.jenkinshelper.yaml_helper.convert_sequence_into_batch_file>`                 |              | Converts a sequence of instructions into a batch file.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`convert_st_date_to_datetime <pyquickhelper.filehelper.file_info.convert_st_date_to_datetime>`                                |              | Converts a string into a datetime.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`copy27_for_setup <pyquickhelper.pycode.setup_helper.copy27_for_setup>`                                                       |              | Prepares a copy of the source for :epkg:`Python` 2.7, assuming the module follows the same design as *pyquickhelper*. ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`copy_download_files <pyquickhelper.sphinxext.sphinx_downloadlink_extension.copy_download_files>`                             |              | Copies all files mentioned with role *downloadlink*.                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`copy_js_files <pyquickhelper.sphinxext.sphinx_gdot_extension.copy_js_files>`                                                 |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`copy_source_files <pyquickhelper.helpgen.utils_sphinx_doc.copy_source_files>`                                                |              | Copies all sources files (input) into a folder (output), apply on each of them a modification.                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`correct_indentation <pyquickhelper.helpgen.rst_converters.correct_indentation>`                                              |              | Tries to improve the indentation before running :epkg:`docutils`.                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`coverage_combine <pyquickhelper.pycode.coverage_helper.coverage_combine>`                                                    |              | Merges multiples reports.                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_app <pyquickhelper.server.filestore_fastapi.create_app>`                                                              |              | Creates an instance of application class returned by :func:`create_fast_api_app`. It checks that environment variables ...                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_cli_argument <pyquickhelper.cli.cli_helper.create_cli_argument>`                                                      |              | Adds an argument for :epkg:`*py:argparse:ArgumentParser`.                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_cli_parser <pyquickhelper.cli.cli_helper.create_cli_parser>`                                                          |              | Automatically creates a parser based on a function, its signature with annotation and its documentation (assuming ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_fast_api_app <pyquickhelper.server.filestore_fastapi.create_fast_api_app>`                                            |              | Creates a :epkg:`REST` application based on :epkg:`FastAPI`.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_virtual_env <pyquickhelper.pycode.venv_helper.create_virtual_env>`                                                    |              | Creates a virtual environment.                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_visual_diff_through_html <pyquickhelper.filehelper.visual_sync.create_visual_diff_through_html>`                      |              | The function uses `jsdifflib <https://github.com/cemerick/jsdifflib>`_ to create a visual diff. If it was not already ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`create_visual_diff_through_html_files <pyquickhelper.filehelper.visual_sync.create_visual_diff_through_html_files>`          |              | Calls function :func:`create_visual_diff_through_html` with the content of two files.                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`css <pyquickhelper.sphinxext.sphinx_youtube_extension.css>`                                                                  |              | Returns style.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`custom_ensuredir <pyquickhelper.helpgen.conf_path_tools.custom_ensuredir>`                                                   |              | Ensure that a path exists.                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`custom_setup <pyquickhelper.helpgen.default_conf.custom_setup>`                                                              |              | See `Sphinx core events <https://www.sphinx-doc.org/en/master/#sphinx-core-events>`_.                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`datetime2str <pyquickhelper.loghelper.convert_helper.datetime2str>`                                                          |              | Converts a datetime into a string.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`decode_outerr <pyquickhelper.loghelper.run_cmd.decode_outerr>`                                                               |              | Decodes the output or the error after running a command line instructions.                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`decompress_cst <pyquickhelper.pycode.unittest_cst.decompress_cst>`                                                           |              | Transforms a huge constant produced by function :func:`compress_cst` into the original value.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`decrypt <pyquickhelper.cli.encryption_cli.decrypt>`                                                                          |              | Decrypts using class :class:`EncryptedBackup`. The function relies on module :epkg:`pycrypto`, :epkg:`cryptography`, ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`decrypt_file <pyquickhelper.cli.encryption_file_cli.decrypt_file>`                                                           |              | Decrypts using class :func:`decrypt_stream`.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`decrypt_stream <pyquickhelper.filehelper.encryption.decrypt_stream>`                                                         |              | Decrypts a file using AES (CBC mode) with the given key. The function relies on module :epkg:`pycrypto`, :epkg:`cryptography`, ...                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`default_engines <pyquickhelper.jenkinshelper.jenkins_helper.default_engines>`                                                |              | Returns a dictionary with default values for Jenkins server, you should update the path if the proposed path are not ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`default_filter_warning <pyquickhelper.pycode.default_filter_warning.default_filter_warning>`                                 |              | Filters out warnings.                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`default_jenkins_jobs <pyquickhelper.jenkinshelper.jenkins_helper.default_jenkins_jobs>`                                      |              | Example of a list of jobs for parameter *module* of function :func:`setup_jenkins_server_yml`.                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`default_skip_function <pyquickhelper.pycode.utils_tests_private.default_skip_function>`                                      |              | Default skip function for function :func:`main_wrapper_tests`.                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`default_sphinx_options <pyquickhelper.helpgen.rst_converters.default_sphinx_options>`                                        |              | Defines or overrides default options for :epkg:`Sphinx`, listed below.                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_autosignature_node <pyquickhelper.sphinxext.sphinx_autosignature.depart_autosignature_node>`                          |              | What to do when leaving a node :class:`autosignature_node`.                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_bigger_node <pyquickhelper.sphinxext.sphinx_bigger_extension.depart_bigger_node>`                                     |              | depart bigger_node for format other than html                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_bigger_node_html <pyquickhelper.sphinxext.sphinx_bigger_extension.depart_bigger_node_html>`                           |              | what to do when leaving a node *bigger* the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_bigger_node_latex <pyquickhelper.sphinxext.sphinx_bigger_extension.depart_bigger_node_latex>`                         |              | depart bigger_node for latex                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_bigger_node_rst <pyquickhelper.sphinxext.sphinx_bigger_extension.depart_bigger_node_rst>`                             |              | depart bigger_node for rst                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_blocref_node <pyquickhelper.sphinxext.sphinx_blocref_extension.depart_blocref_node>`                                  |              | depart_blocref_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_blocreflist_node <pyquickhelper.sphinxext.sphinx_blocref_extension.depart_blocreflist_node>`                          |              | depart_blocref_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_blogpost_node <pyquickhelper.sphinxext.sphinx_blog_extension.depart_blogpost_node>`                                   |              | what to do when leaving a node blogpost the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_blogpostagg_node <pyquickhelper.sphinxext.sphinx_blog_extension.depart_blogpostagg_node>`                             |              | what to do when leaving a node blogpost, the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_blogpostagg_node_html <pyquickhelper.sphinxext.sphinx_blog_extension.depart_blogpostagg_node_html>`                   |              | what to do when leaving a node blogpost, the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_cmdref_node <pyquickhelper.sphinxext.sphinx_cmdref_extension.depart_cmdref_node>`                                     |              | *depart_cmdref_node*, see `sphinx/writers/html.py <https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py>`_. ...                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_cmdreflist_node <pyquickhelper.sphinxext.sphinx_cmdref_extension.depart_cmdreflist_node>`                             |              | *depart_cmdref_node*                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_collapse_node <pyquickhelper.sphinxext.sphinx_collapse_extension.depart_collapse_node>`                               |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_collapse_node_html <pyquickhelper.sphinxext.sphinx_collapse_extension.depart_collapse_node_html>`                     |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_collapse_node_rst <pyquickhelper.sphinxext.sphinx_collapse_extension.depart_collapse_node_rst>`                       |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_downloadlink_node_html <pyquickhelper.sphinxext.sphinx_downloadlink_extension.depart_downloadlink_node_html>`         |              | Converts node *downloadlink* into :epkg:`html`.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_downloadlink_node_latex <pyquickhelper.sphinxext.sphinx_downloadlink_extension.depart_downloadlink_node_latex>`       |              | Does notthing.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_downloadlink_node_md <pyquickhelper.sphinxext.sphinx_downloadlink_extension.depart_downloadlink_node_md>`             |              | Converts node *downloadlink* into :epkg:`md`.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_downloadlink_node_rst <pyquickhelper.sphinxext.sphinx_downloadlink_extension.depart_downloadlink_node_rst>`           |              | Converts node *downloadlink* into :epkg:`rst`.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_downloadlink_node_text <pyquickhelper.sphinxext.sphinx_downloadlink_extension.depart_downloadlink_node_text>`         |              | Does notthing.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_epkg_node <pyquickhelper.sphinxext.sphinx_epkg_extension.depart_epkg_node>`                                           |              | What to do when leaving a node *epkg*.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_exref_node <pyquickhelper.sphinxext.sphinx_exref_extension.depart_exref_node>`                                        |              | depart_exref_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_exreflist_node <pyquickhelper.sphinxext.sphinx_exref_extension.depart_exreflist_node>`                                |              | depart_exref_node                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_faqref_node <pyquickhelper.sphinxext.sphinx_faqref_extension.depart_faqref_node>`                                     |              | depart_faqref_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_faqreflist_node <pyquickhelper.sphinxext.sphinx_faqref_extension.depart_faqreflist_node>`                             |              | depart_faqref_node                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gdot_node_html <pyquickhelper.sphinxext.sphinx_gdot_extension.depart_gdot_node_html>`                                 |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gdot_node_html_svg <pyquickhelper.sphinxext.sphinx_gdot_extension.depart_gdot_node_html_svg>`                         |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gdot_node_rst <pyquickhelper.sphinxext.sphinx_gdot_extension.depart_gdot_node_rst>`                                   |              | depart collapse_node                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gitlog_node <pyquickhelper.sphinxext.sphinx_gitlog_extension.depart_gitlog_node>`                                     |              | depart *gitlog_node* for format other than html                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gitlog_node_html <pyquickhelper.sphinxext.sphinx_gitlog_extension.depart_gitlog_node_html>`                           |              | what to do when leaving a node *gitlog* the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gitlog_node_latex <pyquickhelper.sphinxext.sphinx_gitlog_extension.depart_gitlog_node_latex>`                         |              | depart *gitlog_node* for latex                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_gitlog_node_rst <pyquickhelper.sphinxext.sphinx_gitlog_extension.depart_gitlog_node_rst>`                             |              | depart *gitlog_node* for rst                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_mathdef_node <pyquickhelper.sphinxext.sphinx_mathdef_extension.depart_mathdef_node>`                                  |              | depart_mathdef_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_mathdeflist_node <pyquickhelper.sphinxext.sphinx_mathdef_extension.depart_mathdeflist_node>`                          |              | depart_mathdef_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_nbref_node <pyquickhelper.sphinxext.sphinx_nbref_extension.depart_nbref_node>`                                        |              | *depart_nbref_node*, see `sphinx/writers/html.py <https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py>`_. ...                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_nbreflist_node <pyquickhelper.sphinxext.sphinx_nbref_extension.depart_nbreflist_node>`                                |              | depart_nbref_node                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_postcontents_node <pyquickhelper.sphinxext.sphinx_postcontents_extension.depart_postcontents_node>`                   |              | does nothing                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_quote_node <pyquickhelper.sphinxext.sphinx_quote_extension.depart_quote_node>`                                        |              | depart_quote_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_quote_node_rst <pyquickhelper.sphinxext.sphinx_quote_extension.depart_quote_node_rst>`                                |              | depart_quote_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_revealjs <pyquickhelper.sphinxext.revealjs.directives.depart_revealjs>`                                               |              | build end tag for revealjs                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_runpython_node <pyquickhelper.sphinxext.sphinx_runpython_extension.depart_runpython_node>`                            |              | What to do when leaving a node :class:`runpython_node` the function should have different behaviour, depending on ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_rv_code <pyquickhelper.sphinxext.revealjs.directives.depart_rv_code>`                                                 |              | build end tag for rv_code                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_rv_note <pyquickhelper.sphinxext.revealjs.directives.depart_rv_note>`                                                 |              | build end tag for rv_note                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_rv_small <pyquickhelper.sphinxext.revealjs.directives.depart_rv_small>`                                               |              | build end tag for rv_small                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_sharenet_node <pyquickhelper.sphinxext.sphinx_sharenet_extension.depart_sharenet_node>`                               |              | what to do when leaving a node sharenet the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_sharenet_node_html <pyquickhelper.sphinxext.sphinx_sharenet_extension.depart_sharenet_node_html>`                     |              | what to do when leaving a node sharenet the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_sharenet_node_rst <pyquickhelper.sphinxext.sphinx_sharenet_extension.depart_sharenet_node_rst>`                       |              | what to do when leaving a node sharenet the function should have different behaviour, depending on the format, or ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_simpleimage_node_html <pyquickhelper.sphinxext.sphinx_image_extension.depart_simpleimage_node_html>`                  |              | What to do when leaving a node *image* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_simpleimage_node_latex <pyquickhelper.sphinxext.sphinx_image_extension.depart_simpleimage_node_latex>`                |              | What to do when leaving a node *image* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_simpleimage_node_md <pyquickhelper.sphinxext.sphinx_image_extension.depart_simpleimage_node_md>`                      |              | What to do when leaving a node *image* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_simpleimage_node_rst <pyquickhelper.sphinxext.sphinx_image_extension.depart_simpleimage_node_rst>`                    |              | What to do when leaving a node *image* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_simpleimage_node_text <pyquickhelper.sphinxext.sphinx_image_extension.depart_simpleimage_node_text>`                  |              | What to do when leaving a node *image* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_tocdelay_node <pyquickhelper.sphinxext.sphinx_tocdelay_extension.depart_tocdelay_node>`                               |              | does nothing                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_todoext_node <pyquickhelper.sphinxext.sphinx_todoext_extension.depart_todoext_node>`                                  |              | depart_todoext_node, see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_todoextlist_node <pyquickhelper.sphinxext.sphinx_todoext_extension.depart_todoextlist_node>`                          |              | depart_todoext_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_tpl_node <pyquickhelper.sphinxext.sphinx_template_extension.depart_tpl_node>`                                         |              | What to do when leaving a node *tpl*.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_video_node_html <pyquickhelper.sphinxext.sphinx_video_extension.depart_video_node_html>`                              |              | What to do when leaving a node *video* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_video_node_latex <pyquickhelper.sphinxext.sphinx_video_extension.depart_video_node_latex>`                            |              | What to do when leaving a node *video* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_video_node_rst <pyquickhelper.sphinxext.sphinx_video_extension.depart_video_node_rst>`                                |              | What to do when leaving a node *video* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_video_node_text <pyquickhelper.sphinxext.sphinx_video_extension.depart_video_node_text>`                              |              | What to do when leaving a node *video* the function should have different behaviour, depending on the format, or ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`depart_youtube_node <pyquickhelper.sphinxext.sphinx_youtube_extension.depart_youtube_node>`                                  |              | Youtube node.                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`detect_encoding <pyquickhelper.pycode.open_script_file.detect_encoding>`                                                     |              | Guesses the encoding from ``# -*- coding: ...``.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`df2html <pyquickhelper.pandashelper.tblformat.df2html>`                                                                      |              | Converts the table into a :epkg:`html` string.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`df2rst <pyquickhelper.pandashelper.tblformat.df2rst>`                                                                        |              | Builds a string in :epkg:`RST` format from a :epkg:`dataframe`.                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`dictionary_as_class <pyquickhelper.loghelper.process_script.dictionary_as_class>`                                            |              | Every key of dictionary ``dico`` becomes a member of a dummy class.                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`diff2html <pyquickhelper.texthelper.edit_text_diff.diff2html>`                                                               |              | Produces a HTML report with differences between *rows1* and *rows2*.                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`directive_boolean <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.directive_boolean>`                                |              | local function                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`do_main <pyquickhelper.cli.encryption_cli.do_main>`                                                                          |              | Encrypts or decrypts a folder, see :class:`EncryptedBackup`. The function relies on module :epkg:`pycrypto`, :epkg:`cryptography`, ...                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`do_main <pyquickhelper.cli.encryption_file_cli.do_main>`                                                                     |              | Encrypt or decrypt of a file                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`doc_checking <pyquickhelper.helpgen.utils_sphinx_doc.doc_checking>`                                                          |              | Example of a doc string.                                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`docstring2html <pyquickhelper.helpgen.rst_converters.docstring2html>`                                                        |              | Converts a docstring into a :epkg:`HTML` format.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download <pyquickhelper.filehelper.internet_helper.download>`                                                                |              | Downloads a small file. If *url* is an url, it downloads the file and returns the downloaded filename. If it has ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download <pyquickhelper.loghelper.flog.download>`                                                                            |              | Download a file to the folder path_unzip if not present, if the downloading is interrupted, the next time, it will start ...                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download_images <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.download_images>`                                    |              | Downloads images before running the documentation.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download_requirejs <pyquickhelper.helpgen.install_custom.download_requirejs>`                                                |              | Downloads `require.js <http://requirejs.org/docs/download.html>`_ release.                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download_revealjs <pyquickhelper.helpgen.install_custom.download_revealjs>`                                                  |              | Downloads :epkg:`reveal.js` release and unzips it.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download_urls_in_folder_content <pyquickhelper.filehelper.download_urls_helper.download_urls_in_folder_content>`             |              | Iterates on files in folder, parse them, extracts all urls, download them in a folder.                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`download_urls_iterfile <pyquickhelper.filehelper.synchelper.download_urls_iterfile>`                                         |              | Same as :func:`explore_folder` but iterates on files included in a folder and its subfolders.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`edit_distance_string <pyquickhelper.texthelper.edit_text_diff.edit_distance_string>`                                         |              | Computes the edit distance between strings *s1* and *s2*.                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`edit_distance_text <pyquickhelper.texthelper.edit_text_diff.edit_distance_text>`                                             |              | Computes an edit distance between lines of a text.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`encrypt <pyquickhelper.cli.encryption_cli.encrypt>`                                                                          |              | Encrypts using class :class:`EncryptedBackup`. The function relies on module :epkg:`pycrypto`, :epkg:`cryptography`, ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`encrypt_file <pyquickhelper.cli.encryption_file_cli.encrypt_file>`                                                           |              | Encrypts using class :func:`encrypt_stream`.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`encrypt_stream <pyquickhelper.filehelper.encryption.encrypt_stream>`                                                         |              | Encrypts a file using AES (CBC mode) with the given key. The function relies on module :epkg:`pycrypto`, :epkg:`cryptography`, ...                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_cleaned_signature <pyquickhelper.sphinxext.sphinx_autosignature.enumerate_cleaned_signature>`                      |              | Removes annotation from a signature extracted with :func:`enumerate_extract_signature`.                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_closed_issues <pyquickhelper.loghelper.history_helper.enumerate_closed_issues>`                                    |              | Enumerates github issues for a repo and an owner since a given date.                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_convert_yaml_into_instructions <pyquickhelper.jenkinshelper.yaml_helper.enumerate_convert_yaml_into_instructions>` |              | Converts a :epkg:`yml` file into sequences of instructions, conditions are interpreted.                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_copy_images_for_slides <pyquickhelper.helpgen.sphinx_main_helper.enumerate_copy_images_for_slides>`                |              | Copies images, initial intent was for slides, once converted into html, link to images are relative to the folder ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_extract_signature <pyquickhelper.sphinxext.sphinx_autosignature.enumerate_extract_signature>`                      |              | Looks for substring like the following and clean the signature to be able to use function *_signature_fromstr*.                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_notebooks_link <pyquickhelper.helpgen.stat_helper.enumerate_notebooks_link>`                                       |              | Looks for all links to a notebook in the documentation.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_processed_yml <pyquickhelper.jenkinshelper.yaml_helper.enumerate_processed_yml>`                                   |              | Submits or enumerates jobs based on the content of a :epkg:`yml` file.                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_pypi_versions_date <pyquickhelper.loghelper.pypi_helper.enumerate_pypi_versions_date>`                             |              | Retrieves version and releases dates for modules hosted on :epkg:`pypi`.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`enumerate_split_df <pyquickhelper.pandashelper.tblformat.enumerate_split_df>`                                                |              | Splits a dataframe by columns to display shorter dataframes.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`epkg_role <pyquickhelper.sphinxext.sphinx_epkg_extension.epkg_role>`                                                         |              | Defines custom role *epkg*. A list of supported urls must be defined in the configuration file. It wants to replace ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`escape_html <pyquickhelper.sphinxext.revealjs.compat.escape_html>`                                                           |              | Replace special characters "&", "<" and ">" to HTML-safe sequences. If the optional flag quote is true (the default), ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`evaluate_condition <pyquickhelper.jenkinshelper.yaml_helper.evaluate_condition>`                                             |              | Evaluates a condition inserted in a :epkg:`yml` file.                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`evaluate_template <pyquickhelper.sphinxext.sphinx_template_extension.evaluate_template>`                                     |              | Evaluate a template given a list of parameters given a list of named parameters.                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`everything_but_python <pyquickhelper.helpgen.sphinx_helper.everything_but_python>`                                           |              | Returns True if ``__pycache__`` is not in filename.                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`example_function_latex <pyquickhelper.helpgen.utils_sphinx_doc_helpers.example_function_latex>`                              |              | This function only contains an example with latex to check it is working fine.                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`execute_notebook_list <pyquickhelper.ipythonhelper.run_notebook.execute_notebook_list>`                                      |              | Executes a list of notebooks.                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`execute_notebook_list_finalize_ut <pyquickhelper.ipythonhelper.run_notebook.execute_notebook_list_finalize_ut>`              |              | Checks the list of results and raises an exception if one failed. This is meant to be used in unit tests.                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`execute_script <pyquickhelper.loghelper.process_script.execute_script>`                                                      |              | Executes a :epkg:`python` script in a separate process.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`execute_script_get_local_variables <pyquickhelper.loghelper.process_script.execute_script_get_local_variables>`              |              | Executes a script and returns the local variables.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`explore_folder <pyquickhelper.filehelper.synchelper.explore_folder>`                                                         |              | Returns the list of files included in a folder and its subfolders. Returned names can be modified if *sub_pattern* is ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`explore_folder_iterfile <pyquickhelper.filehelper.synchelper.explore_folder_iterfile>`                                       |              | Same as :func:`explore_folder` but iterates on files included in a folder and its subfolders.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`explore_folder_iterfile_repo <pyquickhelper.filehelper.synchelper.explore_folder_iterfile_repo>`                             |              | Returns all files present in folder and added to a :epkg:`SVN` or :epkg:`GIT` repository.                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`extract_first_title <pyquickhelper.helpgen.sphinx_main_missing_html_files.extract_first_title>`                              |              | Extracts the first title (rst format) in a file.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`extract_issue_from_history <pyquickhelper.loghelper.history_helper.extract_issue_from_history>`                              |              | Extracts issues from exsiting history stored in ``HISTORY.rst``. The pattern must extract from the following lines: ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f1 <pyquickhelper.helpgen._fake_function_to_documentation.f1>`                                                               |              | Addition 1                                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f2 <pyquickhelper.helpgen._fake_function_to_documentation.f2>`                                                               |              | Addition 2                                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f3 <pyquickhelper.helpgen._fake_function_to_documentation.f3>`                                                               |              | Addition 3                                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f4 <pyquickhelper.helpgen._fake_function_to_documentation.f4>`                                                               |              | Addition 4                                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f5 <pyquickhelper.helpgen._fake_function_to_documentation.f5>`                                                               |              | Addition 5 Parameters ---------- a: parameter a b: parameter b Returns ------- ``a+b``                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`f6 <pyquickhelper.helpgen._fake_function_to_documentation.f6>`                                                               |              | Addition 6 Args: a: parameter a b: parameter b Returns: ``a+b``                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fLOG <pyquickhelper.loghelper.flog.fLOG>`                                                                                    |              | Builds a message on a single line with the date, it deals with encoding issues.                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fLOGFormat <pyquickhelper.loghelper.flog.fLOGFormat>`                                                                        |              | Formats a message.                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fast_api_content <pyquickhelper.server.filestore_fastapi.fast_api_content>`                                                  |              | Retrieves the dataframes based on partial information. Enumerates a list of dataframes.                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fast_api_query <pyquickhelper.server.filestore_fastapi.fast_api_query>`                                                      |              | Retrieves the list of dataframe based on partial information.                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fast_api_submit <pyquickhelper.server.filestore_fastapi.fast_api_submit>`                                                    |              | Stores a dataframe into a local stores.                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`filecontent_to_rst <pyquickhelper.helpgen.utils_sphinx_doc.filecontent_to_rst>`                                              |              | Produces a *.rst* file which contains the file. It adds a title and a label based on the filename (no folder included). ...                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_coverage_report <pyquickhelper.pycode.coverage_helper.find_coverage_report>`                                            |              | Finds all coverage reports in one subfolder.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_custom_latex_processing <pyquickhelper.helpgen.post_process_custom.find_custom_latex_processing>`                       |              | Determines the corresponding post processing function associated to name.                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_dvipng_path <pyquickhelper.helpgen.conf_path_tools.find_dvipng_path>`                                                   |              | Determines :epkg:`dvipng` location.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_graphviz_dot <pyquickhelper.helpgen.conf_path_tools.find_graphviz_dot>`                                                 |              | Determines the path to graphviz (on Windows), the function tests the existence of versions 34 to 45 assuming it ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_in_PATH <pyquickhelper.helpgen.conf_path_tools.find_in_PATH>`                                                           |              | look into every path mentioned in ``%PATH%`` a specific file, it raises an exception if not Found                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_latex_path <pyquickhelper.helpgen.conf_path_tools.find_latex_path>`                                                     |              | Finds latex path. Returns an empty string on :epkg:`linux`.                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_link <pyquickhelper.pycode.doc_helper.find_link>`                                                                       |              | Finds all links following RST format in a documentation.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_notebook_kernel <pyquickhelper.ipythonhelper.notebook_helper.find_notebook_kernel>`                                     |              | Returns a dict mapping kernel names to resource directories.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_pandoc_path <pyquickhelper.helpgen.conf_path_tools.find_pandoc_path>`                                                   |              | Determines :epkg:`pandoc` location. Returns an empty string on :epkg:`linux`.                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`find_pdflatex <pyquickhelper.helpgen.process_notebooks.find_pdflatex>`                                                       |              | Returns the executable for latex.                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fix_image_page_for_root <pyquickhelper.helpgen.utils_sphinx_doc_helpers.fix_image_page_for_root>`                            |              | Looks for images and fix their path as if the extract were copied to the root.                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fix_incomplete_references <pyquickhelper.helpgen.utils_sphinx_doc.fix_incomplete_references>`                                |              | Looks into every file .rst or .py for incomplete reference. Example                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`fix_tkinter_issues_virtualenv <pyquickhelper.pycode.tkinter_helper.fix_tkinter_issues_virtualenv>`                           |              | Fix an issue which happens in a virtual environment, see `Fix Tcl inside a virtualenv on Windows <https://github.com/pypa/virtualenv/pull/627>`_ ...                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`format_history <pyquickhelper.helpgen.sphinx_main_helper.format_history>`                                                    |              | Formats history based on module `releases <https://github.com/bitprophet/releases>`_.                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`ftp_upload <pyquickhelper.cli.ftp_cli.ftp_upload>`                                                                           |              | Pushes a file to a server using :epkg:`FTP` or :epkg:`SFTP`.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`generate_changes_repo <pyquickhelper.helpgen.sphinx_main_helper.generate_changes_repo>`                                      |              | Generates a :epkg:`RST` tables containing the changes stored by a :epkg:`SVN` or :epkg:`GIT` repository, the outcome ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`generate_help_sphinx <pyquickhelper.helpgen.sphinx_main.generate_help_sphinx>`                                               |              | Runs the help generation:                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_additional_paths <pyquickhelper.ipythonhelper.run_notebook.get_additional_paths>`                                        |              | Returns a list of paths to add before running the notebooks for a given a list of modules.                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_available_build_commands <pyquickhelper.pycode.setup_helper.get_available_build_commands>`                               |              | Returns commands which build the package.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_available_setup_commands <pyquickhelper.pycode.setup_helper.get_available_setup_commands>`                               |              | Returns the list of commands :epkg:`pyquickhelper` implements or allows.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_build_script <pyquickhelper.pycode.build_helper.get_build_script>`                                                       |              | Builds the build script which builds the setup, run the unit tests and the documentation.                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_call_stack <pyquickhelper.pycode.trace_execution.get_call_stack>`                                                        |              | Returns a string showing the call stack when this function is called.                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_cmd_git <pyquickhelper.loghelper.repositories.pygit_helper.get_cmd_git>`                                                 |              | Gets the command line used to run :epkg:`git`.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_default_extensions <pyquickhelper.sphinxext.get_default_extensions>`                                                     |              | Returns a list of default extensions.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_default_javascript <pyquickhelper.helpgen.default_conf.get_default_javascript>`                                          |              | Returns the style of additional style sheets                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_default_standard_extensions <pyquickhelper.sphinxext.get_default_standard_extensions>`                                   |              | Returns a list of standard extensions.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_default_stylesheet <pyquickhelper.helpgen.default_conf.get_default_stylesheet>`                                          |              | Returns the style of additional style sheets.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_default_value_type <pyquickhelper.loghelper.flog.get_default_value_type>`                                                |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_encryptor <pyquickhelper.filehelper.encryption.get_encryptor>`                                                           |              | Returns an encryptor with method encrypt and decrypt.                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_env_state_info <pyquickhelper.sphinxext.sphinxext_helper.get_env_state_info>`                                            |              | Retrieves an environment and a docname inside a directive.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_epkg_dictionary <pyquickhelper._cst.cst_sphinx.get_epkg_dictionary>`                                                     |              | Returns default dictionary for extension :func:`epkg_role`.                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_estimation_time <pyquickhelper.pycode.utils_tests_private.get_estimation_time>`                                          |              | Return an estimation of the processing time, it extracts the number in ``(time=5s)`` for example.                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_executables_path <pyquickhelper.helpgen.sphinx_main_helper.get_executables_path>`                                        |              | Returns the paths to :epkg:`Python`, :epkg:`Python` Scripts.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_exporter <pyquickhelper.helpgen.process_notebook_api.get_exporter>`                                                      |              | Returns the :epkg:`IPython` exporter associated to a format.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_extra_script_command <pyquickhelper.pycode.build_helper.get_extra_script_command>`                                       |              | Produces a script which runs the notebook, a documentation server, which publishes...                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_fLOG <pyquickhelper.get_fLOG>`                                                                                           |              | return a logging function                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_file_details <pyquickhelper.loghelper.repositories.pygit_helper.get_file_details>`                                       |              | Returns information about a file.                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_file_details_all <pyquickhelper.loghelper.repositories.pygit_helper.get_file_details_all>`                               |              | Returns information about all files                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_file_last_modification <pyquickhelper.loghelper.repositories.pygit_helper.get_file_last_modification>`                   |              | Returns the last modification of a file.                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_first_line <pyquickhelper.helpgen.default_conf.get_first_line>`                                                          |              | Expects to find a text file with a line, the function extracts and returns this line.                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_folder <pyquickhelper.pycode.setup_helper.get_folder>`                                                                   |              | Returns the folder which contains ``setup.py``.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_help_usage <pyquickhelper.helpgen.help_usage.get_help_usage>`                                                            |              | Returns the usage ``python setup.py build_sphinx``.                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_image_extension <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.get_image_extension>`                            |              | Guesses an extension for an image.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_index <pyquickhelper.sphinxext.sphinx_ext_helper.get_index>`                                                             |              | Retrieves documentation data for a specific module.                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_insetup_functions <pyquickhelper.get_insetup_functions>`                                                                 |              | Returns function used when a module includes C++ parts.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_installed_distributions <pyquickhelper.pycode.pip_helper.get_installed_distributions>`                                   |              | Directs call to function *get_installed_distributions* from :epkg:`pip`. Return a list of installed Distribution objects. ...                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_installed_notebook_extension <pyquickhelper.ipythonhelper.notebook_helper.get_installed_notebook_extension>`             |              | Retuns installed extensions.                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_interpreter_path <pyquickhelper.loghelper.run_cmd.get_interpreter_path>`                                                 |              | Returns the interpreter path.                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_intersphinx_mapping <pyquickhelper._cst.cst_sphinx.get_intersphinx_mapping>`                                             |              | Returns default dictionary for extension :epkg:`sphinx.ext.intersphinx`.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_jenkins_mappings <pyquickhelper.server.server_helper.get_jenkins_mappings>`                                              |              | we assume jobs were set up through a jenkins server, the function looks into folder *root* and list folder ``root/.*/dist/html.*`` ...                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_jupyter_datadir <pyquickhelper.ipythonhelper.notebook_helper.get_jupyter_datadir>`                                       |              | Returns the data directory for the notebook.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_jupyter_extension_dir <pyquickhelper.ipythonhelper.notebook_helper.get_jupyter_extension_dir>`                           |              | Parameters ++++++++++ user : bool [default: False] Whether to check the user's .ipython/nbextensions directory. ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_machine <pyquickhelper.loghelper.os_helper.get_machine>`                                                                 |              | Returns the machine name.                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_master_location <pyquickhelper.loghelper.repositories.pygit_helper.get_master_location>`                                 |              | Gets the remote master location.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_master_location <pyquickhelper.loghelper.repositories.pysvn_helper.get_master_location>`                                 |              | raises an exception                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_module_objects <pyquickhelper.helpgen.utils_sphinx_doc_helpers.get_module_objects>`                                      |              | Gets all the classes from a module.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_nb_commits <pyquickhelper.loghelper.repositories.pygit_helper.get_nb_commits>`                                           |              | Returns the number of commit.                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_nb_commits <pyquickhelper.loghelper.repositories.pysvn_helper.get_nb_commits>`                                           |              | returns the number of commit                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_notebook_kernel <pyquickhelper.ipythonhelper.notebook_helper.get_notebook_kernel>`                                       |              | Returns a `KernelSpec <https://ipython.org/ipython-doc/dev/api/ generated/IPython.kernel.kernelspec.html>`_.                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_package_info <pyquickhelper.pycode.pip_helper.get_package_info>`                                                         |              | Calls ``pip show`` to retrieve information about packages.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_packages_list <pyquickhelper.pycode.pip_helper.get_packages_list>`                                                       |              | calls ``pip list`` to retrieve the list of packages                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_parser <pyquickhelper.cli.encryption_cli.get_parser>`                                                                    |              | Defines the way to parse the magic command ``%encrypt`` and ``%decrypt``.                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_parser <pyquickhelper.cli.encryption_file_cli.get_parser>`                                                               |              | defines the way to parse the magic command ``%encrypt`` and ``%decrypt``                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_password <pyquickhelper.loghelper.pwd_helper.get_password>`                                                              |              | Restores a password. By default, uses :epkg:`keyring`.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_path <pyquickhelper.sphinxext.revealjs.get_path>`                                                                        |              | entry-point for sphinx theme.                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_platform <pyquickhelper.jenkinshelper.jenkins_helper.get_platform>`                                                      |              | Returns *platform* if not *None*, ``sys.platform`` otherwise.                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_prefix <pyquickhelper.loghelper.flog.get_prefix>`                                                                        |              | Returns a prefix for a file based on time.                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_pyproj_project <pyquickhelper.pycode.build_helper.get_pyproj_project>`                                                   |              | returns a string which corresponds to a pyproj project                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_relative_path <pyquickhelper.loghelper.flog.get_relative_path>`                                                          |              | private function, return the relative path or absolute between a folder and a file, use `relpath <https://docs.python.org/3/library/os.path.html#os.path.relpath>`_ ...                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_repo_log <pyquickhelper.loghelper.repositories.pygit_helper.get_repo_log>`                                               |              | Gets the latest changes operated on a file in a folder or a subfolder.                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_repo_log <pyquickhelper.loghelper.repositories.pysvn_helper.get_repo_log>`                                               |              | get the latest changes operated on a file in a folder or a subfolder                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_repo_version <pyquickhelper.loghelper.repositories.pygit_helper.get_repo_version>`                                       |              | Gets the latest check for a specific path or version number based on the date (if *usedate* is True). If *usedate* ...                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_repo_version <pyquickhelper.loghelper.repositories.pysvn_helper.get_repo_version>`                                       |              | get the latest check in number for a specific path                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_script_command <pyquickhelper.pycode.build_helper.get_script_command>`                                                   |              | Produces a script which runs a command available through the setup.                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_script_extension <pyquickhelper.pycode.setup_helper.get_script_extension>`                                               |              | Returns the scripts extension based on the system it is running on.                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_script_module <pyquickhelper.pycode.build_helper.get_script_module>`                                                     |              | Produces a script which runs the notebook, a documentation server, which publishes and other scripts.                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_size <pyquickhelper.sphinxext.sphinx_youtube_extension.get_size>`                                                        |              | Get size.                                                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_source <pyquickhelper.pycode.coverage_helper.get_source>`                                                                |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_temp_folder <pyquickhelper.pycode.utils_tests_helper.get_temp_folder>`                                                   |              | Creates and returns a local temporary folder to store files when unit testing.                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_test_file <pyquickhelper.pycode.utils_tests_private.get_test_file>`                                                      |              | Returns the list of test files.                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_url_content <pyquickhelper.loghelper.url_helper.get_url_content>`                                                        |              | retrieve the content of an url                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_url_content_timeout <pyquickhelper.filehelper.download_helper.get_url_content_timeout>`                                  |              | Downloads a file from internet (by default, it assumes it is text information, otherwise, encoding should be None).                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_urls_content_timeout <pyquickhelper.filehelper.download_helper.get_urls_content_timeout>`                                |              | Downloads data from urls (by default, it assumes it is text information, otherwise, encoding should be None).                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`get_user <pyquickhelper.loghelper.os_helper.get_user>`                                                                       |              | Returns the user name.                                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`getsitepackages <pyquickhelper.helpgen.utils_sphinx_config.getsitepackages>`                                                 |              | Overwrites function :epkg:`getsitepackages` which does not work for a virtual environment.                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`getstate <pyquickhelper.pycode.unittest_assert.getstate>`                                                                    |              | Returns the state of an objects. It cannot be used to restore the object.                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`githublink_role <pyquickhelper.sphinxext.sphinx_githublink_extension.githublink_role>`                                       |              | Defines custom role *githublink*. The following instruction add a link to the documentation on github.                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`gitlog_role <pyquickhelper.sphinxext.sphinx_gitlog_extension.gitlog_role>`                                                   |              | Defines custom role *gitlog*. The following instruction prints out the date of the last modification for the current ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_machine_parameter <pyquickhelper.loghelper.flog.guess_machine_parameter>`                                              |              | Determines many parameters on this machine:                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_module_name <pyquickhelper.cli.cli_helper.guess_module_name>`                                                          |              | Guesses the module name based on a function.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_svg_size <pyquickhelper.imghelper.svg_helper.guess_svg_size>`                                                          |              | Guesses the dimension of a :epkg:`SVG` image.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_type_list <pyquickhelper.loghelper.flog.guess_type_list>`                                                              |              | guess the type of a list                                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_type_value <pyquickhelper.loghelper.flog.guess_type_value>`                                                            |              | Guessees the type of a value.                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`guess_type_value_type <pyquickhelper.loghelper.flog.guess_type_value_type>`                                                  |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`gzip_files <pyquickhelper.filehelper.compression_helper.gzip_files>`                                                         |              | Compresses all files from an iterator in a zip file and then in a gzip file.                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`has_been_updated <pyquickhelper.filehelper.synchelper.has_been_updated>`                                                     |              | It assumes *dest* is a copy of *source*, it wants to know if the copy is up to date or not.                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`hash_list <pyquickhelper.pycode.setup_helper.hash_list>`                                                                     |              | Proposes a hash for the list of arguments.                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`heading <pyquickhelper.sphinxext.revealjs.directives.heading>`                                                               |              | directives choices for heading tag                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`html_diffs <pyquickhelper.texthelper.text_diff.html_diffs>`                                                                  |              | Comparares two strings and renders the results as HTML.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`html_in_frame <pyquickhelper.texthelper.html_helper.html_in_frame>`                                                          |              | Inserts :epkg:`HTML` text into a frame in binary format.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`ignore_warnings <pyquickhelper.pycode.unittestclass.ignore_warnings>`                                                        |              | Catches warnings.                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`images2pdf <pyquickhelper.imghelper.img_export.images2pdf>`                                                                  |              | Merges multiples images into one single pdf. Relies on :epkg:`img2pdf`. If an image name contains ``'*'``, the function ...                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_any_object <pyquickhelper.sphinxext.import_object_helper.import_any_object>`                                          |              | Extracts an object defined by its name including the module name.                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_files <pyquickhelper.pycode.utils_tests_private.import_files>`                                                        |              | Runs all tests in file list ``li``.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_module <pyquickhelper.helpgen.utils_sphinx_doc_helpers.import_module>`                                                |              | Imports a module using its filename.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_object <pyquickhelper.sphinxext.import_object_helper.import_object>`                                                  |              | Extracts an object defined by its name including the module name.                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_path <pyquickhelper.sphinxext.import_object_helper.import_path>`                                                      |              | Determines the import path which is the shortest way to import the function. In case the following ``from module.submodule import function`` ...                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`import_pywin32 <pyquickhelper.helpgen.utils_pywin32.import_pywin32>`                                                         |              | For the module ``pywin32``, this function tries to add the path to the DLL to ``PATH`` before throwing the exception: ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`infer_project_name <pyquickhelper.jenkinshelper.yaml_helper.infer_project_name>`                                             |              | Infers a project name based on :epkg:`yml` file.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`info_blocref <pyquickhelper.sphinxext.sphinx_ext_helper.info_blocref>`                                                       |              | Log information with :epkg:`Sphinx`.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`init <pyquickhelper.loghelper.flog.init>`                                                                                    |              | initialisation                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`initialize_simpleimages_directive <pyquickhelper.sphinxext.sphinx_image_extension.initialize_simpleimages_directive>`        |              | Initializes the image directives.                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`initialize_videos_directive <pyquickhelper.sphinxext.sphinx_video_extension.initialize_videos_directive>`                    |              | Initializes the video directives.                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_backend_static_files <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.install_backend_static_files>`          |              | local function                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_javascript_tools <pyquickhelper.helpgen.install_js_dep.install_javascript_tools>`                                    |              | Installs extra dependencies such as :epkg:`reveal.js`.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_jupyter_kernel <pyquickhelper.ipythonhelper.notebook_helper.install_jupyter_kernel>`                                 |              | Installs a kernel based on executable (this python by default).                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_node_js_modules <pyquickhelper.imghelper.js_helper.install_node_js_modules>`                                         |              | Installs missing dependencies to compile a convert a :epkg:`javascript` libraries.                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_notebook_extension <pyquickhelper.ipythonhelper.notebook_helper.install_notebook_extension>`                         |              | Installs notebook extensions, see `install_nbextension <https://ipython.org/ipython-doc/ dev/api/generated/IPython.html.nbextensions.html #IPython.html.nbextensions.install_nbextension>`_ ...    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`install_python_kernel_for_unittest <pyquickhelper.ipythonhelper.notebook_helper.install_python_kernel_for_unittest>`         |              | Installs a kernel based on this python (sys.executable) for unit test purposes.                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`interpret_instruction <pyquickhelper.jenkinshelper.yaml_helper.interpret_instruction>`                                       |              | Interprets an instruction with if statement.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_file_string <pyquickhelper.filehelper.file_info.is_file_string>`                                                          |              | Tells if the string *s* could be a filename.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_file_string <pyquickhelper.helpgen._my_doxypy.is_file_string>`                                                            |              | Says if the string s could be a filename.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_html5_writer_available <pyquickhelper.helpgen.sphinxm_convert_doc_sphinx_helper.is_html5_writer_available>`               |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_travis_or_appveyor <pyquickhelper.pycode.ci_helper.is_travis_or_appveyor>`                                                |              | Tells if is a *travis* environment or *appveyor*.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_url_string <pyquickhelper.filehelper.file_info.is_url_string>`                                                            |              | Tells if the string s could be a url.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_valid_error <pyquickhelper.pycode.utils_tests_private.is_valid_error>`                                                    |              | Checks if the text written on stderr is an error or not, a local server can push logs on this stream, it looks for ...                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`is_virtual_environment <pyquickhelper.pycode.venv_helper.is_virtual_environment>`                                            |              | Tells if the script is run from a virtual environment.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`isempty <pyquickhelper.pandashelper.tblfunction.isempty>`                                                                    |              | checks that a string is empty, returns also True if s is ``NaN``                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`isnan <pyquickhelper.pandashelper.tblfunction.isnan>`                                                                        |              | calls :epkg:`numpy:isnan` but checks it is a float first                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`jenkins_final_postprocessing <pyquickhelper.jenkinshelper.jenkins_helper.jenkins_final_postprocessing>`                      |              | Postprocesses a job produced by :epkg:`Jenkins`.                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`latex2rst <pyquickhelper.helpgen.pandoc_helper.latex2rst>`                                                                   |              | convert a latex document into a rst document using pandoc                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`latex_preamble <pyquickhelper._cst.cst_sphinx.latex_preamble>`                                                               |              | Default latex preamble.                                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`load_content_file_with_encoding <pyquickhelper.loghelper.flog.load_content_file_with_encoding>`                              |              | Tries different encoding to load a file, tries utf8, latin1 and None.                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`load_ipython_extension <pyquickhelper.load_ipython_extension>`                                                               |              | to allow the call ``%load_ext pyquickhelper``                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`load_yaml <pyquickhelper.jenkinshelper.yaml_helper.load_yaml>`                                                               |              | Loads a :epkg:`yml` file (*.yml*).                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`local_url <pyquickhelper.filehelper.download_helper.local_url>`                                                              |              | Replaces the url by a local file in a folder or an environment variable if *folder* is None.                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`locate_image_documentation <pyquickhelper.helpgen.utils_sphinx_config.locate_image_documentation>`                           |              | Tries to local an image in the module for help generation in a folder ``_doc``.                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main <pyquickhelper.__main__.main>`                                                                                          |              | Implements ``python -m pyquickhelper <command> <args>``.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main <pyquickhelper.helpgen._my_doxypy.main>`                                                                                |              | Starts the parser on the file given by the filename as the first argument on the commandline.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main <pyquickhelper.helpgen.process_notebooks_cmd.main>`                                                                     |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main <pyquickhelper.helpgen.process_sphinx_cmd.main>`                                                                        |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main_run_test <pyquickhelper.pycode.utils_tests_private.main_run_test>`                                                      |              | Runs all unit tests, the function looks into the folder _unittest and extract from all files beginning by `test_` ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`main_wrapper_tests <pyquickhelper.pycode.utils_tests.main_wrapper_tests>`                                                    |              | Calls function :func:`main <pyquickhelper.unittests.utils_tests.main>` and throws an exception if it fails.                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`make_label_index <pyquickhelper.helpgen.utils_sphinx_doc_helpers.make_label_index>`                                          |              | Builds a :epkg:`sphinx` label from a string by removing any odd characters.                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`make_link_node <pyquickhelper.sphinxext.sphinx_githublink_extension.make_link_node>`                                         |              | Create a link to a github file.                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`measure_documentation <pyquickhelper.texthelper.code_helper.measure_documentation>`                                          |              | Measures the fact a module is documented.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`measure_documentation_module <pyquickhelper.texthelper.code_helper.measure_documentation_module>`                            |              | Measures the fact a module is documented.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_blocref <pyquickhelper.sphinxext.sphinx_blocref_extension.merge_blocref>`                                              |              | merge_blocref                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_cmdref <pyquickhelper.sphinxext.sphinx_cmdref_extension.merge_cmdref>`                                                 |              | merge_cmdref                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_exref <pyquickhelper.sphinxext.sphinx_exref_extension.merge_exref>`                                                    |              | merge_exref                                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_faqref <pyquickhelper.sphinxext.sphinx_faqref_extension.merge_faqref>`                                                 |              | merge_faqref                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_mathdef <pyquickhelper.sphinxext.sphinx_mathdef_extension.merge_mathdef>`                                              |              | merge_mathdef                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_nbref <pyquickhelper.sphinxext.sphinx_nbref_extension.merge_nbref>`                                                    |              | merge_nbref                                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`merge_todoext <pyquickhelper.sphinxext.sphinx_todoext_extension.merge_todoext>`                                              |              | merge_todoext                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`migrating_doxygen_doc <pyquickhelper.helpgen.utils_sphinx_doc.migrating_doxygen_doc>`                                        |              | Migrates the doxygen documentation to rst format.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`modifies_init_file <pyquickhelper.pycode.setup_helper.modifies_init_file>`                                                   |              | Automatically modifies the init file.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`must_build <pyquickhelper.pycode.insetup_helper.must_build>`                                                                 |              | Determines if the module must be built before running the command in *argv*.                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`my_date_conversion <pyquickhelper.helpgen.sphinx_main_helper.my_date_conversion>`                                            |              | Converts a date into a datetime.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`my_date_conversion <pyquickhelper.loghelper.repositories.pygit_helper.my_date_conversion>`                                   |              | Converts a date into a datetime.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`nb2html <pyquickhelper.helpgen.process_notebook_api.nb2html>`                                                                |              | Converts a notebook into HTML.                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`nb2rst <pyquickhelper.helpgen.process_notebook_api.nb2rst>`                                                                  |              | Converts a notebook into :epkg:`RST`.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`nb2slides <pyquickhelper.helpgen.process_notebook_api.nb2slides>`                                                            |              | Converts a notebook into slides, it copies :epkg:`reveal.js` if not present in the folder of the output.                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`noLOG <pyquickhelper.loghelper.flog.noLOG>`                                                                                  |              | does nothing                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`nodejs_version <pyquickhelper.imghelper.js_helper.nodejs_version>`                                                           |              | Returns :epkg:`node.js` version.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`notebook_coverage <pyquickhelper.ipythonhelper.run_notebook.notebook_coverage>`                                              |              | Extracts a list of notebooks and merges with a list of runs dumped by function :func:`execute_notebook_list_finalize_ut`. ...                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`numeric_module_version <pyquickhelper.texthelper.version_helper.numeric_module_version>`                                     |              | Converts a string into a tuple with numbers wherever possible.                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`open_html_form <pyquickhelper.ipythonhelper.html_forms.open_html_form>`                                                      |              | The function displays a form onto a notebook, it requires a notebook to be open.                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`open_input_output <pyquickhelper.filehelper.encryption.open_input_output>`                                                   |              | Converts *filename* and *out_filename* as streams.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`open_script <pyquickhelper.pycode.open_script_file.open_script>`                                                             |              | Open a filename but read the encoding from the first line.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`optParse <pyquickhelper.helpgen._my_doxypy.optParse>`                                                                        |              | Parses commandline options.                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`ospathdirname <pyquickhelper.jenkinshelper.yaml_helper.ospathdirname>`                                                       |              | Simple ``o.path.dirname`` for a specific platform.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`ospathjoin <pyquickhelper.jenkinshelper.yaml_helper.ospathjoin>`                                                             |              | Simple ``o.path.join`` for a specific platform.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`package2dict <pyquickhelper.pycode.pip_helper.package2dict>`                                                                 |              | Extracts information from a package.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`parse_exception_message <pyquickhelper.loghelper.run_cmd.parse_exception_message>`                                           |              | Parses the message embedded in an exception and returns the standard output and error if it can be found.                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`parse_markdown <pyquickhelper.helpgen.markdown_helper.parse_markdown>`                                                       |              | parse markdown text and return the markdown object                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`pickname <pyquickhelper.jenkinshelper.yaml_helper.pickname>`                                                                 |              | Picks the first string non null in the list.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`plot_graphviz <pyquickhelper.helpgen.graphviz_helper.plot_graphviz>`                                                         |              | Plots a dot graph into a :epkg:`matplotlib` plot.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_html_nb_output_static_file <pyquickhelper.helpgen.sphinx_helper.post_process_html_nb_output_static_file>`       |              | post process the HTML files produced by Sphinx to adjust the static files in notebooks (IPython static files do have ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_html_output <pyquickhelper.helpgen.post_process.post_process_html_output>`                                      |              | Processes a HTML file generated from the conversion of a notebook.                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_latex <pyquickhelper.helpgen.post_process.post_process_latex>`                                                  |              | Modifies a :epkg:`latex` file after its generation by :epkg:`sphinx`.                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_latex_output <pyquickhelper.helpgen.post_process.post_process_latex_output>`                                    |              | Postprocesses the latex file produced by :epkg:`sphinx`.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_latex_output_any <pyquickhelper.helpgen.post_process.post_process_latex_output_any>`                            |              | Postprocesses the latex file produced by :epkg:`sphinx`.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_python <pyquickhelper.helpgen.post_process.post_process_python>`                                                |              | Modifies a python file after its generation by :epkg:`sphinx`.                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_python_output <pyquickhelper.helpgen.post_process.post_process_python_output>`                                  |              | Postprocesses the python file produced by :epkg:`sphinx`.                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_rst_output <pyquickhelper.helpgen.post_process.post_process_rst_output>`                                        |              | Processes a :epkg:`rst` file generated from the conversion of a notebook.                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`post_process_slides_output <pyquickhelper.helpgen.post_process.post_process_slides_output>`                                  |              | Processes a :epkg:`HTML` file generated from the conversion of a notebook.                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`prepare_file_for_sphinx_help_generation <pyquickhelper.helpgen.utils_sphinx_doc.prepare_file_for_sphinx_help_generation>`    |              | Prepares all files for :epkg:`Sphinx` generation.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`private_path_choice <pyquickhelper.pycode.build_helper.private_path_choice>`                                                 |              | Custom logic to reference other currently developped modules.                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`private_replacement_ <pyquickhelper.pycode.build_helper.private_replacement_>`                                               |              | Less copy/paste.                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`private_script_replacements <pyquickhelper.pycode.build_helper.private_script_replacements>`                                 |              | Runs last replacements.                                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_argv_for_unittest <pyquickhelper.pycode.setup_helper.process_argv_for_unittest>`                                     |              | Interprets command line arguments.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_blocref_nodes <pyquickhelper.sphinxext.sphinx_blocref_extension.process_blocref_nodes>`                              |              | process_blocref_nodes                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_blocref_nodes_generic <pyquickhelper.sphinxext.sphinx_blocref_extension.process_blocref_nodes_generic>`              |              | process_blocref_nodes and other kinds of nodes, If the configuration file specifies a variable ``blocref_include_blocrefs`` ...                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_blocrefs <pyquickhelper.sphinxext.sphinx_blocref_extension.process_blocrefs>`                                        |              | collect all blocrefs in the environment this is not done in the directive itself because it some transformations ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_blocrefs_generic <pyquickhelper.sphinxext.sphinx_blocref_extension.process_blocrefs_generic>`                        |              | collect all blocrefs in the environment this is not done in the directive itself because it some transformations ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_blogpost_nodes <pyquickhelper.sphinxext.sphinx_blog_extension.process_blogpost_nodes>`                               |              | unused, kept as example                                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_cmdref_nodes <pyquickhelper.sphinxext.sphinx_cmdref_extension.process_cmdref_nodes>`                                 |              | process_cmdref_nodes                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_cmdrefs <pyquickhelper.sphinxext.sphinx_cmdref_extension.process_cmdrefs>`                                           |              | Collect all cmdrefs in the environment this is not done in the directive itself because it some transformations ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_copy_images <pyquickhelper.helpgen.utils_sphinx_doc.process_copy_images>`                                            |              | Looks into every file .rst or .py for images (                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_downloadlink_role <pyquickhelper.sphinxext.sphinx_downloadlink_extension.process_downloadlink_role>`                 |              | Defines custom role *downloadlink*. The following instructions defines a link which can be displayed or hidden based ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_exref_nodes <pyquickhelper.sphinxext.sphinx_exref_extension.process_exref_nodes>`                                    |              | process_blocref_nodes                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_exrefs <pyquickhelper.sphinxext.sphinx_exref_extension.process_exrefs>`                                              |              | collect all *exref* in the environment this is not done in the directive itself because it some transformations ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_faqref_nodes <pyquickhelper.sphinxext.sphinx_faqref_extension.process_faqref_nodes>`                                 |              | process_faqref_nodes                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_faqrefs <pyquickhelper.sphinxext.sphinx_faqref_extension.process_faqrefs>`                                           |              | collect all *faqref* in the environment this is not done in the directive itself because it some transformations ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_look_for_tag <pyquickhelper.helpgen.utils_sphinx_doc_helpers.process_look_for_tag>`                                  |              | Looks for specific information in all files, collect them into one single page.                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_mathdef_nodes <pyquickhelper.sphinxext.sphinx_mathdef_extension.process_mathdef_nodes>`                              |              | process_mathdef_nodes                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_mathdefs <pyquickhelper.sphinxext.sphinx_mathdef_extension.process_mathdefs>`                                        |              | collect all mathdefs in the environment this is not done in the directive itself because it some transformations ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_nbref_nodes <pyquickhelper.sphinxext.sphinx_nbref_extension.process_nbref_nodes>`                                    |              | process_nbref_nodes                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_nbrefs <pyquickhelper.sphinxext.sphinx_nbref_extension.process_nbrefs>`                                              |              | Collect all *nbref* in the environment this is not done in the directive itself because it some transformations ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_notebooks <pyquickhelper.helpgen.process_notebooks.process_notebooks>`                                               |              | Converts notebooks into :epkg:`html`, :epkg:`rst`, :epkg:`latex`, :epkg:`pdf`, :epkg:`python`, :epkg:`docx` using ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_postcontents <pyquickhelper.sphinxext.sphinx_postcontents_extension.process_postcontents>`                           |              | Collect all *postcontents* in the environment. Look for the section or document which contain them. Put them into ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_raw_html <pyquickhelper.helpgen.notebook_exporter.process_raw_html>`                                                 |              | Replaces the output of `add_menu_notebook <http://www.xavierdupre.fr/app/jyquickhelper/helpsphinx/jyquickhelper/ helper_in_notebook.html#jyquickhelper.helper_in_notebook.add_notebook_menu>`_ ... |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_standard_options_for_setup <pyquickhelper.pycode.setup_helper.process_standard_options_for_setup>`                   |              | Processes the standard options the module pyquickhelper is able to process assuming the module which calls this function ...                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_standard_options_for_setup_help <pyquickhelper.pycode.setup_helper.process_standard_options_for_setup_help>`         |              | Prints the added options available through this module.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_string <pyquickhelper.helpgen._my_doxypy.process_string>`                                                            |              | Applies the doxypy like process to a string.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_tocdelay <pyquickhelper.sphinxext.sphinx_tocdelay_extension.process_tocdelay>`                                       |              | Collect all *tocdelay* in the environment. Look for the section or document which contain them. Put them into the ...                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_todoext_nodes <pyquickhelper.sphinxext.sphinx_todoext_extension.process_todoext_nodes>`                              |              | process_todoext_nodes                                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_todoexts <pyquickhelper.sphinxext.sphinx_todoext_extension.process_todoexts>`                                        |              | collect all todoexts in the environment this is not done in the directive itself because it some transformations ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`process_var_tag <pyquickhelper.helpgen.utils_sphinx_doc_helpers.process_var_tag>`                                            |              | Processes a docstring using tag ``@ var``, and return a list of 2-tuple                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`produce_code_graph_changes <pyquickhelper.helpgen.sphinx_main_helper.produce_code_graph_changes>`                            |              | Returns the code for a graph which counts the number of changes per week over the last year.                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`produces_indexes <pyquickhelper.helpgen.utils_sphinx_doc.produces_indexes>`                                                  |              | Produces a file for each category of object found in the module.                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`profile <pyquickhelper.pycode.profiling.profile>`                                                                            |              | Profiles the execution of a function.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`profile2df <pyquickhelper.pycode.profiling.profile2df>`                                                                      |              | Converts profiling statistics into a Dataframe.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`profile2graph <pyquickhelper.pycode.profiling.profile2graph>`                                                                |              | Converts profiling statistics into a graphs.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`profile_stat <pyquickhelper.cli.profile_cli.profile_stat>`                                                                   |              | Analyses the output of a profiling measured by module :mod:`cProfile`.                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`publish_coverage_on_codecov <pyquickhelper.pycode.coverage_helper.publish_coverage_on_codecov>`                              |              | Publishes the coverage report on `codecov <https://codecov.io/>`_. See blog post :ref:`blogpost_coverage_codecov`.                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_blocrefs <pyquickhelper.sphinxext.sphinx_blocref_extension.purge_blocrefs>`                                            |              | purge_blocrefs                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_blogpost <pyquickhelper.sphinxext.sphinx_blog_extension.purge_blogpost>`                                               |              | unused, kept as example                                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_cmdrefs <pyquickhelper.sphinxext.sphinx_cmdref_extension.purge_cmdrefs>`                                               |              | purge_cmdrefs                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_exrefs <pyquickhelper.sphinxext.sphinx_exref_extension.purge_exrefs>`                                                  |              | purge_exrefs                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_faqrefs <pyquickhelper.sphinxext.sphinx_faqref_extension.purge_faqrefs>`                                               |              | purge_faqrefs                                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_mathsext <pyquickhelper.sphinxext.sphinx_mathdef_extension.purge_mathsext>`                                            |              | purge_mathsext                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_nbrefs <pyquickhelper.sphinxext.sphinx_nbref_extension.purge_nbrefs>`                                                  |              | purge_nbrefs                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`purge_todosext <pyquickhelper.sphinxext.sphinx_todoext_extension.purge_todosext>`                                            |              | purge_todosext                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`py3to2_convert <pyquickhelper.pycode.py3to2.py3to2_convert>`                                                                 |              | converts a script into from python 3 to python 2                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`py3to2_convert_tree <pyquickhelper.pycode.py3to2.py3to2_convert_tree>`                                                       |              | Converts files in a folder and its subfolders from python 3 to python 2, the function only considers python script (verifying ...                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`py3to2_future <pyquickhelper.pycode.py3to2.py3to2_future>`                                                                   |              | checks that import ``from __future__ import unicode_literals`` is always present, the function assumes it is a python ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`py3to2_imported_local_modules <pyquickhelper.pycode.py3to2.py3to2_imported_local_modules>`                                   |              | See function :func:`py3to2_convert_tree` and documentation about parameter *unittest_modules*.                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`py3to2_remove_raise_from <pyquickhelper.pycode.py3to2.py3to2_remove_raise_from>`                                             |              | Removes expression such as: ``raise Exception ("...") from e``. The function is very basic. It should be done with a ...                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`pyq_sync <pyquickhelper.cli.pyq_sync_cli.pyq_sync>`                                                                          |              | Synchronizes a folder using function :func:`synchronize_folder`.                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`python_link_doc <pyquickhelper.sphinxext.documentation_link.python_link_doc>`                                                |              | Returns a url about :epkg:`Python` documentation.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`read_content_ufs <pyquickhelper.filehelper.anyfhelper.read_content_ufs>`                                                     |              | Reads the content of a source, whether it is a url, a file, a stream or a string (in that case, it returns the string ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`read_csv <pyquickhelper.pandashelper.readh.read_csv>`                                                                        |              | Reads a file from a file, it adds the compression zip which was removed in the latest version, see :epkg:`pandas:read_csv`. ...                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`read_nb <pyquickhelper.ipythonhelper.notebook_helper.read_nb>`                                                               |              | Reads a notebook and return a :class:`NotebookRunner` object.                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`read_nb_json <pyquickhelper.ipythonhelper.notebook_helper.read_nb_json>`                                                     |              | Reads a notebook from a :epkg:`JSON` stream or string.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`read_url <pyquickhelper.filehelper.internet_helper.read_url>`                                                                |              | Reads the content of a url.                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`reap_children <pyquickhelper.loghelper.process_helper.reap_children>`                                                        |              | Terminates children processes. Copied from `psutil <http://psutil.readthedocs.io/en/latest/index.html?highlight=terminate#terminate-my-children>`_. ...                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`rebase <pyquickhelper.loghelper.repositories.pygit_helper.rebase>`                                                           |              | Runs ``git pull -rebase`` on a repository.                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`register_file_magics <pyquickhelper.ipythonhelper.magic_class_compress.register_file_magics>`                                |              | Registers magics function, can be called from a notebook.                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`register_file_magics <pyquickhelper.ipythonhelper.magic_class_crypt.register_file_magics>`                                   |              | Register magics function, can be called from a notebook.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`register_file_magics <pyquickhelper.ipythonhelper.magic_class_diff.register_file_magics>`                                    |              | Register magics function, can be called from a notebook.                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`register_file_magics <pyquickhelper.ipythonhelper.magic_class_example.register_file_magics>`                                 |              | Registers magics functions, can be called from a notebook.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_character_under32 <pyquickhelper.helpgen.post_process.remove_character_under32>`                                      |              | Removes :epkg:`ASCII` characters in *[0..31]*.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_diacritics <pyquickhelper.texthelper.diacritic_helper.remove_diacritics>`                                             |              | Removes diacritics.                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_execution_number <pyquickhelper.ipythonhelper.notebook_helper.remove_execution_number>`                               |              | Removes execution number from a notebook.                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_extra_spaces_and_pep8 <pyquickhelper.pycode.code_helper.remove_extra_spaces_and_pep8>`                                |              | Removes extra spaces in a filename, replaces the file in place.                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_extra_spaces_folder <pyquickhelper.pycode.code_helper.remove_extra_spaces_folder>`                                    |              | Removes extra files in a folder for specific file extensions.                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_folder <pyquickhelper.filehelper.synchelper.remove_folder>`                                                           |              | Removes everything in folder *top*.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_kernel <pyquickhelper.ipythonhelper.notebook_helper.remove_kernel>`                                                   |              | Removes a kernel.                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_some_indent <pyquickhelper.helpgen.utils_sphinx_doc_helpers.remove_some_indent>`                                      |              | Brings text to the left.                                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`remove_undesired_part_for_documentation <pyquickhelper.helpgen.utils_sphinx_doc.remove_undesired_part_for_documentation>`    |              | Some files contains blocs inserted between the two lines:                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`removedirs <pyquickhelper.loghelper.flog.removedirs>`                                                                        |              | Removes all files and folders in *folder*.                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`repeat_execution <pyquickhelper.loghelper.time_helper.repeat_execution>`                                                     |              | Runs a function on a regular basis. The function is not multithreaded, it returns when all execution are done.                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`repeat_script <pyquickhelper.cli.script_exec.repeat_script>`                                                                 |              | Runs a python script on a regular basis. The function is not multithreaded, it returns when all execution are done. ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`repeat_script_execution <pyquickhelper.loghelper.time_helper.repeat_script_execution>`                                       |              | Runs a python script on a regular basis. The function is not multithreaded, it returns when all execution are done. ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`replace_placeholder_by_recent_blogpost <pyquickhelper.helpgen.sphinx_main_helper.replace_placeholder_by_recent_blogpost>`    |              | Replaces a place holder by a list of blog post.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`replace_relative_import_fct <pyquickhelper.helpgen.utils_sphinx_doc.replace_relative_import_fct>`                            |              | Takes a :epkg:`python` file and replaces all relative imports it was able to find by an import which can be processed ...                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`repo_ls <pyquickhelper.loghelper.repositories.pygit_helper.repo_ls>`                                                         |              | Runs ``ls`` on a path.                                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`repo_ls <pyquickhelper.loghelper.repositories.pysvn_helper.repo_ls>`                                                         |              | run ``ls`` on a path                                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`require <pyquickhelper.imghelper.js_helper.require>`                                                                         |              | Modified version of function *require* in `node_import.py <https://github.com/PiotrDabkowski/Js2Py/blob/master/js2py/node_import.py>`_. ...                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`retrieve_notebooks_in_folder <pyquickhelper.ipythonhelper.run_notebook.retrieve_notebooks_in_folder>`                        |              | Retrieves notebooks in a test folder.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`rss_update_run_server <pyquickhelper.pycode.blog_helper.rss_update_run_server>`                                              |              | Creates a database if it does not exists, add a table for blogs and posts, update the database, starts a server and ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`rst2html <pyquickhelper.helpgen.rst_converters.rst2html>`                                                                    |              | Converts a string from :epkg:`RST` into :epkg:`HTML` format or transformed :epkg:`RST`.                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`rst2rst_folder <pyquickhelper.helpgen.rst_converters.rst2rst_folder>`                                                        |              | Converts a :epkg:`RST` string into simplified :epkg:`RST`.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_base_script <pyquickhelper.pycode.venv_helper.run_base_script>`                                                          |              | Runs a script with the original intepreter even if this function is run from a virtual environment.                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_build_ext <pyquickhelper.pycode.insetup_helper.run_build_ext>`                                                           |              | Runs ``setup.py build_ext --inplace``.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_cmd <pyquickhelper.loghelper.run_cmd.run_cmd>`                                                                           |              | Runs a command line and wait for the result.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_doc_server <pyquickhelper.server.documentation_server.run_doc_server>`                                                   |              | Runs the server.                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_js_fct <pyquickhelper.imghelper.js_helper.run_js_fct>`                                                                   |              | Assuming *script* contains some :epkg:`javascript` which produces :epkg:`SVG`. This functions runs the code.                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_js_with_nodejs <pyquickhelper.imghelper.js_helper.run_js_with_nodejs>`                                                   |              | Runs a :epkg:`javascript` script with :epkg:`node.js`.                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_nbconvert <pyquickhelper.helpgen.process_notebooks_cmd.run_nbconvert>`                                                   |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_notebook <pyquickhelper.cli.notebook.run_notebook>`                                                                      |              | Runs a notebook end to end, it is inspired from module `runipy <https://github.com/paulgb/runipy/>`_.                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_notebook <pyquickhelper.ipythonhelper.run_notebook.run_notebook>`                                                        |              | Runs a notebook end to end, it is inspired from module `runipy <https://github.com/paulgb/runipy/>`_.                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_pylint_for_setup <pyquickhelper.pycode.setup_helper.run_pylint_for_setup>`                                               |              | Applies :epkg:`pylint` on subfolder *folder*.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_python_script <pyquickhelper.sphinxext.sphinx_runpython_extension.run_python_script>`                                    |              | Executes a script :epkg:`python` as a string.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_script <pyquickhelper.loghelper.run_cmd.run_script>`                                                                     |              | Runs a script.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_sphinx_build <pyquickhelper.helpgen.process_sphinx_cmd.run_sphinx_build>`                                                |              |                                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_test_function <pyquickhelper.pycode.pytest_helper.run_test_function>`                                                    |              | Runs test functions from *module*.                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_unittests_for_setup <pyquickhelper.pycode.setup_helper.run_unittests_for_setup>`                                         |              | Runs the unit tests and computes the coverage, stores the results in ``_doc/sphinxdoc/source/coverage`` assuming ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`run_venv_script <pyquickhelper.pycode.venv_helper.run_venv_script>`                                                          |              | Runs a script on a vritual environment (the script should be simple).                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`set_password <pyquickhelper.loghelper.pwd_helper.set_password>`                                                              |              | Stores a password. By default, uses :epkg:`keyring` or :epkg:`keyrings.cryptfile`.                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`set_sphinx_variables <pyquickhelper.helpgen.default_conf.set_sphinx_variables>`                                              |              | Defines variables for :epkg:`Sphinx`.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.revealjs.directives.setup>`                                                                   |              | Initialize                                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.revealjs.setup>`                                                                              |              | entry-point for sphinx directive.                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_autosignature.setup>`                                                                  |              | Create a new directive called *autosignature* which displays the signature of the function.                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_bigger_extension.setup>`                                                               |              | setup for ``bigger`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_blocref_extension.setup>`                                                              |              | setup for ``blocref`` (sphinx)                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_blog_extension.setup>`                                                                 |              | setup for ``blogpost`` (sphinx)                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_cmdref_extension.setup>`                                                               |              | setup for ``cmdref`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_collapse_extension.setup>`                                                             |              | setup for ``collapse`` (sphinx)                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_docassert_extension.setup>`                                                            |              | setup for docassert                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_doctree_builder.setup>`                                                                |              | Initializes the doctree builder.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_downloadlink_extension.setup>`                                                         |              | setup for ``bigger`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_epkg_extension.setup>`                                                                 |              | setup for ``bigger`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_exref_extension.setup>`                                                                |              | setup for ``exref`` (sphinx)                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_faqref_extension.setup>`                                                               |              | setup for ``faqref`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_gdot_extension.setup>`                                                                 |              | setup for ``gdot`` (sphinx)                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_githublink_extension.setup>`                                                           |              | setup for ``githublink`` (:epkg:`sphinx`)                                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_gitlog_extension.setup>`                                                               |              | setup for ``gitlog`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_image_extension.setup>`                                                                |              | setup for ``image`` (sphinx)                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_latex_builder.setup>`                                                                  |              | Initializes builder :class:`EnhancedLaTeXBuilder`.                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_mathdef_extension.setup>`                                                              |              | setup for ``mathdef`` (sphinx)                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_md_builder.setup>`                                                                     |              | Initializes the :epkg:`MD` builder.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_nbref_extension.setup>`                                                                |              | setup for ``nbref`` (sphinx)                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_postcontents_extension.setup>`                                                         |              | setup for ``postcontents`` (sphinx)                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_quote_extension.setup>`                                                                |              | setup for ``mathdef`` (sphinx)                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_rst_builder.setup>`                                                                    |              | Initializes the :epkg:`RST` builder.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_runpython_extension.setup>`                                                            |              | setup for ``runpython`` (sphinx)                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_sharenet_extension.setup>`                                                             |              | setup for ``sharenet`` (sphinx)                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_template_extension.setup>`                                                             |              | setup for ``bigger`` (sphinx)                                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_tocdelay_extension.setup>`                                                             |              | setup for ``tocdelay`` (sphinx)                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_toctree_extension.setup>`                                                              |              | Setup for ``toctree`` and ``toctree2`` (sphinx).                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_todoext_extension.setup>`                                                              |              | Setup for ``todoext`` (sphinx).                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_video_extension.setup>`                                                                |              | setup for ``video`` (sphinx)                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinx_youtube_extension.setup>`                                                              |              | Setup for youtube extension.                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup <pyquickhelper.sphinxext.sphinximages.sphinxtrib.images.setup>`                                                        |              | setup for :epkg:`sphinx` extension                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup_docassert <pyquickhelper.sphinxext.sphinx_docassert_extension.setup_docassert>`                                        |              | Setup for ``docassert`` extension (sphinx). This changes ``DocFieldTransformer.transform`` and replaces it by a ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup_environment_for_help <pyquickhelper.helpgen.sphinx_main_helper.setup_environment_for_help>`                            |              | Modifies environment variables to be able to use external tools such as :epkg:`Inkscape`.                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`setup_jenkins_server_yml <pyquickhelper.jenkinshelper.jenkins_helper.setup_jenkins_server_yml>`                              |              | Sets up many jobs on :epkg:`Jenkins`.                                                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`sharenet_role <pyquickhelper.sphinxext.sphinx_sharenet_extension.sharenet_role>`                                             |              | Defines custom roles *sharenet*. The following instructions defines buttons of size 20 (:sharenet:`facebook-linkedin-twitter-20-body`) ...                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skip_run_cmd <pyquickhelper.loghelper.run_cmd.skip_run_cmd>`                                                                 |              | Has the same signature as :func:`run_cmd` but does nothing.                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_appveyor <pyquickhelper.pycode.unittestclass.skipif_appveyor>`                                                        |              | Skips a unit test if it runs on :epkg:`appveyor`.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_azure <pyquickhelper.pycode.unittestclass.skipif_azure>`                                                              |              | Skips a unit test if it runs on :epkg:`azure pipeline`.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_azure_linux <pyquickhelper.pycode.unittestclass.skipif_azure_linux>`                                                  |              | Skips a unit test if it runs on :epkg:`azure pipeline` on :epkg:`linux`.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_azure_macosx <pyquickhelper.pycode.unittestclass.skipif_azure_macosx>`                                                |              | Skips a unit test if it runs on :epkg:`azure pipeline` on :epkg:`linux`.                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_circleci <pyquickhelper.pycode.unittestclass.skipif_circleci>`                                                        |              | Skips a unit test if it runs on :epkg:`circleci`.                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_linux <pyquickhelper.pycode.unittestclass.skipif_linux>`                                                              |              | Skips a unit test if it runs on :epkg:`linux`.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_travis <pyquickhelper.pycode.unittestclass.skipif_travis>`                                                            |              | Skips a unit test if it runs on :epkg:`travis`.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`skipif_vless <pyquickhelper.pycode.unittestclass.skipif_vless>`                                                              |              | Skips a unit test if the version is stricly below *version* (tuple).                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`sphinx_add_scripts <pyquickhelper.helpgen.sphinx_helper.sphinx_add_scripts>`                                                 |              | copy additional scripts to a folder for sphinx documentation                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`sphinx_lang <pyquickhelper.sphinxext.sphinx_ext_helper.sphinx_lang>`                                                         |              | Returns the language defined in the configuration file.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`sphinx_rst <pyquickhelper.cli.simplified_fct.sphinx_rst>`                                                                    |              | Converts a string from *RST* to *HTML* or *RST* format.                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`split_cmp_command <pyquickhelper.loghelper.run_cmd.split_cmp_command>`                                                       |              | Splits a command line.                                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`standard_help_for_setup <pyquickhelper.pycode.setup_helper.standard_help_for_setup>`                                         |              | Standard function which generates help assuming they follow the same design as *pyquickhelper*.                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`str2datetime <pyquickhelper.loghelper.convert_helper.str2datetime>`                                                          |              | convert a string into a datetime object, it can be:                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`svg2img <pyquickhelper.imghelper.svg_helper.svg2img>`                                                                        |              | Converts an image in :epkg:`SVG` format.                                                                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`synchronize_folder <pyquickhelper.filehelper.synchelper.synchronize_folder>`                                                 |              | Synchronizes two folders (or copy if the second is empty), it only copies more recent files. It can walk through ...                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`test_notebook_execution_coverage <pyquickhelper.ipythonhelper.unittest_notebook.test_notebook_execution_coverage>`           |              | Runs and tests a specific list of notebooks. The function raises an exception if the execution fails.                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`testlog <pyquickhelper.pycode.unittestclass.testlog>`                                                                        |              | Logs before and after a function is called.                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`timestamp_to_datetime <pyquickhelper.loghelper.convert_helper.timestamp_to_datetime>`                                        |              | convert a timestamp into a datetime                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`tpl_role <pyquickhelper.sphinxext.sphinx_template_extension.tpl_role>`                                                       |              | Defines custom role *tpl*. A template must be specified in the configuration file.                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`transform_postcontents <pyquickhelper.sphinxext.sphinx_postcontents_extension.transform_postcontents>`                       |              | The function is called by event ``'doctree_resolved'``. It looks for every section in page stored in *postcontents_all_postcontents* ...                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`transform_tocdelay <pyquickhelper.sphinxext.sphinx_tocdelay_extension.transform_tocdelay>`                                   |              | The function is called by event ``'doctree_resolved'``. It looks for every section in page stored in *tocdelay_all_tocdelay* ...                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`traverse <pyquickhelper.sphinxext.sphinx_ext_helper.traverse>`                                                               |              | Enumerates through all children but insert a node whenever digging or leaving the childrens nodes.                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`try_add_config_value <pyquickhelper.sphinxext.sphinxext_helper.try_add_config_value>`                                        |              | Add a variables in the config file if it does not have it yet.                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`un7zip_files <pyquickhelper.filehelper.compression_helper.un7zip_files>`                                                     |              | Unzips files from a zip archive compress with :epkg:`7z`.                                                                                                                                          |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`ungzip_files <pyquickhelper.filehelper.compression_helper.ungzip_files>`                                                     |              | Uncompresses files from a gzip file.                                                                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`unittest_require_at_least <pyquickhelper.pycode.unittestclass.unittest_require_at_least>`                                    |              | Skips a unit test if the version of one module is not at least the provided version.                                                                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`unrar_files <pyquickhelper.filehelper.compression_helper.unrar_files>`                                                       |              | Uncompresses files from a rar archive compress with :epkg:`7z` on Window or *unrar* on linux.                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`untar_files <pyquickhelper.filehelper.compression_helper.untar_files>`                                                       |              | Uncompresses files from a tar file.                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`unzip <pyquickhelper.loghelper.flog.unzip>`                                                                                  |              | Unzips a file into the temporary folder, the function expects to have only one zipped file.                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`unzip_files <pyquickhelper.filehelper.compression_helper.unzip_files>`                                                       |              | Unzips files from a zip archive.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`update_docutils_languages <pyquickhelper.helpgen.sphinxm_convert_doc_sphinx_helper.update_docutils_languages>`               |              | Updates ``docutils/languages/en.py`` with missing labels. It Does it for languages *en*.                                                                                                           |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`update_notebook_link <pyquickhelper.helpgen.post_process.update_notebook_link>`                                              |              | A notebook can contain a link ``[anchor](find://...)`` and it will be converted into: ``:ref:...`` in rst format.                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`upgrade_notebook <pyquickhelper.ipythonhelper.notebook_helper.upgrade_notebook>`                                             |              | Converts a notebook from version 2 to latest.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`uvicorn_app <pyquickhelper.cli.uvicorn_cli.uvicorn_app>`                                                                     |              | Runs a uvicorn application. It should be used for testing not for production. Use ``host:post/redoc`` or ``host:post/docs`` ...                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`validate_file_for_help <pyquickhelper.helpgen.utils_sphinx_doc.validate_file_for_help>`                                      |              | Accepts or rejects a file to be copied in the help folder.                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`validate_urls <pyquickhelper.pycode.doc_helper.validate_urls>`                                                               |              | Checks that all urls are valid.                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`validate_urls_in_folder <pyquickhelper.pycode.doc_helper.validate_urls_in_folder>`                                           |              | Looks for all files in a folder and return all invalid urls.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`venv_install <pyquickhelper.pycode.venv_helper.venv_install>`                                                                |              | Installs a package or a list of packages in a virtual environment.                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`verification_html_file <pyquickhelper.helpgen.sphinx_main_verification.verification_html_file>`                              |              | Verifies a file produced by :epkg:`sphinx` and checks basic mistakes.                                                                                                                              |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`verification_html_format <pyquickhelper.helpgen.sphinx_main_verification.verification_html_format>`                          |              | dig into folders abd subfolders to find HTML files produced by Sphinx, does some verification to detect errors, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_autosignature_node <pyquickhelper.sphinxext.sphinx_autosignature.visit_autosignature_node>`                            |              | What to do when visiting a node :class:`autosignature_node`.                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_bigger_node <pyquickhelper.sphinxext.sphinx_bigger_extension.visit_bigger_node>`                                       |              | what to do when visiting a node *bigger* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_bigger_node_latex <pyquickhelper.sphinxext.sphinx_bigger_extension.visit_bigger_node_latex>`                           |              | what to do when visiting a node *bigger* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_bigger_node_rst <pyquickhelper.sphinxext.sphinx_bigger_extension.visit_bigger_node_rst>`                               |              | what to do when visiting a node *bigger* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_blocref_node <pyquickhelper.sphinxext.sphinx_blocref_extension.visit_blocref_node>`                                    |              | visit_blocref_node                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_blocreflist_node <pyquickhelper.sphinxext.sphinx_blocref_extension.visit_blocreflist_node>`                            |              | visit_blocreflist_node see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_blogpost_node <pyquickhelper.sphinxext.sphinx_blog_extension.visit_blogpost_node>`                                     |              | what to do when visiting a node blogpost the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_blogpostagg_node <pyquickhelper.sphinxext.sphinx_blog_extension.visit_blogpostagg_node>`                               |              | what to do when visiting a node blogpost the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_cmdref_node <pyquickhelper.sphinxext.sphinx_cmdref_extension.visit_cmdref_node>`                                       |              | visit_cmdref_node                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_cmdreflist_node <pyquickhelper.sphinxext.sphinx_cmdref_extension.visit_cmdreflist_node>`                               |              | visit_cmdreflist_node see `sphinx/writers/html.py <https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py>`_. ...                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_collapse_node <pyquickhelper.sphinxext.sphinx_collapse_extension.visit_collapse_node>`                                 |              | visit collapse_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_collapse_node_html <pyquickhelper.sphinxext.sphinx_collapse_extension.visit_collapse_node_html>`                       |              | visit collapse_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_collapse_node_rst <pyquickhelper.sphinxext.sphinx_collapse_extension.visit_collapse_node_rst>`                         |              | visit collapse_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_downloadlink_node_html <pyquickhelper.sphinxext.sphinx_downloadlink_extension.visit_downloadlink_node_html>`           |              | Converts node *downloadlink* into :epkg:`html`.                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_downloadlink_node_latex <pyquickhelper.sphinxext.sphinx_downloadlink_extension.visit_downloadlink_node_latex>`         |              | Does notthing.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_downloadlink_node_md <pyquickhelper.sphinxext.sphinx_downloadlink_extension.visit_downloadlink_node_md>`               |              | Converts node *downloadlink* into :epkg:`md`.                                                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_downloadlink_node_rst <pyquickhelper.sphinxext.sphinx_downloadlink_extension.visit_downloadlink_node_rst>`             |              | Converts node *downloadlink* into :epkg:`rst`.                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_downloadlink_node_text <pyquickhelper.sphinxext.sphinx_downloadlink_extension.visit_downloadlink_node_text>`           |              | Does notthing.                                                                                                                                                                                     |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_epkg_node <pyquickhelper.sphinxext.sphinx_epkg_extension.visit_epkg_node>`                                             |              | What to do when visiting a node *epkg*.                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_exref_node <pyquickhelper.sphinxext.sphinx_exref_extension.visit_exref_node>`                                          |              | visit_exref_node                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_exreflist_node <pyquickhelper.sphinxext.sphinx_exref_extension.visit_exreflist_node>`                                  |              | visit_exreflist_node see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_faqref_node <pyquickhelper.sphinxext.sphinx_faqref_extension.visit_faqref_node>`                                       |              | visit_faqref_node                                                                                                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_faqreflist_node <pyquickhelper.sphinxext.sphinx_faqref_extension.visit_faqreflist_node>`                               |              | visit_faqreflist_node see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                  |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gdot_node_html <pyquickhelper.sphinxext.sphinx_gdot_extension.visit_gdot_node_html>`                                   |              | visit collapse_node, the function switches between `graphviz.py <https://github.com/sphinx-doc/sphinx/blob/ master/sphinx/ext/graphviz.py>`_ ...                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gdot_node_html_svg <pyquickhelper.sphinxext.sphinx_gdot_extension.visit_gdot_node_html_svg>`                           |              | visit collapse_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gdot_node_rst <pyquickhelper.sphinxext.sphinx_gdot_extension.visit_gdot_node_rst>`                                     |              | visit collapse_node                                                                                                                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gitlog_node <pyquickhelper.sphinxext.sphinx_gitlog_extension.visit_gitlog_node>`                                       |              | what to do when visiting a node *gitlog* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gitlog_node_latex <pyquickhelper.sphinxext.sphinx_gitlog_extension.visit_gitlog_node_latex>`                           |              | what to do when visiting a node *gitlog* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_gitlog_node_rst <pyquickhelper.sphinxext.sphinx_gitlog_extension.visit_gitlog_node_rst>`                               |              | what to do when visiting a node *gitlog* the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_mathdef_node <pyquickhelper.sphinxext.sphinx_mathdef_extension.visit_mathdef_node>`                                    |              | visit_mathdef_node                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_mathdeflist_node <pyquickhelper.sphinxext.sphinx_mathdef_extension.visit_mathdeflist_node>`                            |              | visit_mathdeflist_node see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_nbref_node <pyquickhelper.sphinxext.sphinx_nbref_extension.visit_nbref_node>`                                          |              | visit_nbref_node                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_nbreflist_node <pyquickhelper.sphinxext.sphinx_nbref_extension.visit_nbreflist_node>`                                  |              | *visit_nbreflist_node*, see `sphinx/writers/html.py <https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py>`_. ...                                                               |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_postcontents_node <pyquickhelper.sphinxext.sphinx_postcontents_extension.visit_postcontents_node>`                     |              | does nothing                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_quote_node <pyquickhelper.sphinxext.sphinx_quote_extension.visit_quote_node>`                                          |              | visit_quote_node                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_quote_node_rst <pyquickhelper.sphinxext.sphinx_quote_extension.visit_quote_node_rst>`                                  |              | visit_quote_node                                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_revealjs <pyquickhelper.sphinxext.revealjs.directives.visit_revealjs>`                                                 |              | build start tag for revealjs                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_runpython_node <pyquickhelper.sphinxext.sphinx_runpython_extension.visit_runpython_node>`                              |              | What to do when visiting a node :class:`runpython_node` the function should have different behaviour, depending ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_rv_code <pyquickhelper.sphinxext.revealjs.directives.visit_rv_code>`                                                   |              | build start tag for rv_code                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_rv_note <pyquickhelper.sphinxext.revealjs.directives.visit_rv_note>`                                                   |              | build start tag for rv_note                                                                                                                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_rv_small <pyquickhelper.sphinxext.revealjs.directives.visit_rv_small>`                                                 |              | build start tag for rv_small                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_sharenet_node <pyquickhelper.sphinxext.sphinx_sharenet_extension.visit_sharenet_node>`                                 |              | what to do when visiting a node sharenet the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_sharenet_node_rst <pyquickhelper.sphinxext.sphinx_sharenet_extension.visit_sharenet_node_rst>`                         |              | what to do when visiting a node sharenet the function should have different behaviour, depending on the format, ...                                                                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_simpleimage_node <pyquickhelper.sphinxext.sphinx_image_extension.visit_simpleimage_node>`                              |              | Visits a image node. Copies the image.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_tocdelay_node <pyquickhelper.sphinxext.sphinx_tocdelay_extension.visit_tocdelay_node>`                                 |              | does nothing                                                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_todoext_node <pyquickhelper.sphinxext.sphinx_todoext_extension.visit_todoext_node>`                                    |              | visit_todoext_node                                                                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_todoextlist_node <pyquickhelper.sphinxext.sphinx_todoext_extension.visit_todoextlist_node>`                            |              | visit_todoextlist_node see https://github.com/sphinx-doc/sphinx/blob/master/sphinx/writers/html.py                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_tpl_node <pyquickhelper.sphinxext.sphinx_template_extension.visit_tpl_node>`                                           |              | What to do when visiting a node *tpl*.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_video_node <pyquickhelper.sphinxext.sphinx_video_extension.visit_video_node>`                                          |              | Visits a video node. Copies the video.                                                                                                                                                             |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`visit_youtube_node <pyquickhelper.sphinxext.sphinx_youtube_extension.visit_youtube_node>`                                    |              | Visit youtube node (html).                                                                                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`walk <pyquickhelper.filehelper.synchelper.walk>`                                                                             |              | Does the same as :epkg:`*py:os:walk` plus does not go through a sub-folder if this one is big. Folders such *build* ...                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`white_to_transparency <pyquickhelper.imghelper.img_helper.white_to_transparency>`                                            |              | Sets white color as transparency color.                                                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`write_module_scripts <pyquickhelper.pycode.setup_helper.write_module_scripts>`                                               |              | Writes a couple of scripts which allow a user to be faster on some tasks or to easily get information about the module. ...                                                                        |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`write_pyproj <pyquickhelper.pycode.setup_helper.write_pyproj>`                                                               |              | Creates a project `pyproj <https://docs.microsoft.com/fr-fr/visualstudio/python/managing-python-projects-in-visual-studio>`_ ...                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`write_version_for_setup <pyquickhelper.pycode.setup_helper.write_version_for_setup>`                                         |              | Extracts the version number, the function writes the files ``version.txt`` in this folder.                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`writes <pyquickhelper.ipythonhelper.notebook_helper.writes>`                                                                 |              | Write a notebook to a string in a given format in the current nbformat version. This function always writes the notebook ...                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`yaml_load <pyquickhelper.jenkinshelper.yaml_helper_yaml.yaml_load>`                                                          |              | Parses a :epkg:`yml` file with :epkg:`yaml`.                                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`yield_sphinx_only_markup_for_pipy <pyquickhelper.helpgen.markdown_helper.yield_sphinx_only_markup_for_pipy>`                 |              | Code from `My rst README is not formatted on pypi.python.org <http://stackoverflow.com/questions/16367770/my-rst-readme-is-not-formatted-on-pypi-python-org>`_. ...                                |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`zip7_files <pyquickhelper.filehelper.compression_helper.zip7_files>`                                                         |              | If :epkg:`7z` is installed, the function uses it to compress file into 7z format. The file *filename_7z* must not exist. ...                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`zip_files <pyquickhelper.filehelper.compression_helper.zip_files>`                                                           |              | Zips all files from an iterator.                                                                                                                                                                   |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :func:`zoom_img <pyquickhelper.imghelper.img_helper.zoom_img>`                                                                      |              | Zooms an image.                                                                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------+--------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+