Ok. We saw last time that the function which searches for the enzyme sites returns a tuple with the actual sites and positions. Why is it better to return sites and positions? Because one enzyme can have multiple sites and you might want to know where are they. Also, it helps us practice some Python skills.

We will start by the last piece, and part of it we already saw before.

if isname:
    print 'Name found'
    sequences = fasta.read_fasta(open(sys.argv[2], 'r').readlines())
    for item in sequences:
        sites, positions = find_sites(enzyme, enzymeset, item.sequence)
        print item.name[:20]+'...'
        for i in zip(sites, positions):
            print i[0], '->', i[1]
else:
    print 'Enzyme name not found, please try again'

This is the if that checks to see if the input enzyme name was found in the list. Clearly we added a couple of things. Already covered here, ff isname is true we go and read the sequence file, which can contain a single or multiple sequences. We start a loop and call the find_sites and expect the return on a tuple sites, positions. Next line, we print the sequence name for the output. And then …

Yes, and then we have something new: zip. This is a function that returns a list of tuples from each one of the arguments passed to it. In our case we are passing two lists (sites and positions) and we know that each site has one position, and we also know that because of the way we build both lists the i-th element in sites will be equivalent to the i-th element in positions. Using zip we create n tuples where the i-th tuple is equivalent to the i-th element in sites and the i-th element in positions. Confused?

Let’s see. Imagine that sites has is composed of

['AAA', 'AAC', 'ACA', 'TAA']

and positions is composed of

['300', '454', '23', '345']

and we want to ouput this

AAA -> 300
AAC -> 454
ACA -> 23
TAA -> 345

The first idea that comes to mind is to do a loop, with a range as we already know that both lists will have the same size. Something in the lines of

for i in range(len(positions)):
    print sites[i], '->', positions[i]

and it will work fine and it is not that long (codewise). zip might not be an advantage here, but it will be somewhere else, for sure. We print the results and we are done. The full code will be posted in the repository soon. Next we will move to the book’s chapter 10 and we start a new section here, checking for GenBank files.

def find_sites(input, set, sequence):
    iupacdict = {'A':'[A]',
    'C':'[C]',
    'G':'[G]',
    'T':'[T]',
    'M':'[AC]',
    'R':'[AG]',
    'W':'[AT]',
    'S':'[CG]',
    'Y':'[CT]',
    'K':'[GT]',
    'V':'[ACG]',
    'H':'[ACT]',
    'D':'[AGT]',
    'B':'[CGT]',
    'X':'[ACGT]',
    'N':'[ACGT]'}

    site = set[input]
    pattern = ''
    positions = []
    for i in site:
        pattern += iupacdict[i]
    searchpattern = re.compile(pattern)
    sites = searchpattern.findall(sequence)
    temppos = searchpattern.finditer(sequence)
    for i in temppos:
        begin, end = i.span()
        positions.append(begin)

    return sites, positions

We use the IUPAC dictionary created previously to translate the nucleotides entries in the restriction enzyme file. The function also receives three values: the input name of the selected enzyme, the dictionary with all the enzymes and sites and the sequence where to search. We could easily remove one of those, but let’s leave it there.

First we get the site from the dictionary and initialize an empty string to receive the patter and a empty list to receive the positions. We will see why we don’t need an empty list to store the found sites. We then iterate over the site and create a pattern using the values for each letter of the site (dictionary key). Created the patter, we compile the regex and with findall we find every entry of the site in the sequence. As we already have seen, using the regex findall will generate a list with all the entries for that particular regex in the string we are searching. This is pretty handy because some enzymes have degenerated restriction sites. That’s why we don’t need a pre-initialized empty list for the sites.

Then we use the finditer to find the the exact position of each one of the sites. Each iterator is a tuple with a start and end positions. In our case we only need the start position, so in a small loop we iterate over the temporary variable and just append to the positions empty list the start value. We have two integers, begin and end that receive the values from i.span, but we only use begin.

The function then returns two lists as a tuple: one for the sites and one for the positions. If our programming is correct, both lists should have the same size and are ready to generate the output.

def read_enzymes(file):
    resenz = {}
    start = False
    for line in file:
        if line.find('Rich Roberts') >= 0:
            start = True
            line = file.next()
        if start == True and len(line) > 10:</pre>
            buffer = line.split()
            resenz[buffer[0]] = buffer[-1].replace('^', '')

    return resenz

We now need a function to write a function that searches for the sites and a main function that accepts the parameters, coordinate the search and return the results. Looks like we are more than halfway there.

Parameters input was shown before, starting on section 3. We import the sys module and use the array inside sys.argv to send the parameters to the script. A basic skeleton of our main function would look like this

import sys
import re
import fasta

#reading the ezyme dataset in one line and storing
#enzyme information in enzymeset
enzymeset = read_enzymes(open('bionet.709', 'r'))

#storing enzyme name on a string
enzyme = sys.argv[1]
#reading a FASTA file and sotring the sequences
sequence = fasta.get_seqs(open(sys.argv[2], 'r').readlines())

That’s a start. Now we have to write a function that will check for the enzyme name entered by the user in order to check for the existence of such enzyme. Something like this would work

def check_enzyme(input, set):
    if set.has_key(input):
        return True
    else:
        return False

This basically tests of the dictionary contains the name entered. If yes then we return True, otherwise False is returned. This changes our main script body

import sys
import re
import fasta

#reading the ezyme dataset in one line and storing
#enzyme information in enzymeset
enzymeset = read_enzymes(open('bionet.709', 'r'))

#storing enzyme name on a string
enzyme = sys.argv[1]
#check if the name entered is valid
isname = check_enzyme(enzyme, enzymeset)

