                     <option_name> should always be lower text.
                     <metadata> dictionary requirements are listed below.
  
      The following keys are expected for the _DEFAULTS <metadata> dict:
          datatype:  [required] A python type class. This limits the type of data that can be
                     provided in the .ini file and ensures that the value is returned in the
                     correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                     <class 'str'>, <class 'bool'>.
          default:   [required] The default value for this option.
          info:      [required] A string describing what this option does.
          choices:   [optional] If this option's datatype is of <class 'str'> then valid
                     selections can be defined here. This validates the option and also enables
                     a combobox / radio option in the GUI.
          gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                     radio buttons rather than a combobox to display this option.
          min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                     otherwise it is ignored. Should be a tuple of min and max accepted values.
                     This is used for controlling the GUI slider range. Values are not enforced.
          rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                     required otherwise it is ignored. Used for the GUI slider. For floats, this
                     is the number of decimal places to display. For ints this is the step size.
          fixed:     [optional] [train only]. Training configurations are fixed when the model is
                     created, and then reloaded from the state file. Marking an item as fixed=False
                     indicates that this value can be changed for existing models, and will override
                     the value saved in the state file with the updated value in config. If not
                     provided this will default to True.
  """
  
  
  _HELPTEXT = (
      "S3FD Detector options.Fast on GPU, slow on CPU. Can detect more faces and fewer false "
 
</s> remove         """ Convert a face alignment to detected face object """
 </s> add         """ Set the attributes of this class from an alignments file and optionally load the face
        into the ``image`` attribute.

        Parameters
        ----------
        alignment: dict
            A dictionary entry for a face from an alignments file containing the keys
            ``x``, ``w``, ``y``, ``h``, ``landmarks_xy``. Optionally the key ``hash``
            will be provided, but not all use cases will know the face hash at this time.
        image: numpy.ndarray, optional
            If an image is passed in, then the ``image`` attribute will
            be set to the cropped face based on the passed in bounding box co-ordinates
        """
 </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         """ 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`
        """
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
                     <option_name> should always be lower text.
                     <metadata> dictionary requirements are listed below.
  
      The following keys are expected for the _DEFAULTS <metadata> dict:
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
    datatype:  [required] A python type class. This limits the type of data that can be
                provided in the .ini file and ensures that the value is returned in the
                correct type to faceswap. Valid datatypes are: <class 'int'>, <class 'float'>,
                <class 'str'>, <class 'bool'>.
    default:   [required] The default value for this option.
    info:      [required] A string describing what this option does.
    group:     [optional]. A group for grouping options together in the GUI. If not
                provided this will not group this option with any others.
    choices:   [optional] If this option's datatype is of <class 'str'> then valid
                selections can be defined here. This validates the option and also enables
                a combobox / radio option in the GUI.
    gui_radio: [optional] If <choices> are defined, this indicates that the GUI should use
                radio buttons rather than a combobox to display this option.
    min_max:   [partial] For <class 'int'> and <class 'float'> datatypes this is required
                otherwise it is ignored. Should be a tuple of min and max accepted values.
                This is used for controlling the GUI slider range. Values are not enforced.
    rounding:  [partial] For <class 'int'> and <class 'float'> datatypes this is
                required otherwise it is ignored. Used for the GUI slider. For floats, this
                is the number of decimal places to display. For ints this is the step size.
    fixed:     [optional] [train only]. Training configurations are fixed when the model is
                created, and then reloaded from the state file. Marking an item as fixed=False
                indicates that this value can be changed for existing models, and will override
                the value saved in the state file with the updated value in config. If not
                provided this will default to True.
  """
  
  
  _HELPTEXT = (
      "S3FD Detector options.Fast on GPU, slow on CPU. Can detect more faces and fewer false "
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace 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/detect/s3fd_defaults.py