Example #1
0
    def get_matched_segments(self, seqrecord_name):
        "It returns the matched segments for the given query (SeqRecord) name."
        try:
            blast = self._blasts[seqrecord_name]
        except KeyError:
            # There was no match in the blast
            return None

        match_parts = [mp for m in blast["matches"] for mp in m["match_parts"]]
        segments = covered_segments_from_match_parts(match_parts, in_query=False)
        return segments
Example #2
0
    def get_matched_segments(self, seqrecord_name):
        'It returns the matched segments for the given query (SeqRecord) name.'
        try:
            blast = self._blasts[seqrecord_name]
        except KeyError:
            # There was no match in the blast
            return None

        match_parts = [mp for m in blast['matches'] for mp in m['match_parts']]
        segments = covered_segments_from_match_parts(match_parts,
                                                     in_query=False)
        return segments
Example #3
0
 def get_matched_segments(self, seqrecord_name):
     "it return the matched segments for the given seqrecord"
     ignore_elongation_shorter = DEFAULT_IGNORE_ELONGATION_SHORTER
     try:
         match_parts = self._match_parts[seqrecord_name]
     except KeyError:
         # There was no match in the blast
         return None
     # Any of the match_parts has been elongated?
     elongated_match = False
     for m_p in match_parts:
         if ELONGATED in m_p and m_p[ELONGATED] > ignore_elongation_shorter:
             elongated_match = True
     segments = covered_segments_from_match_parts(match_parts, in_query=False)
     return segments, elongated_match
Example #4
0
    def get_matched_segments_for_read(self, read_name):
        "It returns the matched segments for any oligo"
        setting_key = "DEFAULT_IGNORE_ELONGATION_SHORTER"
        ignore_elongation_shorter = get_setting(setting_key)

        try:
            match_parts = self._match_parts[read_name]
        except KeyError:
            # There was no match in the blast
            return None

        # Any of the match_parts has been elongated?
        elongated_match = False
        for m_p in match_parts:
            if ELONGATED in m_p and m_p[ELONGATED] > ignore_elongation_shorter:
                elongated_match = True
        segments = covered_segments_from_match_parts(match_parts, in_query=False)
        return segments, elongated_match
Example #5
0
    def get_matched_segments_for_read(self, read_name):
        'It returns the matched segments for any oligo'
        setting_key = 'DEFAULT_IGNORE_ELONGATION_SHORTER'
        ignore_elongation_shorter = get_setting(setting_key)

        try:
            match_parts = self._match_parts[read_name]
        except KeyError:
            # There was no match in the blast
            return None

        # Any of the match_parts has been elongated?
        elongated_match = False
        for m_p in match_parts:
            if ELONGATED in m_p and m_p[ELONGATED] > ignore_elongation_shorter:
                elongated_match = True
        segments = covered_segments_from_match_parts(match_parts,
                                                     in_query=False)
        return segments, elongated_match
Example #6
0
    def test_match_parts_merging(self):
        '''Merging match parts'''
        # ---   ---
        #  ---
        match_part1 = {'query_start': 80, 'query_end': 100,
                       'subject_start': 180, 'subject_end': 200}
        match_part2 = {'query_start': 90, 'query_end': 110,
                       'subject_start': 190, 'subject_end': 210}
        match_part3 = {'query_start': 190, 'query_end': 200,
                       'subject_start': 290, 'subject_end': 300}
        mparts = [match_part1, match_part2, match_part3]
        covered_segs = covered_segments_from_match_parts(mparts)
        assert covered_segs == [(80, 110), (190, 200)]

        match_part2 = {'query_start': 90, 'query_end': 110,
                       'subject_start': 190, 'subject_end': 210}
        match_part3 = {'query_start': 190, 'query_end': 200,
                       'subject_start': 290, 'subject_end': 300}
        covered_segs = covered_segments_from_match_parts([match_part2,
                                                          match_part3])
        assert covered_segs == [(90, 110), (190, 200)]

        # q 0---10
        # s 0---10
        #   q 5---15
        #   s 15--25

        match_part1 = {'query_start': 0, 'query_end': 10,
                       'subject_start': 0, 'subject_end': 10}
        match_part2 = {'query_start': 5, 'query_end': 15,
                       'subject_start': 15, 'subject_end': 25}
        mparts = [match_part1, match_part2]
        covered_segs = covered_segments_from_match_parts(mparts)
        assert covered_segs == [(0, 15)]

        covered_segs = covered_segments_from_match_parts(mparts,
                                                         in_query=False)
        assert covered_segs == [(0, 10), (15, 25)]

        match_part1 = {'query_start': 1, 'query_end': 10,
                       'subject_start': 1, 'subject_end': 10}
        match_part2 = {'query_start': 11, 'query_end': 20,
                       'subject_start': 11, 'subject_end': 20}
        match_part3 = {'query_start': 30, 'query_end': 40,
                       'subject_start': 30, 'subject_end': 40}
        mparts = [match_part1, match_part2, match_part3]
        covered_segs = covered_segments_from_match_parts(mparts)
        assert covered_segs == [(1, 20), (30, 40)]

        match_part1 = {'query_start': 1, 'query_end': 10,
                       'subject_start': 1, 'subject_end': 10}
        match_part2 = {'query_start': 10, 'query_end': 20,
                       'subject_start': 10, 'subject_end': 20}
        mparts = [match_part1, match_part2]
        covered_segs = covered_segments_from_match_parts(mparts)
        assert covered_segs == [(1, 20)]

        match_part1 = {'query_start': 80, 'query_end': 85,
                       'subject_start': 180, 'subject_end': 185}
        match_part2 = {'query_start': 90, 'query_end': 110,
                       'subject_start': 190, 'subject_end': 210}
        match_part3 = {'query_start': 190, 'query_end': 200,
                       'subject_start': 290, 'subject_end': 300}
        mparts = [match_part1, match_part2, match_part3]
        covered_segs = covered_segments_from_match_parts(mparts,
                                                      merge_segments_closer=10)
        assert covered_segs == [(80, 110), (190, 200)]
        covered_segs = covered_segments_from_match_parts(mparts)
        assert covered_segs == [(80, 85), (90, 110), (190, 200)]

        mpart1 = {'query_start': 0, 'query_end': 41,
                  'subject_end': 140, 'subject_start': 99}
        mpart2 = {'query_start': 0, 'query_end': 41,
                  'subject_start': 140, 'subject_end': 99}
        mpart3 = {'query_start': 0, 'query_end': 41,
                  'subject_start': 0, 'subject_end': 41}
        mparts = [mpart1, mpart2, mpart3]
        covered_segs = covered_segments_from_match_parts(mparts,
                                                         in_query=False)
        assert covered_segs == [(0, 41), (99, 140)]