                  self._threaded_redirector("reload", (detected_faces, ))
          if saver is not None:
              saver.close()
  
      def _check_thread_error(self) -> None:
          """ Check if any errors have occurred in the running threads and their errors """
          for thread in self._threads:
              thread.check_and_raise_error()
  
      def _output_processing(self, extract_media: ExtractMedia, size: int) -> None:
          """ Prepare faces for output
  
          Loads the aligned face, generate the thumbnail, perform any processing actions and verify
          the output.
 
</s> remove                 self._threaded_redirector("reload", (detected_faces, ))
 </s> add                 self._loader.reload(detected_faces) </s> remove         self._run_extraction()
 </s> add     def reload(self, detected_faces: Dict[str, ExtractMedia]) -> None:
        """ Reload images for multiple pipeline passes """
        self._threaded_redirector("reload", (detected_faces, ))

    def check_thread_error(self) -> None:
        """ Check if any errors have occurred in the running threads and raise their errors """
        for thread in self._threads:
            thread.check_and_raise_error()

    def join(self) -> None:
        """ Join all open loader threads """ </s> remove         Should only be called from  :class:`lib.cli.launcher.ScriptExecutor`
 </s> add         if len(item.detected_faces) > 1 and is_filter:
            logger.warning("%s faces detected for filter in '%s'. These identies will not be used",
                           len(item.detected_faces), os.path.basename(item.filename))
            filelist.pop(idx)
            embeddings.pop(idx)
            return

        if len(item.detected_faces) > 1 and not is_filter:
            logger.warning("%s faces detected for nfilter in '%s'. All of these identies will be "
                           "used", len(item.detected_faces), os.path.basename(item.filename))
            embeddings[idx] = identities
            return

    def _identity_from_extractor(self, file_list: List[str], aligned: List[str]) -> None:
        """ Obtain the identity embeddings from the extraction pipeline

        Parameters
        ----------
        filesile_list: list
            List of full path to images to run through the extraction pipeline
        aligned: list
            List of full path to images that exist in attr:`filelist` that are faceswap aligned
            images </s> remove     def set_aligner_normalization_method(self, method: Optional[Literal["none",
                                                                        "clahe",
                                                                        "hist",
                                                                        "mean"]]) -> None:
        """ Change the normalization method for faces fed into the aligner.

        Parameters
        ----------
        method: {"none", "clahe", "hist", "mean"}
            The normalization method to apply to faces prior to feeding into the aligner's model
        """
        assert self._align is not None
        logger.debug("Setting to: '%s'", method)
        self._align.set_normalize_method(method)

 </s> add  </s> remove         # Face Filter post processing
        if ((hasattr(self._args, "filter") and self._args.filter is not None) or
                (hasattr(self._args, "nfilter") and
                 self._args.nfilter is not None)):

            if hasattr(self._args, "detector"):
                detector = self._args.detector.replace("-", "_").lower()
            else:
                detector = "cv2_dnn"
            if hasattr(self._args, "aligner"):
                aligner = self._args.aligner.replace("-", "_").lower()
            else:
                aligner = "cv2_dnn"

            face_filter = dict(detector=detector,
                               aligner=aligner,
                               multiprocess=not self._args.singleprocess)
            filter_lists = {}
            if hasattr(self._args, "ref_threshold"):
                face_filter["ref_threshold"] = self._args.ref_threshold
            for filter_type in ('filter', 'nfilter'):
                filter_args = getattr(self._args, filter_type, None)
                filter_args = None if not filter_args else filter_args
                filter_lists[filter_type] = filter_args
            face_filter["filter_lists"] = filter_lists
            postprocess_items["FaceFilter"] = {"kwargs": face_filter}

 </s> add 
                  self._threaded_redirector("reload", (detected_faces, ))
          if saver is not None:
              saver.close()
  





      def _output_processing(self, extract_media: ExtractMedia, size: int) -> None:
          """ Prepare faces for output
  
          Loads the aligned face, generate the thumbnail, perform any processing actions and verify
          the output.
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 Update Face Filter
  - Remove old face filter
  - plugins.extract.pipeline: Expose plugins directly
  - Change `is_aligned` from plugin level to ExtractMedia level
  - Allow extract pipeline to take faceswap aligned images
  - Add ability for recognition plugins to accept aligned faces as input
  - Add face filter to recognition plugin
  - Move extractor pipeline IO ops to own class 
scripts/extract.py