rendering.template_functions.autodoc

Protocol for objects with DocElement-like interface for autodoc.

Normalized parameter view for templates.

Provides consistent access to parameter data for Python functions, CLI commands, and other elements with parameters.

Normalized Python member view for templates.

Provides consistent access to method/function data regardless of how it's stored in the DocElement.

Normalized CLI option/argument view for templates.

Provides consistent access to CLI option data.

Normalized CLI command view for templates.

Provides consistent access to CLI command data.

Normalize Python element members for templates.

Returns a list of MemberView objects for methods, functions, and properties.

Usage: {% for m in element | members %} {{ m.name }} {% if m.is_async %}async{% end %} {% end %}

Normalize CLI element commands for templates.

Returns a list of CommandView objects for commands and command groups.

Usage: {% for cmd in element | commands %} {{ cmd.name }} {{ cmd.option_count }} options {% end %}

Normalize CLI element options for templates.

Returns a list of OptionView objects for options and arguments.

Usage: {% for opt in element | options %} {{ opt.flags_str }} {{ opt.description }} {% if opt.required %}required{% end %} {% end %}

Convert a single DocElement to a MemberView.

Use this when iterating over a pre-filtered list of DocElements and you want normalized access to each member's properties.

Usage: {% for el in members %} {% let m = el | member_view %} {{ m.name }} {% if m.is_async %}async{% end %} {% end %}

Convert a single DocElement to an OptionView.

Use this when iterating over a pre-filtered list of DocElements and you want normalized access to each option's properties.

Usage: {% for el in options %} {% let opt = el | option_view %} {{ opt.flags_str }} {% end %}

Convert a single DocElement to a CommandView.

Use this when iterating over a pre-filtered list of DocElements and you want normalized access to each command's properties.

Usage: {% for el in commands %} {% let cmd = el | command_view %} {{ cmd.name }} {% end %}

Check if a page is autodoc-generated (template helper).

This is a template-friendly wrapper around bengal.utils.autodoc.is_autodoc_page that can be used in Jinja templates.

Get normalized parameters for any DocElement with parameters.

Returns a list of dicts with consistent keys:

• name: Parameter name
• type: Type annotation (or None)
• default: Default value (or None)
• required: Whether required
• description: Description text

Usage in templates: {% for param in element | get_params %} {{ param.name }}: {{ param.type }} {% endfor %}

Get count of parameters for an element.

Usage in templates: {{ element | param_count }} parameters

Get return type string for an element.

Usage in templates: Returns: {{ element | return_type }}

Get normalized return info for an element.

Returns a dict with:

• type: Return type string (or None)
• description: Return description (or None)

Usage in templates: {% set ret = element | get_return_info %} {% if ret.type and ret.type != 'None' %} Returns: {{ ret.type }} {% if ret.description %} — {{ ret.description }}{% endif %} {% endif %}

Extract display stats from a DocElement based on its children types.

Counts children by element_type and returns a list of stats suitable for rendering in templates.

Usage in templates: {% set stats = element | get_element_stats %} {% if stats %}

Filter children by element_type.

This replaces verbose Jinja filter chains like: {% set methods = children | selectattr('element_type', 'eq', 'method') | list %}

With a simple function call: {% set methods = children_by_type(children, 'method') %}

Note: This function is portable across template engines because it's pure Python and can be injected as a context global in any renderer.

Filter to members not starting with underscore.

This replaces verbose Jinja filter chains like: {% set public = members | rejectattr('name', 'startswith', '_') | list %}

With a simple function call: {% set public = public_only(members) %}

Note: This function is portable across template engines because it's pure Python and can be injected as a context global in any renderer.

Filter to members starting with underscore (internal).

This replaces verbose Jinja filter chains like: {% set private = members | selectattr('name', 'startswith', '_') | list %}

With a simple function call: {% set private = private_only(members) %}

Note: This function is portable across template engines because it's pure Python and can be injected as a context global in any renderer.