IGEM:Harvard/2006/Container Design 4/Python Code

• Full Code - Finalized 7/11
  
• Split Scaffold
• Oligo Splitting
  

Pickle Split Parameters

### split = [[oligo_num, num_tokens for oligo_1 - from 5prime], ... ]

import pickle

fout_barrel = None
fout_lid = None

try:
        fout_barrel = open("barrel_oligos_to_split.txt", "w")
        fout_lid = open("lid_oligos_to_split.txt", "w")
except IOError, e:
        print "Error in file IO: ", e

barrel_split = [[56, 2], [57, 3], [41, 3], [26, 3], [21, 4]]
lid_split = [[27, 4], [2, 4]]

pickle.dump(barrel_split, fout_barrel)
pickle.dump(lid_split, fout_lid)

# clean up if they're open
if fout_barrel:
        fout_barrel.close()
if fout_lid:
        fout_lid.close()

Add aptamers

#######
# Add aptamers to the ends of the appropriate oligos.
#######

# Constants
apt_seq = 'GGTTGGTGTGGTTGG'
T_linker = 'TTT'
        
print oligo_ra
num_aptamers = int(raw_input('How many aptamers do you want to add? '))
i = 0   
while i < num_aptamers:
        oligo_num = int(raw_input('Which oligo needs an aptamer? '))
        if oligo_num < len(oligo_ra):
                # Add the aptamer to that oligo
                oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq
                i = i + 1
        else:
                print 'oligo ' + str(oligo_num) + ' out of range.'

print oligo_ra

Add aptamers using File Input rather than User Input

#####
# Add apts this time using file input instead of user input
#####
                        
# Constants
apt_seq = 'GGTTGGTGTGGTTGG'
T_linker = 'TTT'
                        
fin_barrel = None
                        
try:
        fin_barrel = open("barrel_apts_to_add.txt", "r")
except IOError, e:
        print "Error in file IO: ", e

# Ask the user if they are running a lid or a barrel
shape = int(raw_input("Enter 1 if you are running a barrel, 2 if lid: "))
if (shape == 1):   
        apts_to_add = pickle.load(fin_barrel)
        for apt_specs in apts_to_add:
                oligo_num = apt_specs[0]
                type = apt_specs[1]
                if (type == 1):
                        # apt is pointing in so add 'I' as a flag at the end
                        oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq + 'I'
                elif(type == 2):
                        # apt is pointing out so add 'O' as a flag
                        oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq + 'O'
                else:
                        # incorrect type
                        print 'Bad input - aptamer needs to be pointing in or out'

Print Aptamer Oligos

Oligo sorting - find an print out those with aptamers

#####   
# oligo sorting
#####

# sort based on whether or not there's an aptamer attached to the end of
# an oligo
        
apt = re.compile('TTTGGTTGGTGTGGTTGG')
oligo_num = 0
for oligo in oligo_ra:   
        m = apt.search(oligo)
        if m:
                print 'Match found: ', oligo + ' : ' + str(oligo_num)
        else: 
                print 'No match' + str(oligo_num)
        oligo_num = oligo_num + 1

Modifications to honeycomb_v1 scripts

• Modifications to William's program to print each oligo number next to what tokens it represents

oligo_num = 0
for oligo in OTP_ra:
        for token in oligo:
                print str(oligo_num) + ": ", token
        oligo_num = oligo_num + 1

• Modifications to William's program to print a grid of oligo numbers completely filled in
• add this part to main (AAA or BBB)

####
# generate and print the oligo grid
####

# Initialize the grid with all periods
num_strands = len(TPP_ra)
num_subzones = len(TPP_ra[0])

sub_token_visit_ra = ['.' for subzone_num in range(num_subzones)]
grid_ra = [sub_token_visit_ra[:] for strand_num in range(num_strands)]
        
oligo_num = 0
for oligo in OTP_ra:
        grid_ra = generate_oligo_path(oligo, oligo_num, grid_ra)
        oligo_num = oligo_num + 1
print grid_ra
        
print_all_oligos(grid_ra, num_strands, num_subzones)

• add this part to honeycomb_pointers_v1.py

# The idea here is to have a function that adds the numbers of one oligo path
# to the appropriate places in the big grid array. Eventually this will be printed
# in main. Also it needs to be initialized in main. Oligo_path is the path of
# one oligo, while grid_ra is the grid that is constantly being updated until 
# it is printed in main. oligo_num is number that will be inputed to the grid_ra.
                        
def generate_oligo_path(oligo_path, oligo_num, grid_ra):
        num_path_tokens = len(oligo_path)
                
# Assign visits
        for path_token_num in range(num_path_tokens):
                token = oligo_path[path_token_num]
                strand = token[0]
                subzone = token[1]
                grid_ra[strand][subzone] = oligo_num
        
        
        return grid_ra

def print_all_oligos(grid_ra, num_strands, num_subzones):
        spacer = '   '
        for strand_num in range(num_strands):
                for subzone_num in range(num_subzones):
                        visitor_string = str(grid_ra[strand_num][subzone_num])   
                        sys.stdout.write(visitor_string)
                        sys.stdout.write(spacer[:4 - len(visitor_string)])
                sys.stdout.write('\n')