      """ Sorts folders of faces based on input criteria """
      # pylint: disable=no-member
  
      def __init__(self, arguments):
          self._args = arguments
          self.changes = None
          self.serializer = None
          self._vgg_face = None
          self._loader = FacesLoader(self._args.input_dir)
  
      def process(self):
          """ Main processing function of the sort tool """
  
          # Setting default argument values that cannot be set by argparse
  
          # Set output folder to the same value as input folder
          # if the user didn't specify it.
          if self._args.output_dir is None:
              logger.verbose("No output directory provided. Using input folder as output folder.")
              self._args.output_dir = self._args.input_dir
  
          # Assigning default threshold values based on grouping method
          if (self._args.final_process == "folders"
                  and self._args.min_threshold < 0.0):
              method = self._args.group_method.lower()
              if method == 'face-cnn':
                  self._args.min_threshold = 7.2
              elif method == 'hist':
                  self._args.min_threshold = 0.3
  
          # Load VGG Face if sorting by face
          if self._args.sort_method.lower() == "face":
              self._vgg_face = VGGFace(exclude_gpus=self._args.exclude_gpus)
              self._vgg_face.init_model()
  
          # If logging is enabled, prepare container
          if self._args.log_changes:
              self.changes = {}
  
              # Assign default sort_log.json value if user didn't specify one
              if self._args.log_file_path == 'sort_log.json':
                  self._args.log_file_path = os.path.join(self._args.input_dir,
                                                          'sort_log.json')
  
              # Set serializer based on log file extension
              self.serializer = get_serializer_from_filename(self._args.log_file_path)
  
          # Prepare sort, group and final process method names
          _sort = "sort_" + self._args.sort_method.lower()
          _group = "group_" + self._args.group_method.lower()
          _final = "final_process_" + self._args.final_process.lower()
          if _sort.startswith('sort_color-'):
              self._args.color_method = _sort.replace('sort_color-', '')
              _sort = _sort[:10]
          self._args.sort_method = _sort.replace('-', '_')
          self._args.group_method = _group.replace('-', '_')
          self._args.final_process = _final.replace('-', '_')
  
          self.sort_process()
  
      def launch_aligner(self):
          """ Load the aligner plugin to retrieve landmarks """
          extractor = Extractor(None, "fan", None,
                                normalize_method="hist", exclude_gpus=self._args.exclude_gpus)
          extractor.set_batchsize("align", 1)
          extractor.launch()
          return extractor
  
      @staticmethod
      def alignment_dict(filename, image):
          """ Set the image to an ExtractMedia object for alignment """
          height, width = image.shape[:2]
          face = DetectedFace(left=0, width=width, top=0, height=height)
          return ExtractMedia(filename, image, detected_faces=[face])
  
      def _get_landmarks(self):
          """ Multi-threaded, parallel and sequentially ordered landmark loader """
          extractor = self.launch_aligner()
          filename_list, image_list = self._get_images()
          feed_list = list(map(Sort.alignment_dict, filename_list, image_list))
          landmarks = np.zeros((len(feed_list), 68, 2), dtype='float32')
  
          logger.info("Finding landmarks in images...")
          # TODO thread the put to queue so we don't have to put and get at the same time
          # Or even better, set up a proper background loader from disk (i.e. use lib.image.ImageIO)
          for idx, feed in enumerate(tqdm(feed_list, desc="Aligning", file=sys.stdout)):
              extractor.input_queue.put(feed)
              landmarks[idx] = next(extractor.detected_faces()).detected_faces[0].landmarks_xy
  
          return filename_list, image_list, landmarks
  
      def _get_images(self):
          """ Multi-threaded, parallel and sequentially ordered image loader """
          logger.info("Loading images...")
          filename_list = self.find_images(self._args.input_dir)
          with futures.ThreadPoolExecutor() as executor:
              image_list = list(tqdm(executor.map(read_image, filename_list),
                                     desc="Loading Images",
                                     file=sys.stdout,
                                     total=len(filename_list)))
  
          return filename_list, image_list
  
      def sort_process(self):
          """
          This method dynamically assigns the functions that will be used to run
          the core process of sorting, optionally grouping, renaming/moving into
 
</s> remove     def sort_process(self):
        """
        This method dynamically assigns the functions that will be used to run
        the core process of sorting, optionally grouping, renaming/moving into
        folders. After the functions are assigned they are executed.
 </s> add         Returns
        -------
        :class:`argparse.Namespace`
            The command line arguments with output folder correctly set </s> remove     def reload_images(self, group_method, img_list):
        """
        Reloads the image list by replacing the comparative values with those
        that the chosen grouping method expects.
        :param group_method: str name of the grouping method that will be used.
        :param img_list: image list that has been sorted by one of the sort
        methods.
        :return: img_list but with the comparative values that the chosen
        grouping method expects.
        """
        logger.info("Preparing to group...")
        if group_method == 'group_blur':
            filename_list, image_list = self._get_images()
            blurs = [self.estimate_blur(img) for img in image_list]
            temp_list = list(zip(filename_list, blurs))
        elif group_method == 'group_blur_fft':
            filename_list, image_list = self._get_images()
            fft_blurs = [self.estimate_blur_fft(img) for img in image_list]
            temp_list = list(zip(filename_list, fft_blurs))
        elif group_method == 'group_face_cnn':
            filename_list, image_list, landmarks = self._get_landmarks()
            temp_list = list(zip(filename_list, landmarks))
        elif group_method == 'group_face_yaw':
            filename_list, image_list, landmarks = self._get_landmarks()
            yaws = [self.calc_landmarks_face_yaw(mark) for mark in landmarks]
            temp_list = list(zip(filename_list, yaws))
        elif group_method == 'group_hist':
            filename_list, image_list = self._get_images()
            histograms = [cv2.calcHist([img], [0], None, [256], [0, 256]) for img in image_list]
            temp_list = list(zip(filename_list, histograms))
        elif group_method == 'group_black_pixels':
            filename_list, image_list = self._get_images()
            black_pixels = [np.ndarray.all(img == [0, 0, 0], axis=2).sum()/img.size*100*3
                            for img in image_list]
            temp_list = list(zip(filename_list, black_pixels))
        else:
            raise ValueError(f"{group_method} group_method not found.")

        return self.splice_lists(img_list, temp_list)

    @staticmethod
    def _near_split(bin_range, num_bins):
        """ Obtain the split for the given number of bins for the given range

        Parameters
        ----------
        bin_range: int
            The range of data to separate into bins
        num_bins: int
            The number of bins to create
 </s> add     def process(self) -> None:
        """ Main processing function of the sort tool </s> remove     # pylint: disable=no-member

 </s> add  </s> remove         sort_method = self._args.sort_method.lower()
        group_method = self._args.group_method.lower()
        final_method = self._args.final_process.lower()

        img_list = getattr(self, sort_method)()
        if "folders" in final_method:
            # Check if non-dissimilarity sort method and group method are not the same
            if group_method.replace('group_', '') not in sort_method:
                img_list = self.reload_images(group_method, img_list)
                img_list = getattr(self, group_method)(img_list)
            else:
                img_list = getattr(self, group_method)(img_list)

        getattr(self, final_method)(img_list)

        logger.info("Done.")

    # Methods for sorting
    def sort_distance(self):
        """ Sort by comparison of face landmark points to mean face by average distance of core
        landmarks. """
        logger.info("Sorting by average distance of landmarks...")
        filenames = []
        distances = []
        filelist = [os.path.join(self._loader.location, fname)
                    for fname in os.listdir(self._loader.location)
                    if os.path.splitext(fname)[-1] == ".png"]
        for filename, metadata in tqdm(read_image_meta_batch(filelist),
                                       total=len(filelist),
                                       desc="Calculating Distances"):
            if not metadata:
                msg = ("The images to be sorted do not contain alignment data. Images must have "
                       "been generated by Faceswap's Extract process.\nIf you are sorting an "
                       "older faceset, then you should re-extract the faces from your source "
                       "alignments file to generate this data.")
                raise FaceswapError(msg)
            alignments = metadata["itxt"]["alignments"]
            aligned_face = AlignedFace(np.array(alignments["landmarks_xy"], dtype="float32"))
            filenames.append(filename)
            distances.append(aligned_face.average_distance)

        logger.info("Sorting...")
        matched_list = list(zip(filenames, distances))
        img_list = sorted(matched_list, key=operator.itemgetter(1))
        return img_list

    def sort_blur(self):
        """ Sort by blur amount """
        logger.info("Sorting by estimated image blur...")

        blurs = [(filename, self.estimate_blur(image, metadata))
                 for filename, image, metadata in tqdm(self._loader.load(),
                                                       desc="Estimating blur",
                                                       total=self._loader.count,
                                                       leave=False)]
        logger.info("Sorting...")
        return sorted(blurs, key=lambda x: x[1], reverse=True)

    def sort_blur_fft(self):
        """ Sort by fft filtered blur amount with fft"""
        logger.info("Sorting by estimated fft filtered image blur...")

        fft_blurs = [(filename, self.estimate_blur_fft(image, metadata))
                     for filename, image, metadata in tqdm(self._loader.load(),
                                                           desc="Estimating fft blur score",
                                                           total=self._loader.count,
                                                           leave=False)]
        logger.info("Sorting...")
        return sorted(fft_blurs, key=lambda x: x[1], reverse=True)

    def sort_color(self):
        """ Score by channel average intensity """
        logger.info("Sorting by channel average intensity...")
        desired_channel = {'gray': 0, 'luma': 0, 'orange': 1, 'green': 2}
        method = self._args.color_method
        channel_to_sort = next(v for (k, v) in desired_channel.items() if method.endswith(k))
        filename_list, image_list = self._get_images()

        logger.info("Converting to appropriate colorspace...")
        same_size = all(img.size == image_list[0].size for img in image_list)
        images = np.array(image_list, dtype='float32')[None, ...] if same_size else image_list
        converted_images = self._convert_color(images, same_size, method)

        logger.info("Scoring each image...")
        if same_size:
            scores = np.average(converted_images[0], axis=(1, 2))
        else:
            progress_bar = tqdm(converted_images, desc="Scoring", file=sys.stdout)
            scores = np.array([np.average(image, axis=(0, 1)) for image in progress_bar])

        logger.info("Sorting...")
        matched_list = list(zip(filename_list, scores[:, channel_to_sort]))
        sorted_file_img_list = sorted(matched_list, key=operator.itemgetter(1), reverse=True)
        return sorted_file_img_list

    def sort_face(self):
        """ Sort by identity similarity """
        logger.info("Sorting by identity similarity...")
        filenames = []
        preds = []
        for filename, image, metadata in tqdm(self._loader.load(),
                                              desc="Classifying Faces",
                                              total=self._loader.count,
                                              leave=False):
            if not metadata:
                msg = ("The images to be sorted do not contain alignment data. Images must have "
                       "been generated by Faceswap's Extract process.\nIf you are sorting an "
                       "older faceset, then you should re-extract the faces from your source "
                       "alignments file to generate this data.")
                raise FaceswapError(msg)
            alignments = metadata["alignments"]
            face = AlignedFace(np.array(alignments["landmarks_xy"], dtype="float32"),
                               image=image,
                               centering="legacy",
                               size=self._vgg_face.input_size,
                               is_aligned=True).face
            filenames.append(filename)
            preds.append(self._vgg_face.predict(face))

        logger.info("Sorting by ward linkage...")

        indices = self._vgg_face.sorted_similarity(np.array(preds), method="ward")
        img_list = np.array(filenames)[indices]
        return img_list

    def sort_face_cnn(self):
        """ Sort by landmark similarity """
        logger.info("Sorting by landmark similarity...")
        filename_list, _, landmarks = self._get_landmarks()
        img_list = list(zip(filename_list, landmarks))

        logger.info("Comparing landmarks and sorting...")
        img_list_len = len(img_list)
        for i in tqdm(range(0, img_list_len - 1), desc="Comparing", file=sys.stdout):
            min_score = float("inf")
            j_min_score = i + 1
            for j in range(i + 1, img_list_len):
                fl1 = img_list[i][1]
                fl2 = img_list[j][1]
                score = np.sum(np.absolute((fl2 - fl1).flatten()))
                if score < min_score:
                    min_score = score
                    j_min_score = j
            (img_list[i + 1], img_list[j_min_score]) = (img_list[j_min_score], img_list[i + 1])
        return img_list

    def sort_face_cnn_dissim(self):
        """ Sort by landmark dissimilarity """
        logger.info("Sorting by landmark dissimilarity...")
        filename_list, _, landmarks = self._get_landmarks()
        scores = np.zeros(len(filename_list), dtype='float32')
        img_list = list(list(items) for items in zip(filename_list, landmarks, scores))

        logger.info("Comparing landmarks...")
        img_list_len = len(img_list)
        for i in tqdm(range(0, img_list_len - 1), desc="Comparing", file=sys.stdout):
            score_total = 0
            for j in range(i + 1, img_list_len):
                if i == j:
                    continue
                fl1 = img_list[i][1]
                fl2 = img_list[j][1]
                score_total += np.sum(np.absolute((fl2 - fl1).flatten()))
            img_list[i][2] = score_total

        logger.info("Sorting...")
        img_list = sorted(img_list, key=operator.itemgetter(2), reverse=True)
        return img_list

    def sort_face_yaw(self):
        """ Sort by estimated face yaw angle """
        logger.info("Sorting by estimated face yaw angle..")
        filenames = []
        yaws = []
        filelist = [os.path.join(self._loader.location, fname)
                    for fname in os.listdir(self._loader.location)
                    if os.path.splitext(fname)[-1] == ".png"]
        for filename, metadata in tqdm(read_image_meta_batch(filelist),
                                       total=len(filelist),
                                       desc="Calculating Yaw"):
            if not metadata:
                msg = ("The images to be sorted do not contain alignment data. Images must have "
                       "been generated by Faceswap's Extract process.\nIf you are sorting an "
                       "older faceset, then you should re-extract the faces from your source "
                       "alignments file to generate this data.")
                raise FaceswapError(msg)
            alignments = metadata["itxt"]["alignments"]
            aligned_face = AlignedFace(np.array(alignments["landmarks_xy"], dtype="float32"),
                                       image=None,
                                       centering="legacy",
                                       is_aligned=True)
            filenames.append(filename)
            yaws.append(aligned_face.pose.yaw)

        logger.info("Sorting...")
        matched_list = list(zip(filenames, yaws))
        img_list = sorted(matched_list, key=operator.itemgetter(1), reverse=True)
        return img_list

    def sort_hist(self):
        """ Sort by image histogram similarity """
        logger.info("Sorting by histogram similarity...")

        # TODO We have metadata here, so we can mask the face for hist sorting
        img_list = [(filename, cv2.calcHist([image], [0], None, [256], [0, 256]))
                    for filename, image, _ in tqdm(self._loader.load(),
                                                   desc="Calculating histograms",
                                                   total=self._loader.count,
                                                   leave=False)]

        logger.info("Comparing histograms and sorting...")
        img_list_len = len(img_list)
        for i in tqdm(range(0, img_list_len - 1), desc="Comparing histograms", file=sys.stdout):
            min_score = float("inf")
            j_min_score = i + 1
            for j in range(i + 1, img_list_len):
                score = cv2.compareHist(img_list[i][1], img_list[j][1], cv2.HISTCMP_BHATTACHARYYA)
                if score < min_score:
                    min_score = score
                    j_min_score = j
            (img_list[i + 1], img_list[j_min_score]) = (img_list[j_min_score], img_list[i + 1])
        return img_list

    def sort_hist_dissim(self):
        """ Sort by image histogram dissimilarity """
        logger.info("Sorting by histogram dissimilarity...")

        # TODO We have metadata here, so we can mask the face for hist sorting
        img_list = [[filename, cv2.calcHist([image], [0], None, [256], [0, 256]), 0.0]
                    for filename, image, _ in tqdm(self._loader.load(),
                                                   desc="Calculating histograms",
                                                   total=self._loader.count,
                                                   leave=False)]

        img_list_len = len(img_list)
        for i in tqdm(range(0, img_list_len), desc="Comparing histograms", file=sys.stdout):
            score_total = 0
            for j in range(0, img_list_len):
                if i == j:
                    continue
                score_total += cv2.compareHist(img_list[i][1],
                                               img_list[j][1],
                                               cv2.HISTCMP_BHATTACHARYYA)
            img_list[i][2] = score_total

        logger.info("Sorting...")
        return sorted(img_list, key=lambda x: x[2], reverse=True)

    def sort_size(self):
        """ Sort the faces by largest face (in original frame) to smallest """
        logger.info("Sorting by original face size...")
        img_list = []
        for filename, image, metadata in tqdm(self._loader.load(),
                                              desc="Calculating face sizes",
                                              total=self._loader.count,
                                              leave=False):
            if not metadata:
                msg = ("The images to be sorted do not contain alignment data. Images must have "
                       "been generated by Faceswap's Extract process.\nIf you are sorting an "
                       "older faceset, then you should re-extract the faces from your source "
                       "alignments file to generate this data.")
                raise FaceswapError(msg)
            alignments = metadata["alignments"]
            aligned_face = AlignedFace(np.array(alignments["landmarks_xy"], dtype="float32"),
                                       image=image,
                                       centering="legacy",
                                       is_aligned=True)
            roi = aligned_face.original_roi
            size = ((roi[1][0] - roi[0][0]) ** 2 + (roi[1][1] - roi[0][1]) ** 2) ** 0.5
            img_list.append((filename, size))

        logger.info("Sorting...")
        return sorted(img_list, key=lambda x: x[1], reverse=True)

    def sort_black_pixels(self):
        """ Sort by percentage of black pixels
 </s> add         logger.debug("setting output folder: %s", arguments.output_dir)
        input_dir = arguments.input_dir
        output_dir = arguments.output_dir
        sort_method = arguments.sort_method
        group_method = arguments.group_method

        needs_rename = sort_method != "none" and group_method == "none"

        if needs_rename and arguments.keep_original and (not output_dir or
                                                         output_dir == input_dir):
            output_dir = os.path.join(input_dir, "sorted")
            logger.warning("No output folder selected, but files need renaming. "
                           "Outputting to: '%s'", output_dir)
        elif not output_dir:
            output_dir = input_dir
            logger.warning("No output folder selected, files will be sorted in place in: '%s'",
                           output_dir)

        arguments.output_dir = output_dir
        logger.debug("Set output folder: %s", arguments.output_dir)
        return arguments

    def _parse_arguments(self, arguments):
        """ Parse the arguments and update/format relevant choices

        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process </s> remove         logger.info("Grouping by face-yaw...")
        bins = [[] for _ in range(num_bins)]
        idx = 0
        for i in range(num_bins):
            for _ in range(num_per_bin):
                bins[i].append(img_list[idx][0])
                idx += 1
 </s> add         if arguments.log_changes and arguments.log_file_path == "sort_log.json":
            # Assign default sort_log.json value if user didn't specify one
            arguments.log_file_path = os.path.join(self._args.input_dir, 'sort_log.json')
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
      """ Sorts folders of faces based on input criteria """
      # pylint: disable=no-member
  
      def __init__(self, arguments):
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
        logger.debug("Initializing %s: arguments: %s", self.__class__.__name__, arguments)
        self._processes = dict(blur=SortBlur,
                               blur_fft=SortBlur,
                               distance=SortDistance,
                               yaw=SortYaw,
                               pitch=SortPitch,
                               size=SortSize,
                               face=SortFace,
                               face_cnn=SortFaceCNN,
                               face_cnn_dissim=SortFaceCNN,
                               hist=SortHistogram,
                               hist_dissim=SortHistogram,
                               color_black=SortColor,
                               color_gray=SortColor,
                               color_luma=SortColor,
                               color_green=SortColor,
                               color_orange=SortColor)

        self._args = self._parse_arguments(arguments)
        self._changes = {}
        self.serializer: Optional[Serializer] = None

        if arguments.log_changes:
            self.serializer = get_serializer_from_filename(arguments.log_file_path)

        self._sorter = self._get_sorter()
        logger.debug("Initialized %s", self.__class__.__name__)

    def _set_output_folder(self, arguments):
        """ Set the output folder correctly if it has not been provided
        Parameters:
        ----------
        arguments: :class:`argparse.Namespace`
            The command line arguments passed to the sort process
  
      def sort_process(self):
          """
          This method dynamically assigns the functions that will be used to run
          the core process of sorting, optionally grouping, renaming/moving into
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 replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace 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
 Overhaul sort:
  - Standardize image data reading and writing
  - Optimize loading (just one pass required)
  - Make all sort groups binnable (to greater or lesser results)
  - Add sort by pitch
  - Deprecate multiple options
  - linting, docs + locales 
tools/sort/sort.py