Пример #1
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    Inputs:
        seq_x, seq_y: character strings that share a common alphabet with 
            scoring_matrix.
        scoring_matrix: output of build_scoring_matrix. Dictionary of 
            dictionaries whose [seq_x[i]][seq_y[j]] value is the score of the
            alignment of seq_x[i], seq_y[i].
        num_trials: integer number of simulations to run
    Output:
        scoring_distribution: a list of scores from the simulations.
        
    Randomly shuffle seq_y num_trial times, score the local alignment with 
    seq_x.
    """
    # initialize
    scores = []
    
    # run trials
    for trial in range(num_trials):
        # shuffle seq_y
        _seq_y = list(seq_y)
        random.shuffle(_seq_y)
        rand_y = ''.join(_seq_y)
        
        # compute local alignment of seq_x and random permutation of seq_y
        alignment = seq.compute_alignment_matrix(seq_x, rand_y, scoring_matrix, False)
        score = seq.compute_local_alignment(seq_x, rand_y, scoring_matrix, alignment)[0]
        
        # update frequency distribution
        scores.append(score)
            
    return scores
Пример #2
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    Function for question 4
    """
    ## make a copy of seq_y:
    #new_seq_y = ''
    #for each_char in seq_y:
    #    new_seq_y += each_char

    list_seq_y = list(seq_y)
    scoring_distribution = {}
    for dummy_idx in range(num_trials):
        #random.shuffle(new_seq_y)
        random.shuffle(list_seq_y)
        new_seq_y = ''.join(list_seq_y)
        align_matrix = project4.compute_alignment_matrix(
            seq_x, new_seq_y, scores, False)
        local_result = project4.compute_local_alignment(
            seq_x, new_seq_y, scores, align_matrix)
        if (local_result[0] in scoring_distribution):
            scoring_distribution[local_result[0]] += 1
        else:
            scoring_distribution[local_result[0]] = 1

        print dummy_idx

    return scoring_distribution
Пример #3
0
def generate_null_distribution2(seq_x, seq_y, scoring_matrix, num_trials):
    # This function does work. I don't understand why balta2ar write it this way by using distr.json
    distr = {
    }  # store the whole distribution {score1: count1, score2: count2, ..., scoren: countn}
    raw = [
    ]  # store all the scores: [score1, score2, ..., scoren], could be duplicate

    try:
        with open('distr.json') as f:
            pair = loads(f.read())
            return pair['distr'], pair['raw']
    except Exception as e:
        print('can\'t open file', str(e))

    for _ in range(num_trials):
        temp = list(seq_y)
        shuffle(temp)
        rand_y = ''.join(temp)
        align_matrix = compute_alignment_matrix(seq_x, rand_y, scoring_matrix,
                                                False)
        score, _, _ = compute_local_alignment(seq_x, rand_y, scoring_matrix,
                                              align_matrix)
        if score not in distr:
            distr[score] = 0
        distr[score] += 1
        raw.append(score)

    with open('distr.json', 'w') as f:
        f.write(dumps({'distr': distr, 'raw': raw}))

    return distr, raw
