                       "normalize_method: %s)", self.__class__.__name__, detector, aligner,
                       loglevel, configfile, multiprocess, rotate_images, min_size,
                       normalize_method)
          self.phase = "detect"
          self.detector = self.load_detector(detector, loglevel, rotate_images, min_size, configfile)
          self.aligner = self.load_aligner(aligner, loglevel, configfile, normalize_method)
          self.is_parallel = self.set_parallel_processing(multiprocess)
          self.processes = list()
          self.queues = self.add_queues()
          logger.debug("Initialized %s", self.__class__.__name__)
  
      @property
      def input_queue(self):
          """ Return the correct input queue depending on the current phase """
 
</s> remove                      loglevel, configfile, multiprocess, rotate_images, min_size,
                     normalize_method)
 </s> add                      configfile, multiprocess, rotate_images, min_size, normalize_method) </s> remove         logger.debug("Initializing %s: (detector: %s, aligner: %s, loglevel: %s, configfile: %s, "
 </s> add         logger.debug("Initializing %s: (detector: %s, aligner: %s, configfile: %s, " </s> remove         """ Return the correct input queue depending on the current phase """
        if self.is_parallel or self.phase == "detect":
 </s> add         """ queue: Return the correct input queue depending on the current phase

        The input queue is the entry point into the extraction pipeline. A ``dict`` should
        be put to the queue in the following format(s):

        For detect/single phase operations:

        >>> {'filename': <path to the source image that is to be extracted from>,
        >>>  'image': <the source image as a numpy.array in BGR color format>}

        For align (2nd pass operations):

        >>> {'filename': <path to the source image that is to be extracted from>,
        >>>  'image': <the source image as a numpy.array in BGR color format>,
        >>>  'detected_faces: [<list of DetectedFace objects as generated from detect>]}

        """
        if self._is_parallel or self.phase == "detect": </s> remove         retval = self.queues[qname]
        logger.trace("%s: %s", qname, retval)
        return retval

    @property
    def output_queue(self):
        """ Return the correct output queue depending on the current phase """
        qname = "extract_align_out" if self.final_pass else "extract_align_in"
        retval = self.queues[qname]
 </s> add         retval = self._queues[qname] </s> remove     @staticmethod
    def load_detector(detector, loglevel, rotation, min_size, configfile):
        """ Set global arguments and load detector plugin """
        detector_name = detector.replace("-", "_").lower()
        logger.debug("Loading Detector: '%s'", detector_name)
        detector = PluginLoader.get_detector(detector_name)(loglevel=loglevel,
                                                            rotation=rotation,
                                                            min_size=min_size,
                                                            configfile=configfile)
        return detector
 </s> add     def set_batchsize(self, plugin_type, batchsize):
        """ Set the batchsize of a given :attr:`plugin_type` to the given :attr:`batchsize`.
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
                       "normalize_method: %s)", self.__class__.__name__, detector, aligner,
                       loglevel, configfile, multiprocess, rotate_images, min_size,
                       normalize_method)
          self.phase = "detect"
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
        self._queue_size = 32
        self._vram_buffer = 320  # Leave a buffer for VRAM allocation
        self._detector = self._load_detector(detector, rotate_images, min_size, configfile)
        self._aligner = self._load_aligner(aligner, configfile, normalize_method)
        self._is_parallel = self._set_parallel_processing(multiprocess)
        self._queues = self._add_queues()
          logger.debug("Initialized %s", self.__class__.__name__)
  
      @property
      def input_queue(self):
          """ Return the correct input queue depending on the current phase """
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 De-Multiprocess Extract (#871)

* requirements.txt: - Pin opencv to 4.1.1 (fixes cv2-dnn error)

* lib.face_detect.DetectedFace: change LandmarksXY to landmarks_xy. Add left, right, top, bottom attributes

* lib.model.session: Session manager for loading models into different graphs (for Nvidia + CPU)

* plugins.extract._base: New parent class for all extract plugins

* plugins.extract.pipeline. Remove MultiProcessing. Dynamically limit batchsize for Nvidia cards. Remove loglevel input

* S3FD + FAN plugins. Standardise to Keras version for all backends

* Standardize all extract plugins to new threaded codebase

* Documentation. Start implementing Numpy style docstrings for Sphinx Documentation

* Remove s3fd_amd. Change convert OTF to expect DetectedFace object

* faces_detect - clean up and documentation

* Remove PoolProcess

* Migrate manual tool to new extract workflow

* Remove AMD specific extractor code from cli and plugins

* Sort tool to new extract workflow

* Remove multiprocessing from project

* Remove multiprocessing queues from QueueManager

* Remove multiprocessing support from logger

* Move face_filter to new extraction pipeline

* Alignments landmarksXY > landmarks_xy and legacy handling

* Intercept get_backend for sphinx doc build

# Add Sphinx documentation 
plugins/extract/pipeline.py