docs: def applyconfiguration(
              self, conf=None, paths=None, drivers=None, logger=None,
              targets=None, scope=None, safe=None, besteffort=None,
              callconf=False, keepstate=None, modules=None
      ):
          """Apply conf on a destination in those phases:
  
          1. identify the right driver to use with paths to parse.
          2. for all paths, get conf which matches input conf.
          3. apply parsing rules on path parameters.
          4. fill input conf with resolved parameters.
          5. apply filled conf on targets.
  
          :param conf: conf from where get conf.
          :type conf: Configuration, Category or Parameter
          :param paths: conf files to parse. If paths is a str, it is
              automatically putted into a list.
          :type paths: list of str
          :param Iterable targets: objects to configure. this targets by default.
          :param dict scope: local variables to use for expression resolution.
          :param bool callconf: if True (False by default), the configuration is
              used in the callable target parameters while calling it.
          :param bool keepstate: if True (default), do not instanciate sub objects
              if they already exist.
          :param list modules: modules to load before configure this configurable.
          :return: configured targets.
          :rtype: list
          """
  
          result = []
  
          self.loadmodules(modules=modules)
          modules = []
  
          if scope is None:
              scope = self.scope
  
          if safe is None:
              safe = self.safe
  
          if besteffort is None:
              besteffort = self.besteffort
  
          if targets is None:
              targets = self.targets
  
          if logger is None:
              logger = self.logger
  
          if keepstate is None:
              keepstate = self.keepstate
  
          # get conf from drivers and paths
          conf = self.getconf(
              conf=conf, paths=paths, logger=logger, drivers=drivers,
              modules=modules
          )
          if conf is not None:
              # resolve all values
              conf.resolve(
                  configurable=self, scope=scope, safe=safe, besteffort=besteffort
              )
              # configure resolved configuration
              configured = self.configure(
                  conf=conf, targets=targets, callconf=callconf,
                  keepstate=keepstate, modules=modules
              )
  
              result += configured
  
          return result