Пример #4
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    Function for question 4
    """
    ## make a copy of seq_y:
    #new_seq_y = ''
    #for each_char in seq_y:
    #    new_seq_y += each_char

    list_seq_y = list(seq_y)
    scoring_distribution = {}
    for dummy_idx in range(num_trials):
        #random.shuffle(new_seq_y)
        random.shuffle(list_seq_y)
        new_seq_y = ''.join(list_seq_y)
        align_matrix = project4.compute_alignment_matrix(seq_x, new_seq_y, scores, False)
        local_result = project4.compute_local_alignment(seq_x, new_seq_y, scores, align_matrix)
        if (local_result[0] in scoring_distribution):
            scoring_distribution[local_result[0]] += 1
        else:    
            scoring_distribution[local_result[0]] = 1

        print dummy_idx

    return scoring_distribution
def question_1():
    '''
    First, load the files HumanEyelessProtein and FruitflyEyelessProtein using 
    the provided code. These files contain the amino acid sequences that form 
    the eyeless proteins in the human and fruit fly genomes, respectively. Then 
    load the scoring matrix PAM50 for sequences of amino acids. This scoring 
    matrix is defined over the alphabet {A,R,N,D,C,Q,E,G,H,I,L,K,M,F,P,S,T,W,Y,
    V,B,Z,X,-} which represents all possible amino acids and gaps (the "dashes" 
    in the alignment).

    Next, compute the local alignments of the sequences of HumanEyelessProtein 
    and FruitflyEyelessProtein using the PAM50 scoring matrix and enter the 
    score and local alignments for these two sequences below. Be sure to 
    clearly distinguish which alignment is which and include any dashes ('-') 
    that might appear in the local alignment.
    '''

    human_protein = provided.read_protein(provided.HUMAN_EYELESS_URL)
    fruitfly_protein = provided.read_protein(provided.FRUITFLY_EYELESS_URL)
    scoring_matrix = provided.read_scoring_matrix(provided.PAM50_URL)

    alignment_matrix = project4.compute_alignment_matrix(
        human_protein, fruitfly_protein, scoring_matrix, False)

    local_alignment = project4.compute_local_alignment(human_protein,
                                                       fruitfly_protein,
                                                       scoring_matrix,
                                                       alignment_matrix)
    return local_alignment
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    '''
    Helper function for Question 4
    Takes as input two sequences seq_x and seq_y, a scoring matrix 
    scoring_matrix, and a number of trials num_trials. This function should 
    return a dictionary scoring_distribution that represents an un-normalized 
    distribution generated by performing the following process num_trials times:

    Generate a random permutation rand_y of the sequence seq_y using 
    random.shuffle().
    Compute the maximum value score for the local alignment of seq_x and rand_y 
    using the score matrix scoring_matrix.
    Increment the entry score in the dictionary scoring_distribution by one.
    '''

    scoring_distribution = {}
    trial = 0

    while trial < num_trials:
        seq_y_list = list(seq_y)
        random.shuffle(seq_y_list)
        rand_y = ''.join(seq_y_list)
        alignment_matrix = project4.compute_alignment_matrix(
            seq_x, rand_y, scoring_matrix, False)
        score = project4.compute_local_alignment(seq_x, rand_y, scoring_matrix,
                                                 alignment_matrix)
        if score[0] not in scoring_distribution:
            scoring_distribution[score[0]] = 1
        else:
            scoring_distribution[score[0]] += 1
        trial += 1
        print trial

    return scoring_distribution
def question1():
    """
    Code for quetion 1
    """
    human = read_protein(HUMAN_EYELESS_URL)
    fruitfly = read_protein(FRUITFLY_EYELESS_URL)
    score_mat = read_scoring_matrix(PAM50_URL)
    align_mat = compute_alignment_matrix(human, fruitfly, score_mat, False)
    result = compute_local_alignment(human, fruitfly, score_mat, align_mat)
    return result
Пример #8
0
def question1():
    # QUESTION 1
    align_matrix = project4.compute_alignment_matrix(fruitfly_protein, human_protein, scores, False)
    local_alignment_eyeless = project4.compute_local_alignment(fruitfly_protein, human_protein, scores, align_matrix) 
    #
    #for each in local_alignment_eyeless:
    #    print each

    #print local_alignment_eyeless[0]
    local_human = local_alignment_eyeless[2]
    local_fruitfly = local_alignment_eyeless[1]
Пример #9
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    distribution = {}
    bar = progressbar.ProgressBar(max_value=1000)
    for progress in range(num_trials):
        bar.update(progress)
        rand_y = list(seq_y)
        random.shuffle(rand_y)
        alignment_matrix = project4.compute_alignment_matrix(seq_x, rand_y, scoring_matrix, False)
        score = project4.compute_local_alignment(seq_x, rand_y, scoring_matrix, alignment_matrix)[0]
        distribution[score] = distribution.get(score,0) + 1
    save_dict(distribution)
    return distribution
Пример #10
0
def question1():
    # QUESTION 1
    align_matrix = project4.compute_alignment_matrix(fruitfly_protein,
                                                     human_protein, scores,
                                                     False)
    local_alignment_eyeless = project4.compute_local_alignment(
        fruitfly_protein, human_protein, scores, align_matrix)
    #
    #for each in local_alignment_eyeless:
    #    print each

    #print local_alignment_eyeless[0]
    local_human = local_alignment_eyeless[2]
    local_fruitfly = local_alignment_eyeless[1]
Пример #11
0
def align_eyeless(scoring_matrix):
    """
    compute the local alignment and score of the human eyeless AA sequence and
    the drosophila eyeless AA sequence, using the PAM 50 scoring matrix
    """
    # load eyeless AA strings 
    human = read_protein(HUMAN_EYELESS_URL)
    drosophila = read_protein(FRUITFLY_EYELESS_URL)
    
    # compute local alignment matrix
    la_mtrx = seq.compute_alignment_matrix(human, drosophila, scoring_matrix, False)
    
    # compute local alignment
    return seq.compute_local_alignment(human, drosophila, scoring_matrix, la_mtrx)
Пример #12
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
   '''
   1) Generate a random permutation 'rand_y' of the sequence seq_y
   2) Compute the maximum value 'score' for the local alignment of seq_x and rand_y using the score matrix 'scoring_matrix'

   Return local alignment score
   '''
   temp = list(seq_y)
   random.shuffle(temp)
   seq_y = ''.join(temp)

   local_alignment_matrix = project4.compute_alignment_matrix(seq_x, seq_y, scoring_matrix, False)
   local_alignment = project4.compute_local_alignment(seq_x, seq_y, scoring_matrix, local_alignment_matrix)
   return local_alignment[0]
Пример #13
0
def question_1():
    human = read_protein(HUMAN_EYELESS_URL)
    fly = read_protein(FRUITFLY_EYELESS_URL)

    scoring_matrix = read_scoring_matrix(PAM50_URL)

    alignment_matrix = project4.compute_alignment_matrix(human, fly, scoring_matrix, False)

    answer = project4.compute_local_alignment(human, fly, scoring_matrix, alignment_matrix)

    print "score =", answer[0]
    print "align human = ", answer[1]
    print "align fly = ", answer[2]

    return answer[0]
Пример #14
0
def question_2():

    human = read_protein(HUMAN_EYELESS_URL)
    fly = read_protein(FRUITFLY_EYELESS_URL)
    consensus = read_protein(CONSENSUS_PAX_URL)

    scoring_matrix = read_scoring_matrix(PAM50_URL)

    alignment_matrix_local = project4.compute_alignment_matrix(human, fly, scoring_matrix, False)

    local_aligns = project4.compute_local_alignment(human, fly, scoring_matrix, alignment_matrix_local)

    human_local_align = local_aligns[1]
    fly_local_align = local_aligns[2]

    human_no_dashes = human_local_align.replace('-','')
    fly_no_dashes = fly_local_align.replace('-','')

    global_matrix_human_consensus = project4.compute_alignment_matrix(human_no_dashes, consensus, scoring_matrix,True)
    global_matrix_fly_consensus = project4.compute_alignment_matrix(fly_no_dashes,consensus, scoring_matrix, True)

    global_align_human_consensus = project4.compute_global_alignment(human_no_dashes,consensus,scoring_matrix,global_matrix_human_consensus)
    align_global_human = global_align_human_consensus[1]

    global_align_fly_consensus = project4.compute_global_alignment(fly_no_dashes, consensus,scoring_matrix,global_matrix_fly_consensus)
    align_global_fly = global_align_fly_consensus[1]

    count_human = 0
    count_fly = 0

    #print align_global_human
    #print align_global_fly
    #print consensus

    for pair in zip(align_global_human, consensus):
        if pair[0] == pair[1]:
            count_human += 1.
    for pair in zip(align_global_fly,consensus):
        if pair[0] == pair[1]:
            count_fly += 1.

    human_percentage = (count_human / len(align_global_human)) * 100
    fly_percentage = (count_fly / len(align_global_fly)) * 100

    print "human percentage: ", human_percentage
    print "fly percentage: ", fly_percentage
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    Calculate a dictionary scoring_distribution that represents
    an un-normalized distribution generated by performing the following
    process num_trials times:

    Generate a random permutation rand_y of the sequence seq_y
    using random.shuffle().
    Compute the maximum value score for the local alignment of
    seq_x and rand_y using the score matrix scoring_matrix.
    Increment the entry score in the dictionary scoring_distribution by one.

    Parameters
    ----------
    seq_x: str
    a sequence

    seq_y: str
    another sequence

    scoring_matrix: dict of dicts
    the scoring matrix

    num_trials: int
    the number of trials


    Returns
    -------
    scoring_distribution: dict
    a dictionary scoring_distribution that represents
    an un-normalized distribution
    """
    scoring_distribution = defaultdict(int)
    for _ in range(num_trials):
        rand_y = list(seq_y)
        shuffle(rand_y)
        align_mat = compute_alignment_matrix(seq_x, rand_y,
                                             scoring_matrix, False)
        alignment = compute_local_alignment(seq_x, rand_y,
                                            scoring_matrix, align_mat)
        score = alignment[0]
        scoring_distribution[score] += 1
    return scoring_distribution
