Some section headers are not visible

[zerojun-wows]

I am trying to use mkdocstrings 0.24.0 with the readthedocs-theme.

But in that mkdoocstrings page some section headers are missing.

My configuration:
mkdocs.yml.txt

Page to display mkdocstrings generated content:
part-argparse.md
screenshot:

Notes section has a heading as can be seen. The Examples section has no heading.
Parameters and Returns sections also look strange.

I don't know what I could have done wrong and somehow I couldn't find anything in the documentation.

Maybe someone here knows what could help in this case?

[pawamoy]

Can you update your post to include the contents of mkdocs.yml and your Markdown files as code blocks rather than downloadable files? You can use triple backticks for code blocks:

The following is a code block:

```yaml
# contents of mkdocs.yml
```

[zerojun-wows]

Unfortunately I haven't figured it out before. So here are the files as requested.

mkdocs.yml:

site_name: zerojun's Allgemeintest Documentation
#site_url: 
copyright: © Copyright 2023 - zerojun 

nav:
  - 'Home': 'index.md'
  - 'Parts':
    - 'argparse CLI': part-argparse.md
  - 'Other things':
    - 'Old index': 'oldindex.md' 

theme: readthedocs

plugins:
- search
- mkdocstrings:
    handlers:
      python:
        options:
          docstring_style: numpy
          docstring_section_style: 'table'

part-argparse.md:

# argparse Reference

::: src.allgemeintest

allgemeinttest.py:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""Starting point of allgemeintest"""

# import standard library modules
import argparse
import sys

# import 3rd party modules
# import local modules
import seleniumtest
import sieve

# Informationen zur Autorenschaft:
__author__ = "zerojun"
__copyright__ = "Copyright 2023, zerojun"
# __credits__ unterscheidet sich von __author__ dadurch, dass
# __credits__ Leute einschließt,  die Fehlerbehebungen gemeldet, Vorschläge
# gemacht usw. haben, aber den Code nicht selbst geschrieben haben
__credits__ = ["zerojun"]
__license__ = "GPL"
__version__ = "0.3.0"
# __maintainer__ sollte die Person sein, die Fehler behebt und Verbesserungen
# vornimmt, wenn sie importiert werden.
__maintainer__ = "zerojun"
__email__ = "zerojun@gmx.net"
__status__ = "Prototype"  # "Prototype", "Development", or "Production"

# Available parts to chose from - only edit parts here
part_choices_dic = {"selenium": seleniumtest.main, "sieve": sieve.main}


def cli_parse_args(args=None) -> argparse.Namespace:
    """Parse command-line interface arguments and return them as a Namespace
    object.

    Parameters
    ----------
    args : list, optional
        A list of command-line arguments. If not provided, sys.argv[1:] is
        used.

    Returns
    -------
    argparse.Namespace
        An object containing the parsed command-line arguments.

    Notes
    -----
    This function relies on the `create_parser` function to set up the argument
    parser.
    For more information on how to build and test a command-line interface,
    refer to:
    https://dev.to/bowmanjd/build-and-test-a-command-line-interface-with-poetry-python-s-argparse-and-pytest-4gab

    Examples
    --------
    >>> parsed_args = cli_parse_args(["-v"])
    >>> # `parsed_args` now contains the parsed command-line arguments.

    >>> parsed_args = cli_parse_args(["-p", "some_part"])
    >>> # `parsed_args` now contains the parsed command-line arguments,
    including the selected part.
    """
    if not args:
        args = sys.argv[1:]

    parser = create_parser()
    return parser.parse_args(args)


def create_parser() -> argparse.ArgumentParser:
    """Create and return a command-line argument parser for the Allgemeintest
    program.

    Returns
    -------
    argparse.ArgumentParser
        An instance of the ArgumentParser class configured for the
        Allgemeintest program.

    Notes
    -----
    This function sets up a command-line argument parser with options for
    version information and selecting a specific part for execution.

    Examples
    --------
    >>> parser = create_parser()
    >>> args = parser.parse_args(["-v"])
    >>> # The parser now contains the version information.

    >>> args = parser.parse_args(["-p", "some_part"])
    >>> # The parser now contains the selected part information.
    """
    parser = argparse.ArgumentParser(
        prog="Allgemeintest",
        description="Commandline plattform for script and funtionality tests",
        epilog="Allgemeintest (v "
        + __version__
        + ") "
        + __copyright__
        + " - "
        + __license__
        + " - Status: "
        + __status__,
    )
    parser.add_argument(
        "-v",
        "--version",
        action="version",
        help="shows current version",
        version=parser.prog + " v" + __version__,
    )
    parser.add_argument(
        "-p",
        "--partname",
        choices=part_choices_dic,
        action="store",
        help="select the part to execute",
    )
    return parser


def switch_to_part_by_name(part_name: str) -> None:
    """Switch to a specified part by its name or take appropriate action.

    Parameters
    ----------
    part_name : str
        The name of the part to switch to.

    Returns
    -------
    None

    Notes
    -----
    This function assumes the existence of a dictionary, `part_choices_dic`,
    where keys represent part names, and values are functions corresponding to
    each part. If the specified `part_name` is found in the dictionary, the
    associated function is invoked. If the part is not found, the function does
    not raise an error but rather takes appropriate action within the context
    of the application.

    Examples
    --------
    >>> switch_to_part_by_name("some_part")
    >>> # Switches to the part named "some_part" if it exists in
    part_choices_dic.

    >>> switch_to_part_by_name("unknown_part")
    >>> # Takes appropriate action if "unknown_part" is not found in
    part_choices_dic.
    """
    part_choices_dic[part_name]()


def main() -> None:
    """Main entry point for the program.

    Parses command-line arguments using the `cli_parse_args` function and
    performs actions based on the parsed arguments. If no specific part is
    specified, the help information for the program is printed using the
    `create_parser` function. Otherwise, the program switches to the specified
    part using the `switch_to_part_by_name` function.

    Notes
    -----
    This function assumes the existence of the `cli_parse_args`,
    `create_parser`, and `switch_to_part_by_name` functions.

    Examples
    --------
    >>> `main()`
    >>> # Parses command-line arguments and takes appropriate actions based on
    the provided arguments.
    """
    args = cli_parse_args()

    if args.partname is None:
        create_parser().print_help()
    else:
        switch_to_part_by_name(args.partname)


if __name__ == "__main__":
    main()

[pawamoy]

Thanks, investigating now.

[pawamoy]

Converted to issue and fixed: #115