          if not any(val for val in filter_lists.values()):
              return None
  
          facefilter = None
          filter_files = [self.set_face_filter(f_type, filter_lists[f_type])
                          for f_type in ("filter", "nfilter")]
  
          if any(filters for filters in filter_files):
              facefilter = FilterFunc(filter_files[0],
                                      filter_files[1],
 
</s> remove     def load_face_filter(self, filter_lists, ref_threshold, aligner, detector,
                         multiprocess):
        """ Load faces to filter out of images """
 </s> add     def _load_face_filter(self, filter_lists, ref_threshold, aligner, detector, multiprocess):
        """ Set up and load the :class:`~lib.face_filter.FaceFilter`.

        Parameters
        ----------
        filter_lists: dict
            The filter and nfilter image paths
        ref_threshold: float
            The reference threshold for a positive match
        aligner: str
            The aligner to use
        detector: str
            The detector to use
        multiprocess: bool
            Whether to run the extraction pipeline in single process mode or not

        Returns
        -------
        :class:`~lib.face_filter.FaceFilter`
            The face filter
        """ </s> remove     def set_face_filter(f_type, f_args):
        """ Set the required filters """
 </s> add     def _set_face_filter(f_type, f_args):
        """ Check filter files exist and add the filter file paths to a list.

        Parameters
        ----------
        f_type: {"filter", "nfilter"}
            The type of filter to create this list for
        f_args: str or list
            The filter image(s) to use

        Returns
        -------
        list
            The confirmed existing paths to filter files to use
        """ </s> remove             for item, options in self.config_dicts[config_section].items():
 </s> add             for item, options in self._config_dicts[config_section].items(): </s> remove         self.display = FacesDisplay(256, 64, self.tk_vars)
        self.samples = Samples(arguments, 5, self.display, self.lock, self.trigger_patch)
        self.patch = Patch(arguments,
                           self.samples,
                           self.display,
                           self.lock,
                           self.trigger_patch,
                           self.config_tools,
                           self.tk_vars)

        self.initialize_tkinter()
        self.image_canvas = None
        self.opts_book = None
        self.cli_frame = None  # cli frame holds cli options
 </s> add         self._display = FacesDisplay(256, 64, self._tk_vars)

        trigger_patch = Event()
        self._samples = Samples(arguments, 5, self._display, self._lock, trigger_patch)
        self._patch = Patch(arguments,
                            self._samples,
                            self._display,
                            self._lock,
                            trigger_patch,
                            self._config_tools,
                            self._tk_vars)

        self._initialize_tkinter()
        self._image_canvas = None
        self._opts_book = None
        self._cli_frame = None  # cli frame holds cli options </s> remove         self.tk_vars = dict(refresh=tk.BooleanVar(), busy=tk.BooleanVar())
        for val in self.tk_vars.values():
 </s> add         self._tk_vars = dict(refresh=tk.BooleanVar(), busy=tk.BooleanVar())
        for val in self._tk_vars.values():
        filter_files = [self._set_face_filter(f_type, filter_lists[f_type])
          if not any(val for val in filter_lists.values()):
              return None
  
          facefilter = None
        filter_files = [self._set_face_filter(f_type, filter_lists[f_type])
                          for f_type in ("filter", "nfilter")]
  
          if any(filters for filters in filter_files):
              facefilter = FilterFunc(filter_files[0],
                                      filter_files[1],
keep keep keep keep replace keep keep keep keep keep
 Smart Masks to Convert (#957)

- scripts.convert - Use Smart Masks for Convert
    * Make on-the-fly conversion an explicit option

- Move BlurMask to lib.faces_detect

- tools.preview - Fix for smart masks
    * Subclass from tk.Tk
    * Options to lib.gui.control_helper
    *variable cleanup

- lib.logger - Demote more tensorflow deprecation messages

- Documentation:
    * lib.faces_detect.BlurMask
    * plugins.convert.mask
    * lib.convert
    * scripts.convert
    * scripts.fsmedia
    * tools.preview 
scripts/fsmedia.py