def question1():
    """
    Compute the local alignments of the sequences of HumanEyelessProtein and
    FruitflyEyelessProtein using the PAM50 scoring matrix.
    """
    # Compute local alignments.
    alignment_matrix = project4.compute_alignment_matrix(HUMAN,
                                                         FLY,
                                                         SCORING_MATRIX,
                                                         global_flag=False)
    local_alignment = project4.compute_local_alignment(HUMAN, FLY,
                                                       SCORING_MATRIX,
                                                       alignment_matrix)
    align_human = local_alignment[1]
    align_fly = local_alignment[2]
    print "Human local alignment:", align_human
    print "Fruit fly local alignment:", align_fly
    print "score:", local_alignment[0]
    return (local_alignment[0], align_human, align_fly)
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    Returns a dictionary scoring_distribution that represents an 
    un-normalized distribution based on the given number of trials num_trials.
    """
    scoring_distribution = {}
    for dummy in range(num_trials):
        y_list = list(seq_y)
        random.shuffle(y_list)
        rand_y = ''.join(y_list)
        alignment_matrix = project4.compute_alignment_matrix(
            seq_x, rand_y, scoring_matrix, False)
        score = project4.compute_local_alignment(seq_x, rand_y, scoring_matrix,
                                                 alignment_matrix)[0]
        if score in scoring_distribution.keys():
            scoring_distribution[score] = scoring_distribution[score] + 1
        else:
            scoring_distribution[score] = 1
    return scoring_distribution
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    generate null distribution of amino acid at specific position
    :param seq_x: seq_x
    :param seq_y: seq_y
    :param scoring_matrix:  scoring matrix
    :param num_trials: number of trials
    :return: a dictionary of scoring_distribution
    """
    scoring_distr= {}
    for i in xrange(1, num_trials+1):
        # random seq from seq_y
        rand_y = ''.join(random.sample(seq_y, len(seq_y)))

        alignment_matrix = student.compute_alignment_matrix(seq_x, rand_y, scoring_matrix, False)
        result = student.compute_local_alignment(seq_x, rand_y, scoring_matrix, alignment_matrix)

        scoring_distr[i]= result[0]

    return scoring_distr
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    """
    generate null distribution of amino acid at specific position
    :param seq_x: seq_x
    :param seq_y: seq_y
    :param scoring_matrix:  scoring matrix
    :param num_trials: number of trials
    :return: a dictionary of scoring_distribution
    """
    scoring_distr= {}
    for i in xrange(1, num_trials+1):
        # random seq from seq_y
        rand_y = ''.join(random.sample(seq_y, len(seq_y)))

        alignment_matrix = student.compute_alignment_matrix(seq_x, rand_y, scoring_matrix, False)
        result = student.compute_local_alignment(seq_x, rand_y, scoring_matrix, alignment_matrix)

        scoring_distr[i]= result[0]

    return scoring_distr
