Beispiel #1
0
    def __mutate_rbs(self):
        '''Mutates RBS.'''
        move = random.random()
        pos = int(random.random() * len(self.__seqs[2]))

        # Insert:
        if move < 0.1 and \
                len(self.__seqs[2]) < rbs_calc.MAX_RBS_LENGTH:
            base = random.choice(seq_utils.NUCLEOTIDES)
            rbs_new = self.__seqs[2][0:pos] + base + \
                self.__seqs[2][pos:len(self.__seqs[2])]
            pre_seq_new = self.__seqs_new[1][1:] \
                if len(self.__seqs_new[1]) > 0 else ''

        # Delete:
        elif move < 0.2 and len(self.__seqs[2]) > 1:
            rbs_new = _replace(self.__seqs[2], pos, '')
            pre_seq_new = random.choice(seq_utils.NUCLEOTIDES) + \
                self.__seqs_new[1]

        # Replace:
        else:
            rbs_new = _replace(self.__seqs[2], pos, _rand_nuc())
            pre_seq_new = self.__seqs_new[1]

        if seq_utils.count_pattern(pre_seq_new + rbs_new, self.__inv_patt) + \
                seq_utils.count_pattern(pre_seq_new + rbs_new,
                                        seq_utils.START_CODON_PATT) == 0:
            self.__seqs_new[1] = pre_seq_new
            self.__seqs_new[2] = rbs_new
        else:
            self.__seqs_new[1] = self.__seqs[1]
            self.__seqs_new[2] = self.__seqs[2]
Beispiel #2
0
    def __mutate_pre_seq(self):
        '''Mutates pre-sequence.'''
        pos = int(random.random() * len(self.__seqs[1]))
        pre_seq_new = _replace(self.__seqs[1], pos, _rand_nuc())

        if seq_utils.count_pattern(pre_seq_new + self.__seqs[2],
                                   self.__inv_patt) + \
                seq_utils.count_pattern(pre_seq_new + self.__seqs[2],
                                        seq_utils.START_CODON_PATT) == 0:
            self.__seqs_new[1] = pre_seq_new
        else:
            self.__seqs_new[1] = self.__seqs[1]
Beispiel #3
0
    def __get_valid_rand_seq(self, length, attempts=0, max_attempts=1000):
        '''Returns a valid random sequence of supplied length.'''
        sys.setrecursionlimit(max_attempts)

        if attempts > max_attempts - 1:
            raise ValueError('Unable to generate valid random sequence of ' +
                             'length ' + str(length))

        seq = ''.join([_rand_nuc() for _ in range(0, length)])

        if seq_utils.count_pattern(seq, self.__inv_patt) + \
                seq_utils.count_pattern(seq,
                                        seq_utils.START_CODON_PATT) == 0:
            return seq

        return self.__get_valid_rand_seq(length, attempts + 1, max_attempts)
Beispiel #4
0
    def __get_init_rbs(self, cds, attempts=0, max_attempts=1000):
        '''Gets an initial RBS.'''
        if attempts > max_attempts - 1:
            raise ValueError('Unable to generate valid initial RBS.')

        rbs = self.__calc.get_initial_rbs(cds, self.__dg_target)

        if seq_utils.count_pattern(rbs,
                                   seq_utils.START_CODON_PATT) == 0:
            return rbs

        return self.__get_init_rbs(cds, attempts + 1, max_attempts)
Beispiel #5
0
 def __get_num_inv_seq(self, seqs):
     '''Returns number of invalid sequences.'''
     return sum([seq_utils.count_pattern(seqs[1] + seqs[2] + cds +
                                         seqs[4] + seqs[5], self.__inv_patt)
                 for cds in seqs[3]])