          self.args = arguments
          self.actions = self.set_actions()
          logger.debug("Initialized %s", self.__class__.__name__)
  
      def set_actions(self):
          """ Compile the actions to be performed into a list """
          postprocess_items = self.get_items()
          actions = list()
          for action, options in postprocess_items.items():
              options = dict() if options is None else options
              args = options.get("args", tuple())
              kwargs = options.get("kwargs", dict())
 
</s> remove         self.args = arguments
        self.actions = self.set_actions()
 </s> add         self._args = arguments
        self._actions = self._set_actions() </s> remove class PostProcess():
    """ Optional post processing tasks """
 </s> add class PostProcess():  # pylint:disable=too-few-public-methods
    """ Optional pre/post processing tasks for convert and extract.

    Builds a pipeline of actions that have optionally been requested to be performed
    in this session.

    Parameters
    ----------
    arguments: :class:`argparse.Namespace`
        The command line arguments that were passed to Faceswap
    """ </s> remove     def get_items(self):
        """ Set the post processing actions """
 </s> add     def _get_items(self):
        """ Check the passed in command line arguments for requested actions,

        For any requested actions, add the item to the actions list along with
        any relevant arguments and keyword arguments.

        Returns
        -------
        dict
            The name of the action to be performed as the key. Any action specific
            arguments and keyword arguments as the value.
        """ </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         defaults = {opt: self.format_to_display(d_locals["selected_{}".format(opt)])
                    for opt in self.options}
        self.busy_indicator = self.build_frame(defaults, refresh_callback, patch_callback)
 </s> add         defaults = {opt: self._format_to_display(d_locals["selected_{}".format(opt)])
                    for opt in self._options}
        self._busy_indicator = self._build_frame(defaults,
                                                 refresh_callback,
                                                 patch_callback,
                                                 available_masks,
                                                 has_predicted_mask)
    def _set_actions(self):
        """ Compile the requested actions to be performed into a list

        Returns
        -------
        list
            The list of :class:`PostProcessAction` to be performed
        """
        postprocess_items = self._get_items()
          self.args = arguments
          self.actions = self.set_actions()
          logger.debug("Initialized %s", self.__class__.__name__)
  
    def _set_actions(self):
        """ Compile the requested actions to be performed into a list

        Returns
        -------
        list
            The list of :class:`PostProcessAction` to be performed
        """
        postprocess_items = self._get_items()
    def _set_actions(self):
        """ Compile the requested actions to be performed into a list

        Returns
        -------
        list
            The list of :class:`PostProcessAction` to be performed
        """
        postprocess_items = self._get_items()
    def _set_actions(self):
        """ Compile the requested actions to be performed into a list

        Returns
        -------
        list
            The list of :class:`PostProcessAction` to be performed
        """
        postprocess_items = self._get_items()
          actions = list()
          for action, options in postprocess_items.items():
              options = dict() if options is None else options
              args = options.get("args", tuple())
              kwargs = options.get("kwargs", dict())
keep keep keep keep replace replace 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