              logger.debug("No detector selected. Returning None")
              return None
          detector_name = detector.replace("-", "_").lower()
          logger.debug("Loading Detector: '%s'", detector_name)
          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):
          """ Set global arguments and load masker plugin """
          if masker is None or masker.lower() == "none":
              logger.debug("No masker selected. Returning None")
              return None
          masker_name = masker.replace("-", "_").lower()
 
</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"]: </s> remove         masker = PluginLoader.get_masker(masker_name)(exclude_gpus=self._exclude_gpus,
 </s> add         plugin = PluginLoader.get_masker(masker_name)(exclude_gpus=self._exclude_gpus, </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         return masker
 </s> add         return plugin </s> remove     def _launch_plugin(self, phase):
 </s> add     def _launch_plugin(self, phase: str) -> None:
        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"]:
              logger.debug("No detector selected. Returning None")
              return None
          detector_name = detector.replace("-", "_").lower()
          logger.debug("Loading Detector: '%s'", detector_name)
        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"]:
        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"]:
        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"]:
        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"]:
        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"]:
        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"]:
        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"]:
        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"]:
          """ Set global arguments and load masker plugin """
          if masker is None or masker.lower() == "none":
              logger.debug("No masker selected. Returning None")
              return None
          masker_name = masker.replace("-", "_").lower()
keep keep keep keep replace replace replace replace replace replace replace replace keep keep keep keep keep
 extract: Add batch processing mode 
plugins/extract/pipeline.py