                                        "align faces with difficult lighting conditions at an "
                                        "extraction speed cost. Different methods will yield "
                                        "different results on different sets. NB: This does not "
                                        "impact the output face, just the input to the aligner."
                                        "\nL|'none': Don't perform normalization on the face."
                                        "\nL|'clahe': Perform Contrast Limited Adaptive Histogram "
                                        "Equalization on the face."
                                        "\nL|'hist': Equalize the histograms on the RGB channels."
                                        "\nL|'mean': Normalize the face colors to the mean."})
          argument_list.append({"opts": ("-r", "--rotate-images"),
                                "type": str,
 
</s> remove                                       "\nL|'hist': Equalize the histograms on the RGB channels."
                                      "\nL|'mean': Normalize the face colors to the mean."})
 </s> add                                       "\nL|hist: Equalize the histograms on the RGB channels."
                                      "\nL|mean: Normalize the face colors to the mean."}) </s> remove     """ Creates a detect/align pipeline and returns results from a generator

        Input queue is dynamically set depending on the current phase of extraction
        and can be accessed from:
            Extractor.input_queue
 </s> add     """ Creates a :mod:`~plugins.extract.detect`/:mod:`~plugins.extract.align` pipeline and yields
    results frame by frame from the :attr:`detected_faces` generator

    :attr:`input_queue` is dynamically set depending on the current :attr:`phase` of extraction

    Parameters
    ----------
    detector: str
        The name of a detector plugin as exists in :mod:`plugins.extract.detect`
    aligner: str
        The name of an aligner plugin as exists in :mod:`plugins.extract.align`
    configfile: str, optional
        The path to a custom ``extract.ini`` configfile. If ``None`` then the system
        :file:`config/extract.ini` file will be used.
    multiprocess: bool, optional
        Whether to attempt processing the plugins in parallel. This may get overridden
        internally depending on the plugin combination. Default: ``False``
    rotate_images: str, optional
        Used to set the :attr:`~plugins.extract.detect.rotation` attribute. Pass in a single number
        to use increments of that size up to 360, or pass in a ``list`` of ``ints`` to enumerate
        exactly what angles to check. Can also pass in ``'on'`` to increment at 90 degree
        intervals. Default: ``None``
    min_size: int, optional
        Used to set the :attr:`~plugins.extract.detect.min_size` attribute Filters out faces
        detected below this size. Length, in pixels across the diagonal of the bounding box. Set
        to ``0`` for off. Default: ``0``
    normalize_method: {`None`, 'clahe', 'hist', 'mean'}, optional
        Used to set the :attr:`~plugins.extract.align.normalize_method` attribute. Normalize the
        images fed to the aligner.Default: ``None``

    Attributes
    ----------
    phase: str
        The current phase that the pipeline is running. Used in conjunction with :attr:`passes` and
        :attr:`final_pass` to indicate to the caller which phase is being processed </s> remove                     "\nL|'cv2-dnn': A CPU only extractor, is the least reliable, but uses least "
 </s> add                     "\nL|cv2-dnn: A CPU only extractor, is the least reliable, but uses least " </s> remove         """ No need to load aligned information for all uses of this
            class, so only call this to load the information for easy
            reference to aligned properties for this face """
        # Don't reload an already aligned face:
 </s> add         """ Align a face from a given image.

        Aligning a face is a relatively expensive task and is not required for all uses of
        the :class:`~lib.faces_detect.DetectedFace` object, so call this function explicitly to
        load an aligned face.

        This method plugs into :mod:`lib.aligner` to perform face alignment based on this face's
        ``landmarks_xy``. If the face has already been aligned, then this function will return
        having performed no action.

        Parameters
        ----------
        image: numpy.ndarray
            The image that contains the face to be aligned
        size: int
            The size of the output face in pixels
        align_eyes: bool, optional
            Optionally perform additional alignment to align eyes. Default: `False`
        dtype: str, optional
            Optionally set a ``dtype`` for the final face to be formatted in. Default: ``None``

        Notes
        -----
        This method must be executed to get access to the following `properties`:
            - :func:`original_roi`
            - :func:`aligned_landmarks`
            - :func:`aligned_face`
            - :func:`adjusted_interpolators`
        """ </s> remove                     "\nL|'mtcnn': Fast on GPU, slow on CPU. Uses fewer resources than other GPU "
                    "detectors but can often return more false positives. NB: Runs on CPU for AMD "
                    "cards."
                    "\nL|'" + s3fd + "': Fast on GPU, slow on CPU. Can detect more faces and "
 </s> add                     "\nL|mtcnn: Fast on GPU, slow on CPU. Uses fewer resources than other GPU "
                    "detectors but can often return more false positives."
                    "\nL|s3fd: Fast on GPU, slow on CPU. Can detect more faces and "
                                      "\nL|none: Don't perform normalization on the face."
                                      "\nL|clahe: Perform Contrast Limited Adaptive Histogram "
                                        "align faces with difficult lighting conditions at an "
                                        "extraction speed cost. Different methods will yield "
                                        "different results on different sets. NB: This does not "
                                        "impact the output face, just the input to the aligner."
                                      "\nL|none: Don't perform normalization on the face."
                                      "\nL|clahe: Perform Contrast Limited Adaptive Histogram "
                                      "\nL|none: Don't perform normalization on the face."
                                      "\nL|clahe: Perform Contrast Limited Adaptive Histogram "
                                        "Equalization on the face."
                                        "\nL|'hist': Equalize the histograms on the RGB channels."
                                        "\nL|'mean': Normalize the face colors to the mean."})
          argument_list.append({"opts": ("-r", "--rotate-images"),
                                "type": str,
keep keep keep keep 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 
lib/cli.py