Пример #20
0
def generate_null_distribution(seq_x, seq_y, scoring_matrix, num_trials):
    distr = {
    }  # store the whole distribution {score1: count1, score2: count2, ..., scoren: countn}
    raw = [
    ]  # store all the scores: [score1, score2, ..., scoren], could be duplicate

    for _ in range(num_trials):
        temp = list(seq_y)
        shuffle(temp)
        rand_y = ''.join(temp)
        align_matrix = compute_alignment_matrix(
            seq_x, rand_y, scoring_matrix,
            False)  # Returns local alignment matrix.
        score, _, _ = compute_local_alignment(seq_x, rand_y, scoring_matrix,
                                              align_matrix)
        if score not in distr:
            distr[score] = 0
        distr[score] += 1
        raw.append(score)
    return distr, raw
Пример #21
0
def question1And2():
    human = read_protein(HUMAN_EYELESS_URL)
    fly = read_protein(FRUITFLY_EYELESS_URL)
    print(len(human), len(fly))

    scoring = read_scoring_matrix(PAM50_URL)
    local_align_matrix = compute_alignment_matrix(human, fly, scoring, False)
    score, xs, ys = compute_local_alignment(human, fly, scoring,
                                            local_align_matrix)
    print('Question 1')
    print('The score of the local alignment is: ', score)
    print('The sequence for the HumanEyelessProtein is: ', xs)
    print('The sequence for the FruitflyEyelessProtein is: ', ys)
    print()

    print('Question2')
    consensus = read_protein(CONSENSUS_PAX_URL)

    # Step1: Delete any dashes '-' present in the sequence.
    human_nodash = ''.join([x for x in xs if x != '-'])
    fly_nodash = ''.join([y for y in ys if y != '-'])

    # Step2: Compute the global alignment of this dash-less sequence with the ConsensusPAXDomain sequence.
    hc_global_align_matrix = compute_alignment_matrix(human_nodash, consensus,
                                                      scoring, True)
    fc_global_align_matrix = compute_alignment_matrix(fly_nodash, consensus,
                                                      scoring, True)

    # Step3: Compare corresponding elements of these two globally-aligned sequences (local vs consensus) and
    # compute the percentage  of elements in these two sequences that agree
    # NOTE: func agreement contains Stpe2 and Step3.
    hc_agree = agreement(human_nodash, consensus, scoring,
                         hc_global_align_matrix)
    fc_agree = agreement(fly_nodash, consensus, scoring,
                         fc_global_align_matrix)

    print('Human vs Consensus agree = %s%%' % hc_agree)
    print('Fly vs Consensus agree = %s%%' % fc_agree)
