docs: def inflate_analysis_group(self, identifier, definition):
          """
          Inflate a whole analysis group.
  
          An analysis group is a section defined in the YAML file.
  
          Args:
              identifier (str): the group identifier.
              definition (list/dict): the group definition.
  
          Returns:
              AnalysisGroup: an instance of AnalysisGroup.
  
          Raises:
              ValueError: when identifier targets a plugin of a certain type,
                  and the definition does not contain the entry for the
                  other-type plugins (providers <-> checkers).
          """
          providers_definition = definition.pop('providers', None)
          checkers_definition = definition.pop('checkers', None)
  
          analysis_group = AnalysisGroup()
  
          try:
  
              first_plugin = self.inflate_plugin(identifier, definition)
  
              if isinstance(first_plugin, Checker):
                  analysis_group.checkers.append(first_plugin)
  
                  if providers_definition is None:
                      raise ValueError(
                          'when declaring an analysis group with a checker '
                          'identifier, you must also declare providers with '
                          'the "providers" key.')
  
                  analysis_group.providers.extend(
                      self.inflate_providers(providers_definition))
  
              elif isinstance(first_plugin, Provider):
                  analysis_group.providers.append(first_plugin)
  
                  if checkers_definition is None:
                      raise ValueError(
                          'when declaring an analysis group with a provider '
                          'identifier, you must also declare checkers with '
                          'the "checkers" key.')
  
                  analysis_group.checkers.extend(
                      self.inflate_checkers(checkers_definition))
  
          except PluginNotFoundError as e:
  
              logger.warning(
                  'Could not find any plugin identified by %s, '
                  'considering entry as group name. Exception: %s.',
                  identifier, e)
  
              analysis_group.name = definition.pop('name', identifier)
              analysis_group.description = definition.pop('description', None)
  
              if bool(providers_definition) != bool(checkers_definition):
                  raise ValueError(
                      'when declaring an analysis group with a name, you must '
                      'either declare both "providers" and "checkers" or none.')
  
              if providers_definition and checkers_definition:
                  analysis_group.providers.extend(
                      self.inflate_providers(providers_definition))
                  analysis_group.checkers.extend(
                      self.inflate_checkers(checkers_definition))
  
          self.cleanup_definition(definition)
  
          for nd_identifier, nd_definition in definition.items():
              analysis_group.checkers.append(
                  self.inflate_nd_checker(nd_identifier, nd_definition))
  
          return analysis_group