docs: def _build_parser(
          cls,
          dictionary,
          parser,
          section_name,
          delimiter=DEFAULT_DELIMITER,
          empty_sections=False,
      ):
          """ Populates a parser instance with the content of a dictionary.
  
          :param dict dictionary: The dictionary to use for populating the parser instance
          :param configparser.ConfigParser parser: The parser instance
          :param str section_name: The current section name to add the dictionary keys to
          :param str delimiter: The nested dictionary delimiter character,
              defaults to ":", optional
          :param bool empty_sections: Flag to allow the representation of empty sections
              to exist, defaults to False, optional
          :return: The populated parser
          :rtype: configparser.ConfigParser
          """
  
          for (key, value) in dictionary.items():
              if isinstance(value, dict):
                  nested_section = delimiter.join([section_name, key])
                  is_empty = all(isinstance(_, dict) for _ in value.values())
                  if not is_empty or empty_sections:
                      parser.add_section(nested_section)
                  cls._build_parser(value, parser, nested_section, delimiter=delimiter)
              elif isinstance(value, (list, tuple, set, frozenset)):
                  if any(isinstance(_, dict) for _ in value):
                      raise ValueError(
                          f"INI files cannot support arrays with mappings, "
                          f"found in key {key!r}"
                      )
                  parser.set(
                      section_name, key, "\n".join(cls._encode_var(_) for _ in value)
                  )
              else:
                  parser.set(section_name, key, cls._encode_var(value))
          return parser