      @property
      def _filetypes(self):
          """ dict: The accepted extensions for each file type for opening/saving """
          all_files = ("All files", "*.*")
          filetypes = {"default": (all_files,),
                       "alignments": [("Faceswap Alignments", "*.fsa"),
                                      all_files],
                       "config_project": [("Faceswap Project files", "*.fsw"), all_files],
                       "config_task": [("Faceswap Task files", "*.fst"), all_files],
                       "config_all": [("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
                       "csv": [("Comma separated values", "*.csv"), all_files],
                       "image": [("Bitmap", "*.bmp"),
                                 ("JPG", "*.jpeg *.jpg"),
                                 ("PNG", "*.png"),
                                 ("TIFF", "*.tif *.tiff"),
                                 all_files],
                       "ini": [("Faceswap config files", "*.ini"), all_files],
                       "state": [("State files", "*.json"), all_files],
                       "log": [("Log files", "*.log"), all_files],
                       "video": [("Audio Video Interleave", "*.avi"),
                                 ("Flash Video", "*.flv"),
                                 ("Matroska", "*.mkv"),
                                 ("MOV", "*.mov"),
                                 ("MP4", "*.mp4"),
                                 ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                                 ("WebM", "*.webm"),
                                 ("Windows Media Video", "*.wmv"),
                                 all_files]}
  
          # Add in multi-select options and upper case extensions for Linux
          for key in filetypes:
              if platform.system() == "Linux":
                  filetypes[key] = [item
 
</s> remove         for model in self._get_all_sub_models(self._model):
 </s> add         for model in _get_all_sub_models(self._model): </s> remove     def _freeze_weights(self):
        """ If freeze has been selected in the cli arguments, then freeze those models indicated
        in the plugin's configuration. """
        if not self._args.freeze_weights:
            logger.debug("Freeze weights deselected. Not freezing")
            return

        to_freeze = self.config.get("freeze_layers")  # Standardized config for freezing weights
        to_freeze = to_freeze if to_freeze else ["encoder"]  # No plugin config
        for layer in self._get_all_sub_models(self._model):
            if layer.name in to_freeze:
                logger.info("Freezing weights for '%s' in model '%s'", layer.name, self.name)
                layer.trainable = False
                to_freeze.remove(layer.name)
        if to_freeze:
            logger.warning("The following layers were set to be frozen but do not exist in the "
                           "model: %s", to_freeze)

 </s> add  </s> remove         return {
            "effmpeg": {
                "input": {
                    "extract": "filename",
                    "gen-vid": "dir",
                    "get-fps": "filename",
                    "get-info": "filename",
                    "mux-audio": "filename",
                    "rescale": "filename",
                    "rotate": "filename",
                    "slice": "filename"},
                "output": {
                    "extract": "dir",
                    "gen-vid": "savefilename",
                    "get-fps": "nothing",
                    "get-info": "nothing",
                    "mux-audio": "savefilename",
                    "rescale": "savefilename",
                    "rotate": "savefilename",
                    "slice": "savefilename"}
                }
            }
 </s> add         return dict(effmpeg=dict(input={"extract": "filename",
                                        "gen-vid": "dir",
                                        "get-fps": "filename",
                                        "get-info": "filename",
                                        "mux-audio": "filename",
                                        "rescale": "filename",
                                        "rotate": "filename",
                                        "slice": "filename"},
                                 output={"extract": "dir",
                                         "gen-vid": "savefilename",
                                         "get-fps": "nothing",
                                         "get-info": "nothing",
                                         "mux-audio": "savefilename",
                                         "rescale": "savefilename",
                                         "rotate": "savefilename",
                                         "slice": "savefilename"})) </s> remove     def _get_all_sub_models(self, model, models=None):
        """ For a given model, return all sub-models that occur (recursively) as children.

        Parameters
        ----------
        model: :class:`keras.models.Model`
            A Keras model to scan for sub models
        models: `None`
            Do not provide this parameter. It is used for recursion

        Returns
        -------
        list
            A list of all :class:`keras.models.Model`s found within the given model. The provided
            model will always be returned in the first position
        """
        if models is None:
            models = [model]
        else:
            models.append(model)
        for layer in model.layers:
            if isinstance(layer, KModel):
                self._get_all_sub_models(layer, models=models)
        return models

 </s> add  </s> remove         tk_vars = {"display": display,
                   "runningtask": runningtask,
                   "istraining": istraining,
                   "action": actioncommand,
                   "generate": generatecommand,
                   "consoleclear": consoleclear,
                   "refreshgraph": refreshgraph,
                   "updatepreview": updatepreview,
                   "analysis_folder": analysis_folder}
 </s> add         tk_vars = dict(display=display,
                       runningtask=runningtask,
                       istraining=istraining,
                       action=actioncommand,
                       generate=generatecommand,
                       consoleclear=consoleclear,
                       refreshgraph=refreshgraph,
                       updatepreview=updatepreview,
                       analysis_folder=analysis_folder)
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
      @property
      def _filetypes(self):
          """ dict: The accepted extensions for each file type for opening/saving """
          all_files = ("All files", "*.*")
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
        filetypes = dict(
            default=(all_files,),
            alignments=[("Faceswap Alignments", "*.fsa"), all_files],
            config_project=[("Faceswap Project files", "*.fsw"), all_files],
            config_task=[("Faceswap Task files", "*.fst"), all_files],
            config_all=[("Faceswap Project and Task files", "*.fst *.fsw"), all_files],
            csv=[("Comma separated values", "*.csv"), all_files],
            image=[("Bitmap", "*.bmp"),
                   ("JPG", "*.jpeg *.jpg"),
                   ("PNG", "*.png"),
                   ("TIFF", "*.tif *.tiff"),
                   all_files],
            ini=[("Faceswap config files", "*.ini"), all_files],
            model=[("Keras model files", "*.h5"), all_files],
            state=[("State files", "*.json"), all_files],
            log=[("Log files", "*.log"), all_files],
            video=[("Audio Video Interleave", "*.avi"),
                   ("Flash Video", "*.flv"),
                   ("Matroska", "*.mkv"),
                   ("MOV", "*.mov"),
                   ("MP4", "*.mp4"),
                   ("MPEG", "*.mpeg *.mpg *.ts *.vob"),
                   ("WebM", "*.webm"),
                   ("Windows Media Video", "*.wmv"),
                   all_files])
  
          # Add in multi-select options and upper case extensions for Linux
          for key in filetypes:
              if platform.system() == "Linux":
                  filetypes[key] = [item
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 replace replace keep keep keep keep keep
 Training - Load Weights
  - Enable the loading of previously trained encoders for new models. 
lib/gui/utils.py