code: def load_extensions(self, group, name_filter=None, comp_filter=None, class_filter=None, product_name=None, unique=False):
          found_extensions = []
          if product_name is not None:
              for comp in self.iter_components():
                  if comp_filter is not None and comp.name != comp_filter:
                      continue
                  products = comp.find_products(product_name)
                  for product in products:
                      try:
                          entries = self.load_extension(product, name_filter=name_filter, class_filter=class_filter,
                                                        component=comp)
                          if len(entries) == 0 and name_filter is None:
                              self._logger.warn("Found no valid extensions in product %s of component %s",
                                                product, comp.path)
                              continue
                          found_extensions.extend(entries)
                      except:
                          self._logger.exception("Unable to load extension %s from local component %s at path %s",
                                                 product_name, comp, product)
          for entry in self._iter_entrypoint_group(group):
              name = entry.name
              if name_filter is not None and name != name_filter:
                  continue
              try:
                  ext = entry.load()
              except:
                  self._logger.warn("Unable to load %s from %s", entry.name, entry.distro, exc_info=True)
                  continue
              found_extensions.extend((name, x) for x in self._filter_subclasses(ext, class_filter))
          for (name, ext) in self._registered_extensions.get(group, []):
              if name_filter is not None and name != name_filter:
                  continue
              found_extensions.extend((name, x) for x in self._filter_subclasses(ext, class_filter))
          found_extensions = [(name, x) for name, x in found_extensions if self._filter_nonextensions(x)]
          if unique is True:
              if len(found_extensions) > 1:
                  raise ArgumentError("Extension %s should have had exactly one instance of class %s, found %d" % (group, class_filter.__name__, len(found_extensions)), classes=found_extensions)
              elif len(found_extensions) == 0:
                  raise ArgumentError("Extension %s had no instances of class %s" % (group, class_filter.__name__))
              return found_extensions[0]
          return found_extensions