docs: def deduplication_backup(self, process_bar):
          """
          Backup the current file and compare the content.
  
          :param process_bar: tqdm process bar
          """
          self.fast_backup = False  # Was a fast backup used?
  
          src_path = self.dir_path.resolved_path
          log.debug("*** deduplication backup: '%s'", src_path)
  
          log.debug("abs_src_filepath: '%s'", self.path_helper.abs_src_filepath)
          log.debug("abs_dst_filepath: '%s'", self.path_helper.abs_dst_filepath)
          log.debug("abs_dst_hash_filepath: '%s'", self.path_helper.abs_dst_hash_filepath)
          log.debug("abs_dst_dir: '%s'", self.path_helper.abs_dst_path)
  
          if not self.path_helper.abs_dst_path.is_dir():
              try:
                  self.path_helper.abs_dst_path.makedirs(mode=phlb_config.default_new_path_mode)
              except OSError as err:
                  raise BackupFileError("Error creating out path: %s" % err)
          else:
              assert not self.path_helper.abs_dst_filepath.is_file(), (
                  "Out file already exists: %r" % self.path_helper.abs_src_filepath
              )
  
          try:
              try:
                  with self.path_helper.abs_src_filepath.open("rb") as in_file:
                      with self.path_helper.abs_dst_hash_filepath.open("w") as hash_file:
                          with self.path_helper.abs_dst_filepath.open("wb") as out_file:
                              hash = self._deduplication_backup(self.dir_path, in_file, out_file, process_bar)
                          hash_hexdigest = hash.hexdigest()
                          hash_file.write(hash_hexdigest)
              except OSError as err:
                  # FIXME: Better error message
                  raise BackupFileError("Skip file %s error: %s" % (self.path_helper.abs_src_filepath, err))
          except KeyboardInterrupt:
              # Try to remove created files
              try:
                  self.path_helper.abs_dst_filepath.unlink()
              except OSError:
                  pass
              try:
                  self.path_helper.abs_dst_hash_filepath.unlink()
              except OSError:
                  pass
              raise KeyboardInterrupt
  
          old_backup_entry = deduplicate(self.path_helper.abs_dst_filepath, hash_hexdigest)
          if old_backup_entry is None:
              log.debug("File is unique.")
              self.file_linked = False  # Was a hardlink used?
          else:
              log.debug("File was deduplicated via hardlink to: %s" % old_backup_entry)
              self.file_linked = True  # Was a hardlink used?
  
          # set origin access/modified times to the new created backup file
          atime_ns = self.dir_path.stat.st_atime_ns
          mtime_ns = self.dir_path.stat.st_mtime_ns
          self.path_helper.abs_dst_filepath.utime(ns=(atime_ns, mtime_ns))  # call os.utime()
          log.debug("Set mtime to: %s" % mtime_ns)
  
          BackupEntry.objects.create(
              backup_run=self.backup_run,
              backup_entry_path=self.path_helper.abs_dst_filepath,
              hash_hexdigest=hash_hexdigest,
          )
  
          self.fast_backup = False