          self.post_process.do_actions(faces)
  
          faces_count = len(faces["detected_faces"])
          if faces_count == 0:
              logger.verbose("No faces were detected in image: %s", os.path.basename(filename))
  
          if not self.verify_output and faces_count > 1:
              self.verify_output = True
  
      def align_face(self, faces, size, filename):
 
</s> remove         if not self.verify_output and faces_count > 1:
            self.verify_output = True
 </s> add         if not self._verify_output and faces_count > 1:
            self._verify_output = True </s> remove     def output_processing(self, faces, size, filename):
        """ Prepare faces for output """
        self.align_face(faces, size, filename)
        self.post_process.do_actions(faces)
 </s> add     def _output_processing(self, faces, size):
        """ Prepare faces for output

        Loads the aligned face, perform any processing actions and verify the output.

        Parameters:
        faces: dict
            Dictionary output from :class:`plugins.extract.Pipeline.Extractor`
        size: int
            The size that the aligned face should be created at
        """
        for face in faces["detected_faces"]:
            face.load_aligned(faces["image"], size=size)

        self._post_process.do_actions(faces) </s> remove     def align_face(self, faces, size, filename):
        """ Align the detected face and add the destination file path """
        final_faces = list()
        image = faces["image"]
        detected_faces = faces["detected_faces"]
        for face in detected_faces:
            face.load_aligned(image, size=size)
            final_faces.append({"file_location": self.output_dir / Path(filename).stem,
                                "face": face})
        faces["detected_faces"] = final_faces

    def output_faces(self, filename, faces):
        """ Output faces to save thread """
 </s> add     def _output_faces(self, saver, faces):
        """ Output faces to save thread

        Set the face filename based on the frame name and put the face to the
        :class:`lib.image.ImagesSaver` save queue and add the face information to the alignments
        data.

        Parameters
        ----------
        saver: lib.images.ImagesSaver
            The background saver for saving the image
        faces: dict
            The output dictionary from :class:`plugins.extract.Pipeline.Extractor`
        """
        logger.debug("Save Faces: Start") </s> remove     def check_thread_error(self):
        """ Check and raise thread errors """
        for thread in self.threads:
 </s> add     def _check_thread_error(self):
        """ Check if any errors have occurred in the running threads and their errors """
        for thread in self._threads: </s> remove                 if self.extractor.final_pass:
                    self.output_processing(faces, size, filename)
                    self.output_faces(filename, faces)
                    if self.save_interval and (idx + 1) % self.save_interval == 0:
                        self.alignments.save()
 </s> add                 if self._extractor.final_pass:
                    self._output_processing(faces, size)
                    self._output_faces(saver, faces)
                    if self._save_interval and (idx + 1) % self._save_interval == 0:
                        self._alignments.save()
            logger.verbose("No faces were detected in image: %s",
                           os.path.basename(faces["filename"]))
          self.post_process.do_actions(faces)
  
          faces_count = len(faces["detected_faces"])
          if faces_count == 0:
            logger.verbose("No faces were detected in image: %s",
                           os.path.basename(faces["filename"]))
  
          if not self.verify_output and faces_count > 1:
              self.verify_output = True
  
      def align_face(self, faces, size, filename):
keep keep keep keep replace keep keep keep keep keep
 scripts.extract - code optimizations

Limit queue sizes to reduce RAM usage
Rename lib.image.BackgroundIO to ImageIO
Create separate ImagesLoader and ImagesSaver classes
Load/Save images from centralized lib.image.ImageIO
scripts.extract documentation 
scripts/extract.py