      arguments: :class:`argparse.Namespace`
          The arguments to be passed to the extraction process as generated from Faceswap's command
          line arguments
      """
      def __init__(self, arguments: argparse.Namespace) -> None:
          logger.debug("Initializing %s: (args: %s", self.__class__.__name__, arguments)
          self._args = arguments
          self._output_dir = None if self._args.skip_saving_faces else get_folder(
              self._args.output_dir)
  
 
</s> remove         self._output_dir = None if self._args.skip_saving_faces else get_folder(
            self._args.output_dir)

        logger.info("Output Directory: %s", self._args.output_dir)
        self._images = ImagesLoader(self._args.input_dir, fast_count=True)
        self._alignments = Alignments(self._args, True, self._images.is_video)

        self._existing_count = 0
        self._set_skip_list()
 </s> add         self._input_locations = self._get_input_locations()
        self._validate_batchmode() </s> remove     def __init__(self, detector, aligner, masker, configfile=None, multiprocess=False,
                 exclude_gpus=None, rotate_images=None, min_size=20, normalize_method=None,
                 re_feed=0, image_is_aligned=False):
 </s> add     def __init__(self,
                 detector: str,
                 aligner: str,
                 masker: Union[str, List[str]],
                 configfile: Optional[str] = None,
                 multiprocess: bool = False,
                 exclude_gpus: Optional[List[int]] = None,
                 rotate_images: Optional[List[int]] = None,
                 min_size: int = 20,
                 normalize_method: Optional[str] = None,
                 re_feed: int = 0,
                 image_is_aligned: bool = False) -> None: </s> remove     def _load_align(self, aligner, configfile, normalize_method, re_feed):
 </s> add     def _load_align(self,
                    aligner: str,
                    configfile: Optional[str],
                    normalize_method: Optional[str],
                    re_feed: int) -> Optional["Aligner"]: </s> remove         detector = PluginLoader.get_detector(detector_name)(exclude_gpus=self._exclude_gpus,
                                                            rotation=rotation,
                                                            min_size=min_size,
                                                            configfile=configfile,
                                                            instance=self._instance)
        return detector

    def _load_mask(self, masker, image_is_aligned, configfile):
 </s> add         plugin = PluginLoader.get_detector(detector_name)(exclude_gpus=self._exclude_gpus,
                                                          rotation=rotation,
                                                          min_size=min_size,
                                                          configfile=configfile,
                                                          instance=self._instance)
        return plugin

    def _load_mask(self,
                   masker: str,
                   image_is_aligned: bool,
                   configfile: Optional[str]) -> Optional["Masker"]: </s> remove         aligner = PluginLoader.get_aligner(aligner_name)(exclude_gpus=self._exclude_gpus,
                                                         configfile=configfile,
                                                         normalize_method=normalize_method,
                                                         re_feed=re_feed,
                                                         instance=self._instance)
        return aligner

    def _load_detect(self, detector, rotation, min_size, configfile):
 </s> add         plugin = PluginLoader.get_aligner(aligner_name)(exclude_gpus=self._exclude_gpus,
                                                        configfile=configfile,
                                                        normalize_method=normalize_method,
                                                        re_feed=re_feed,
                                                        instance=self._instance)
        return plugin

    def _load_detect(self,
                     detector: str,
                     rotation: Optional[List[int]],
                     min_size: int,
                     configfile: Optional[str]) -> Optional["Detector"]:
    def __init__(self, arguments: Namespace) -> None:
      arguments: :class:`argparse.Namespace`
          The arguments to be passed to the extraction process as generated from Faceswap's command
          line arguments
      """
    def __init__(self, arguments: Namespace) -> None:
          logger.debug("Initializing %s: (args: %s", self.__class__.__name__, arguments)
          self._args = arguments
          self._output_dir = None if self._args.skip_saving_faces else get_folder(
              self._args.output_dir)
  
keep keep keep keep replace keep keep keep keep keep
 extract: Add batch processing mode 
scripts/extract.py