Пример #22
0
def generate_null_distribution(seq_x, seq_y,scoring_matrix, num_trials):

    scoring_distribution = {}
    scores_list = []

    for i in range(num_trials):
        temp = list(seq_y)
        random.shuffle(temp)
        rand_y = ''.join(temp)

        align_matrix = project4.compute_alignment_matrix(seq_x, rand_y, scoring_matrix, False)

        local_align = project4.compute_local_alignment(seq_x, rand_y, scoring_matrix, align_matrix)

        score = local_align[0]

        if score not in scoring_distribution:
            scoring_distribution[score] = 0

        scoring_distribution[score] += 1
        scores_list.append(score)

    return scoring_distribution, scores_list
Пример #23
0
def compare(n, nh, nf, alpha, cons, scoring, align):
    '''
	n: number of trials
	nh: number of characters chosen from alpha and assign to x
	nf: number of characters chosen from alpha and assing to y
	alpha: original string set: alpha = 'ACBEDGFIHKMLNQPSRTWVYXZ'
	cons: Consensus strings 
	scoring: scoring matrix for alpha
	align: alignment matrix????? What is this? Somthing wrong??
	'''
    ag1, ag2 = [], []
    for i in range(n):
        x, y = rprot(nh, alpha), rprot(nf, alpha)
        _, xs, ys = compute_local_alignment(x, y, scoring, align)
        xs_nodash = ''.join([x for x in xs if x != '-'])
        ys_nodash = ''.join([y for y in ys if y != '-'])
        ag1.append(agreement(xs_nodash, cons, scoring, align))
        ag2.append(agreement(ys_nodash, cons, scoring, align))

    hc_agree = sum(ag1) / float(n)
    fc_agree = sum(ag2) / float(n)

    print('Random Human vs Consensus agree = %s%%' % hc_agree)
    print('Random Fly vs Consensus agree = %s%%' % fc_agree)
    A string representing the protein
    """
    protein_file = urllib2.urlopen(filename)
    protein_seq = protein_file.read()
    protein_seq = protein_seq.rstrip()
    return protein_seq


# Q1
#compute_local_alignment(seq_x, seq_y, scoring_matrix, alignment_matrix)
seq_fly = read_protein(FRUITFLY_EYELESS_URL)
seq_human = read_protein(HUMAN_EYELESS_URL)
score_matrix = read_scoring_matrix(PAM50_URL)
alignment_matrix = student.compute_alignment_matrix(seq_human, seq_fly, score_matrix, False)

result = student.compute_local_alignment(seq_human, seq_fly, score_matrix, alignment_matrix)
#print result[0]
#human
#print result[1]
#fly
#print result[2]


# Q2
seq_pax = read_protein(CONSENSUS_PAX_URL)

#fly and pax domain
# alignment_matrix_global = student.compute_alignment_matrix(result[2], seq_pax, score_matrix, True)
# result2 = student.compute_global_alignment(result[2], seq_pax, score_matrix, alignment_matrix_global)
#print result2[0]
#print result2[1]
Пример #25
0
def align_human_fly_protein():
    alignment_matrix = project4.compute_alignment_matrix(protein_human, protein_fly, scoring_matrix, False)
    result = project4.compute_local_alignment(protein_human, protein_fly, scoring_matrix, alignment_matrix)

    return result
    # template lines and solution lines list of line string
    word_list = words.split('\n')
    print "Loaded a dictionary with", len(word_list), "words"
    return word_list


# question 1
scoring_matrix = read_scoring_matrix(PAM50_URL)
seq_x = read_protein(HUMAN_EYELESS_URL)
seq_y = read_protein(FRUITFLY_EYELESS_URL)
consensusseq = read_protein(CONSENSUS_PAX_URL)

alignment_matrix = student.compute_alignment_matrix(seq_x, seq_y,
                                                    scoring_matrix, False)
score, string_Hu, string_Fr = student.compute_local_alignment(
    seq_x, seq_y, scoring_matrix, alignment_matrix)
print string_Hu

newstring_Hu = ""
for elem in string_Hu:
    if elem != '-':
        newstring_Hu += elem
print newstring_Hu
newstring_Fr = ""
for elem in string_Fr:
    if elem != '-':
        newstring_Fr += elem

alignment_matrix_Hum_local_Con = student.compute_alignment_matrix(
    newstring_Hu, consensusseq, scoring_matrix, True)
score1, str_Hu_Con, str_Con_Hu = student.compute_global_alignment(
Пример #27
0

def read_words(filename):
    """
    Load word list from the file named filename.

    Returns a list of strings.
    """
    # load assets
    word_file = urllib2.urlopen(filename)

    # read in files as string
    words = word_file.read()

    # template lines and solution lines list of line string
    word_list = words.split('\n')
    print "Loaded a dictionary with", len(word_list), "words"
    return word_list


HUMAN_EYELESS_PROTEIN = read_protein(HUMAN_EYELESS_URL)
FRUITFLY_EYELESS_PROTEIN = read_protein(FRUITFLY_EYELESS_URL)
PAM50_SCORING_MATRIX = read_scoring_matrix(PAM50_URL)
PAM50_ALIGNMENT_MATRIX = student.compute_alignment_matrix(
    HUMAN_EYELESS_PROTEIN, FRUITFLY_EYELESS_PROTEIN, PAM50_SCORING_MATRIX,
    False)
print student.compute_local_alignment(HUMAN_EYELESS_PROTEIN,
                                      FRUITFLY_EYELESS_PROTEIN,
                                      PAM50_SCORING_MATRIX,
                                      PAM50_ALIGNMENT_MATRIX)
Пример #28
0
    """
    protein_file = urllib2.urlopen(filename)
    protein_seq = protein_file.read()
    protein_seq = protein_seq.rstrip()
    return protein_seq


# Q1
#compute_local_alignment(seq_x, seq_y, scoring_matrix, alignment_matrix)
seq_fly = read_protein(FRUITFLY_EYELESS_URL)
seq_human = read_protein(HUMAN_EYELESS_URL)
score_matrix = read_scoring_matrix(PAM50_URL)
alignment_matrix = student.compute_alignment_matrix(seq_human, seq_fly,
                                                    score_matrix, False)

result = student.compute_local_alignment(seq_human, seq_fly, score_matrix,
                                         alignment_matrix)
#print result[0]
#human
#print result[1]
#fly
#print result[2]

# Q2
seq_pax = read_protein(CONSENSUS_PAX_URL)

#fly and pax domain
# alignment_matrix_global = student.compute_alignment_matrix(result[2], seq_pax, score_matrix, True)
# result2 = student.compute_global_alignment(result[2], seq_pax, score_matrix, alignment_matrix_global)
#print result2[0]
#print result2[1]
#print result2[2]