<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _process_interaction(self, source_id, interaction, text, pmid, extra_annotations):
 """Process an interaction JSON tuple from the ISI output, and adds up to one statement to the list of extracted statements. Parameters source_id : str the JSON key corresponding to the sentence in the ISI output interaction: the JSON list with subject/verb/object information about the event in the ISI output text : str the text of the sentence pmid : str the PMID of the article from which the information was extracted extra_annotations : dict Additional annotations to add to the statement's evidence, potentially containing metadata about the source. Annotations with the key "interaction" will be overridden by the JSON interaction tuple from the ISI output """

        verb = interaction[0].lower()
        subj = interaction[-2]
        obj = interaction[-1]

        # Make ungrounded agent objects for the subject and object
        # Grounding will happen after all statements are extracted in __init__
        subj = self._make_agent(subj)
        obj = self._make_agent(obj)

        # Make an evidence object
        annotations = deepcopy(extra_annotations)
        if 'interaction' in extra_annotations:
            logger.warning("'interaction' key of extra_annotations ignored" +
                           " since this is reserved for storing the raw ISI " +
                           "input.")
        annotations['source_id'] = source_id
        annotations['interaction'] = interaction
        ev = ist.Evidence(source_api='isi',
                          pmid=pmid,
                          text=text.rstrip(),
                          annotations=annotations)

        # For binding time interactions, it is said that a catayst might be
        # specified. We don't use this for now, but extract in case we want
        # to in the future
        cataylst_specified = False
        if len(interaction) == 4:
            catalyst = interaction[1]
            if catalyst is not None:
                cataylst_specified = True
        self.verbs.add(verb)

        statement = None
        if verb in verb_to_statement_type:
            statement_class = verb_to_statement_type[verb]

            if statement_class == ist.Complex:
                statement = ist.Complex([subj, obj], evidence=ev)
            else:
                statement = statement_class(subj, obj, evidence=ev)

        if statement is not None:
            # For Complex statements, the ISI reader produces two events:
            # binds(A, B) and binds(B, A)
            # We want only one Complex statement for each sentence, so check
            # to see if we already have a Complex for this source_id with the
            # same members
            already_have = False
            if type(statement) == ist.Complex:
                for old_s in self.statements:
                    old_id = statement.evidence[0].source_id
                    new_id = old_s.evidence[0].source_id
                    if type(old_s) == ist.Complex and old_id == new_id:
                        old_statement_members = \
                                [m.db_refs['TEXT'] for m in old_s.members]
                        old_statement_members = sorted(old_statement_members)

                        new_statement_members = [m.db_refs['TEXT']
                                                 for m in statement.members]
                        new_statement_members = sorted(new_statement_members)

                        if old_statement_members == new_statement_members:
                            already_have = True
                            break

            if not already_have:
                self.statements.append(statement)