#if it is valid, continue, otherwise abort
if isname:
    #reading a FASTA file and sotring the sequences
    sequence = fasta.get_seqs(open(sys.argv[2], 'r').readlines())</pre>
else:
    print 'Name invalid. Please try again.'

So, we have a good idea on what to do now. We just need a function that creates a regular expression and searches it on the sequence. Next time …

How to write use cases or design UML is not a subject taught in many biology courses, so we won;t see much of the theory here. Consider this a more informal way of planning a small script or application.

First thing would be to set a goal:

What is the main objective of our script?

Create a simple restriction enzyme map of certain sequences

Next,

what do we need to make the program work?

We need restriction enzyme information, such as names and sites and a sequence.

That leads us

How do I store information?

Restriction enzyme data (last entry) obtained from a file can be stored in a dictionary, with the enzyme name as key and the site as value. Sequences are stored using our fasta class.

This will brings us to one important issue

How to interact with the user?

The ideal way would be to present a list of enzymes for the user to select, but we do not have a graphical interface to organize it nicely. So, we will ask the user to enter the name of enzyme and a name of a file to read the sequence where the enzyme site should be found. We can do that interactively or by passing parameters to the script. We will do it by parameters here, but the interactive way can be tested as a homework for those following the blog.

And finally

What about an output?

We will do the same way as the book: a list of positions, indicating the restriction sites. I welcome other options in the comments.

It looks we have a plan. Let’s gather what we already have, and our previous knowledge and meet on the other side of this post.

This file looks like this:

AaaI (XmaIII) C^GGCCG
AacI (BamHI) GGATCC
AaeI (BamHI) GGATCC
AagI (ClaI) AT^CGAT
AanI (PsiI) TTA^TAA
AaqI (ApaLI) GTGCAC

where the first column contains the enzyme names and the second column has the actual cleavage sites. It won’t be difficult to parse this file and create a dictionary with the names and sites, but it would be easier if the file the data was tab-separated, but it is nothing we will have problem dealing with. The file also has some header lines which we will have to avoid.

Next entry will deal with user cases and some other aspects of coding, as we head to our most complex script until now. Noe we will only create a function that reads the file and generates the dictionary, what sounds very simple.

There are two ways (maybe even more) to discard the header lines: progamatically or actively deleting such lines. We won’t delete the lines this time, so we have to follow the other path. The easiest way to eliminate header lines from our parsing function would be to count the lines and start the parsing procedure after that certain number but that would mean a high confidence of the format being constant in every release.

So, first we get rid of the header lines

def read_enzymes(file):
    resenz = {}
    start = False
    for line in file:
        if line.find('Rich Roberts') >= 0:
            start = True
            line = file.next()
        if start == True and len(line) > 10:

where we already declared the dictionary that will receive the name and sites. We have a flag boolean that tells the script where the actual enzyme list starts (start), declared as false and then modified to true when the line containing Rich Roberts is found. The line line = file.next() tells the script that the current line is equal to the next line of the file. We do this to avoid starting the parsing of the file at the line we found Rich Roberts. the if statement checks for the line size in order to split and parse only the actual lines and discard empty ones.

Now, in order to get the sites and enzyme names we will use split, differently than we used before. This time we won’t pass any arguments to split as a separator. This will trigger another type of splitting procedure, where some characters will be stripped from the string (spaces, tabs, newlines, returns, and formfeeds) and the resulting words will be then separated by arbitrary length strings of whitspaces. Basicall this split will return a list with the words in that particular line.

Inpecting the file carefully, we notice that some enzyme names have an extra id between parentheses. We will not consider this extra id. After splitting we will get the first and last elements of the list and put them in our dictionary.

buffer = line.split()
resenz[buffer[0]] = buffer[-1].replace('^', '')

Done. We have the dictionary ready. And using Python’s included batteries we use the last line in the function to remove the circumflex characters. Putting everything together we have

def read_enzymes(file):
    resenz = {}
    start = False
    for line in file:
        if line.find('Rich Roberts') >= 0:
            start = True
            line = file.next()
        if start == True and len(line) > 10:
            buffer = line.split()
            resenz[buffer[0]] = buffer[-1].replace('^', '')

iupacdict = {'M':'[AC]',
	'R':'[AG]',
	'W':'[AT]',
	'S':'[CG]',
	'Y':'[CT]',
	'K':'[GT]',
	'V':'[ACG]',
	'H':'[ACT]',
	'D':'[AGT]',
	'B':'[CGT]',
	'X':'[ACGT]',
	'N':'[ACGT]'}

and the same consensus sequence of the GATA3 binding site

NNGATARNG

This consensus sequence will be provided as a script parameter, along with the filename

import sys
import re
sequencefile = open(sys.argv[1], 'r').readlines()
motif = sys.argv[2]

First line reads the sequence file from the user input and second line stores the input motif in a string. Now we have to get the motif string and check for each letter (IUPAC code) and get the correspondent set of nucleotides. For this we will use a loop and a the method get method of Python dictionaries. This method, as its name implies, gets the value of the key in parentheses. Like this

for n in motif:
    iupacdict.get(n)

[ACGT]
[ACGT]
[AG]
[ACGT]

iupacdict = {'A':'A',
	'C':'C',
	'G':'G',
	'T':'T',
	'M':'[AC]',
	'R':'[AG]',
	'W':'[AT]',
	'S':'[CG]',
	'Y':'[CT]',
	'K':'[GT]',
	'V':'[ACG]',
	'H':'[ACT]',
	'D':'[AGT]',
	'B':'[CGT]',
	'X':'[ACGT]',
	'N':'[ACGT]'}

mregex = ''
for n in motif:
    mregex += iupacdict.get(n)

print mregex #just to check

tosearch = re.compile(str(mregex))
for i in tosearch.findall(sequencefile):
    print i