Returns (TUID, line) tuples for a given file at a given revision.

        Uses json-annotate to find all lines in this revision, then it updates
        the database with any missing revisions for the file changes listed
        in annotate. Then, we use the information from annotate coupled with the
        diff information that was inserted into the DB to return TUIDs. This way
        we don't have to deal with child, parents, dates, etc..

        :param files: list of files to process
        :param revision: revision at which to get the file
        :param annotated_files: annotations for each file
        :param commit: True to commit new TUIDs else False
        :param repo: The branch to get tuids from
        :return: List of TuidMap objects

def _get_tuids(
            self,
            transaction,
            files,
            revision,
            annotated_files,
            commit=True,
            repo=None
        ):
        '''
        Returns (TUID, line) tuples for a given file at a given revision.

        Uses json-annotate to find all lines in this revision, then it updates
        the database with any missing revisions for the file changes listed
        in annotate. Then, we use the information from annotate coupled with the
        diff information that was inserted into the DB to return TUIDs. This way
        we don't have to deal with child, parents, dates, etc..

        :param files: list of files to process
        :param revision: revision at which to get the file
        :param annotated_files: annotations for each file
        :param commit: True to commit new TUIDs else False
        :param repo: The branch to get tuids from
        :return: List of TuidMap objects
        '''
        results = []

        for fcount, annotated_object in enumerate(annotated_files):
            file = files[fcount]

            # TODO: Replace old empty annotation if a new one is found
            # TODO: at the same revision and if it is not empty as well.
            # Make sure we are not adding the same thing another thread
            # added.
            tmp_ann = self._get_annotation(revision, file, transaction=transaction)
            if tmp_ann != None:
                results.append((file, self.destringify_tuids(tmp_ann)))
                continue

            # If it's not defined at this revision, we need to add it in
            errored = False
            if isinstance(annotated_object, (text_type, str)):
                errored = True
                Log.warning(
                    "{{file}} does not exist in the revision={{cset}} branch={{branch_name}}",
                    branch_name=repo,
                    cset=revision,
                    file=file
                )
            elif annotated_object is None:
                Log.warning(
                    "Unexpected error getting annotation for: {{file}} in the revision={{cset}} branch={{branch_name}}",
                    branch_name=repo,
                    cset=revision,
                    file=file
                )
                errored = True
            elif 'annotate' not in annotated_object:
                Log.warning(
                    "Missing annotate, type got: {{ann_type}}, expecting:dict returned when getting "
                    "annotation for: {{file}} in the revision {{cset}}",
                    cset=revision, file=file, ann_type=type(annotated_object)
                )
                errored = True

            if errored:
                Log.note("Inserting dummy entry...")
                self.insert_tuid_dummy(transaction, revision, file, commit=commit)
                self.insert_annotate_dummy(transaction, revision, file, commit=commit)
                results.append((file, []))
                continue

            # Gather all missing csets and the
            # corresponding lines.
            line_origins = []
            for node in annotated_object['annotate']:
                cset_len12 = node['node'][:12]

                # If the line added by `cset_len12` is not known
                # add it. Use the 'abspath' field to determine the
                # name of the file it was created in (in case it was
                # changed).
                line_origins.append((node['abspath'], cset_len12, int(node['targetline'])))

            file_names = list(set([f for f, _, _ in line_origins]))
            revs_to_find = list(set([rev for _, rev, _ in line_origins]))
            lines_to_find = list(set([line for _, _, line in line_origins]))
            existing_tuids_tmp = {
                str((file, revision, line)): tuid
                for tuid, file, revision, line in transaction.query(
                    "SELECT tuid, file, revision, line FROM temporal"
                    " WHERE file IN " + quote_list(file_names) +
                    " AND revision IN " + quote_list(revs_to_find) +
                    " AND line IN " + quote_list(lines_to_find)
                ).data
            }

            # Recompute existing tuids based on line_origins
            # entry ordering because we can't order them any other way
            # since the `line` entry in the `temporal` table is relative
            # to it's creation date, not the currently requested
            # annotation.
            existing_tuids = {
                (line_num+1): existing_tuids_tmp[str(ann_entry)]
                for line_num, ann_entry in enumerate(line_origins)
                if str(ann_entry) in existing_tuids_tmp
            }
            new_lines = set([line_num+1 for line_num, _ in enumerate(line_origins)]) - set(existing_tuids.keys())

            # Update DB with any revisions found in annotated
            # object that are not in the DB.
            new_line_origins = {}
            if len(new_lines) > 0:
                try:
                    '''
                        HG Annotate Bug, Issue #58:
                        Here is where we assign the new tuids for the first
                        time we see duplicate entries - they are left
                        in `new_line_origins` after duplicates are found.
                        We only remove it from the lines to insert. In future
                        requests, `existing_tuids` above will handle duplicating
                        tuids for the entries if needed.
                    '''
                    new_line_origins = {
                        line_num: (self.tuid(),) + line_origins[line_num - 1]
                        for line_num in new_lines
                    }

                    duplicate_lines = {
                        line_num+1: line
                        for line_num, line in enumerate(line_origins)
                        if line in line_origins[:line_num]
                    }
                    if len(duplicate_lines) > 0:
                        Log.note(
                            "Duplicates found in {{file}} at {{cset}}: {{dupes}}",
                            file=file,
                            cset=revision,
                            dupes=str(duplicate_lines)
                        )
                        lines_to_insert = [
                            line
                            for line_num, line in new_line_origins.items()
                            if line_num not in duplicate_lines
                        ]
                    else:
                        lines_to_insert = new_line_origins.values()

                    for _, part_of_insert in jx.groupby(lines_to_insert, size=SQL_BATCH_SIZE):
                        transaction.execute(
                            "INSERT INTO temporal (tuid, file, revision, line)"
                            " VALUES " +
                            sql_list(
                                sql_iso(
                                    sql_list(map(quote_value, (tuid, f, rev, line_num)))
                                ) for tuid, f, rev, line_num in list(part_of_insert)
                            )
                        )

                    # Format so we don't have to use [0] to get at the tuid
                    new_line_origins = {line_num: new_line_origins[line_num][0] for line_num in new_line_origins}
                except Exception as e:
                    # Something broke for this file, ignore it and go to the
                    # next one.
                    Log.note("Failed to insert new tuids {{cause}}", cause=e)
                    continue

            tuids = []
            for line_ind, line_origin in enumerate(line_origins):
                line_num = line_ind + 1
                if line_num in existing_tuids:
                    tuids.append(TuidMap(existing_tuids[line_num], line_num))
                else:
                    tuids.append(TuidMap(new_line_origins[line_num], line_num))

            self.insert_annotations(
                transaction,
                [(
                    revision,
                    file,
                    self.stringify_tuids(tuids)
                )]
            )
            results.append((file, tuids))

        return results