              new = "{}_{}{}".format(frame, idx, face_ext)
              if old == new:
                  logger.trace("Face does not require renaming: '%s'", old)
                  continue
              for action in ("temp", "final"):
                  old_file = old if action == "temp" else old + temp_ext
                  new_file = old + temp_ext if action == "temp" else new
                  src = os.path.join(self.faces.folder, old_file)
                  dst = os.path.join(self.faces.folder, new_file)
                  logger.trace("Renaming: '%s' to '%s'", old_file, new_file)
 
</s> remove             rename_count += 1
            logger.verbose("Renamed '%s' to '%s'", old, new)
 </s> add                 if action == "final":
                    rename_count += 1
                    logger.verbose("Renamed '%s' to '%s'", old, new) </s> remove             face_name, face_ext = self.faces.items[f_hash]
 </s> add             faces = self.faces.items[f_hash]
            if len(faces) == 1:
                face_name, face_ext = faces[0]
            else:
                face_name, face_ext = self.check_multi_hashes(faces, frame, idx) </s> remove                        if details[0] == frame_fullname]
 </s> add                        for frame_name, idx in details.items()
                       if frame_name == frame_fullname] </s> remove class Legacy():
    """ Update legacy alignments:

        - Add frame dimensions
        - Rotate landmarks and bounding boxes on legacy alignments
          and remove the 'r' parameter
        - Add face hashes to alignments file
    """

    def __init__(self, alignments, arguments, frames=None, faces=None, child_process=False):
        logger.debug("Initializing %s: (arguments: %s, child_process: %s)",
                     self.__class__.__name__, arguments, child_process)
        self.alignments = alignments
        if child_process:
            self.frames = frames
            self.faces = faces
        else:
            self.frames = Frames(arguments.frames_dir)
            self.faces = Faces(arguments.faces_dir)
        logger.debug("Initialized %s", self.__class__.__name__)

    def process(self):
        """ Run the rotate alignments process """
        no_dims = self.alignments.get_legacy_no_dims()
        rotated = self.alignments.get_legacy_rotation()
        hashes = self.alignments.get_legacy_no_hashes()
        if (not self.frames or (not no_dims and not rotated)) and (not self.faces or not hashes):
            return
        logger.info("[UPDATE LEGACY LANDMARKS]")  # Tidy up cli output
        if no_dims and self.frames:
            logger.info("Legacy landmarks found. Adding frame dimensions...")
            self.add_dimensions(no_dims)
            self.alignments.save()
        if rotated and self.frames:
            logger.info("Legacy rotated frames found. Converting...")
            self.rotate_landmarks(rotated)
            self.alignments.save()
        if hashes and self.faces:
            logger.info("Legacy alignments found. Adding Face Hashes...")
            self.add_hashes(hashes)
            self.alignments.save()

    def add_dimensions(self, no_dims):
        """ Add width and height of original frame to alignments """
        for no_dim in tqdm(no_dims, desc="Adding Frame Dimensions"):
            if no_dim not in self.frames.items.keys():
                continue
            dims = self.frames.load_image(no_dim).shape[:2]
            self.alignments.add_dimensions(no_dim, dims)

    def rotate_landmarks(self, rotated):
        """ Rotate the landmarks """
        for rotate_item in tqdm(rotated, desc="Rotating Landmarks"):
            if rotate_item not in self.frames.items.keys():
                continue
            self.alignments.rotate_existing_landmarks(rotate_item)

    def add_hashes(self, hashes):
        """ Add Face Hashes to the alignments file """
        all_faces = dict()
        logger.info("Getting original filenames, indexes and hashes...")
        for face in self.faces.file_list_sorted:
            filename = face["face_name"]
            extension = face["face_extension"]
            if "_" not in face["face_name"]:
                logger.warning("Unable to determine index of file. Skipping: '%s'", filename)
                continue
            index = filename[filename.rfind("_") + 1:]
            if not index.isdigit():
                logger.warning("Unable to determine index of file. Skipping: '%s'", filename)
                continue
            orig_frame = filename[:filename.rfind("_")] + extension
            all_faces.setdefault(orig_frame, dict())[int(index)] = face["face_hash"]

        logger.info("Updating hashes to alignments...")
        for frame in hashes:
            if frame not in all_faces.keys():
                logger.warning("Skipping missing frame: '%s'", frame)
                continue
            self.alignments.add_face_hashes(frame, all_faces[frame])


 </s> add  </s> remove         frame_faces = [(f_hash, details[1])
 </s> add         frame_faces = list()
        frame_faces = [(f_hash, idx)
            rename_files.append((old, new))
        for action in ("temp", "final"):
            for files in rename_files:
                old, new = files
              new = "{}_{}{}".format(frame, idx, face_ext)
              if old == new:
                  logger.trace("Face does not require renaming: '%s'", old)
                  continue
            rename_files.append((old, new))
        for action in ("temp", "final"):
            for files in rename_files:
                old, new = files
                  old_file = old if action == "temp" else old + temp_ext
                  new_file = old + temp_ext if action == "temp" else new
                  src = os.path.join(self.faces.folder, old_file)
                  dst = os.path.join(self.faces.folder, new_file)
                  logger.trace("Renaming: '%s' to '%s'", old_file, new_file)
keep keep keep keep replace keep keep keep keep keep
 Alignments tool: Filename clash bugfix 
tools/lib_alignments/jobs.py