Back to index

python-biopython  1.60
Public Member Functions | Public Attributes
Bio.Restriction._Update.RestrictionCompiler.DictionaryBuilder Class Reference

List of all members.

Public Member Functions

def __init__
def build_dict
def install_dict
def no_install
def lastrebasefile
def parseline
def removestart
def getblock
def get
def information_mixer

Public Attributes

 rebase_pass
 proxy

Detailed Description

Definition at line 362 of file RestrictionCompiler.py.


Constructor & Destructor Documentation

def Bio.Restriction._Update.RestrictionCompiler.DictionaryBuilder.__init__ (   self,
  e_mail = '',
  ftp_proxy = '' 
)
DictionaryBuilder([e_mail[, ftp_proxy]) -> DictionaryBuilder instance.

If the emboss files used for the construction need to be updated this
class will download them if the ftp connection is correctly set.
either in RanaConfig.py or given at run time.

e_mail is the e-mail address used as password for the anonymous
ftp connection.

proxy is the ftp_proxy to use if any.

Definition at line 364 of file RestrictionCompiler.py.

00364 
00365     def __init__(self, e_mail='', ftp_proxy=''):
00366         """DictionaryBuilder([e_mail[, ftp_proxy]) -> DictionaryBuilder instance.
00367 
00368         If the emboss files used for the construction need to be updated this
00369         class will download them if the ftp connection is correctly set.
00370         either in RanaConfig.py or given at run time.
00371         
00372         e_mail is the e-mail address used as password for the anonymous
00373         ftp connection.
00374 
00375         proxy is the ftp_proxy to use if any."""
00376         self.rebase_pass = e_mail or config.Rebase_password
00377         self.proxy = ftp_proxy or config.ftp_proxy
    

Member Function Documentation

DB.build_dict() -> None.

Construct the dictionary and build the files containing the new
dictionaries.

Definition at line 378 of file RestrictionCompiler.py.

00378 
00379     def build_dict(self):
00380         """DB.build_dict() -> None.
00381 
00382         Construct the dictionary and build the files containing the new
00383         dictionaries."""
00384         #
00385         #   first parse the emboss files.
00386         #
00387         emboss_e, emboss_r, emboss_s = self.lastrebasefile()
00388         #
00389         #   the results will be stored into enzymedict.
00390         #
00391         self.information_mixer(emboss_r, emboss_e, emboss_s)
00392         emboss_r.close()
00393         emboss_e.close()
00394         emboss_s.close()
00395         #
00396         #   we build all the possible type 
00397         #
00398         tdct = {}
00399         for klass in TypeCompiler().buildtype():
00400             exec klass.__name__ +'= klass'
00401             exec "tdct['"+klass.__name__+"'] = klass"
00402 
00403         #
00404         #   Now we build the enzymes from enzymedict
00405         #   and store them in a dictionary.
00406         #   The type we will need will also be stored.
00407         #
00408 
00409         for name in enzymedict:
00410             #
00411             #   the class attributes first:
00412             #
00413             cls = newenzyme(name)
00414             #
00415             #   Now select the right type for the enzyme.
00416             #
00417             bases = cls.bases
00418             clsbases = tuple([eval(x) for x in bases])
00419             typestuff = ''
00420             for n, t in tdct.iteritems():
00421                 #
00422                 #   if the bases are the same. it is the right type.
00423                 #   create the enzyme and remember the type
00424                 #
00425                 if t.__bases__ == clsbases:
00426                     typestuff = t
00427                     typename = t.__name__
00428                 continue
00429             #
00430             #   now we build the dictionaries.
00431             #
00432             dct = dict(cls.__dict__)
00433             del dct['bases']
00434             del dct['__bases__']
00435             del dct['__name__']# no need to keep that, it's already in the type.
00436             classdict[name] = dct
00437            
00438             commonattr = ['fst5', 'fst3', 'scd5', 'scd3', 'substrat',
00439                           'ovhg', 'ovhgseq','results', 'dna']
00440             if typename in typedict:
00441                 typedict[typename][1].append(name)
00442             else:
00443                 enzlst= []
00444                 tydct = dict(typestuff.__dict__)
00445                 tydct = dict([(k,v) for k,v in tydct.iteritems() if k in commonattr])
00446                 enzlst.append(name)
00447                 typedict[typename] = (bases, enzlst)
00448             for letter in cls.__dict__['suppl']:
00449                 supplier = suppliersdict[letter]
00450                 suppliersdict[letter][1].append(name)
00451         if not classdict or not suppliersdict or not typedict:
00452             print 'One of the new dictionaries is empty.'
00453             print 'Check the integrity of the emboss file before continuing.'
00454             print 'Update aborted.'
00455             sys.exit()
00456         #
00457         #   How many enzymes this time?
00458         #
00459         print '\nThe new database contains %i enzymes.\n' % len(classdict)
00460         #
00461         #   the dictionaries are done. Build the file 
00462         #
00463         #update = config.updatefolder
00464         
00465         update = os.getcwd()
00466         results = open(os.path.join(update, 'Restriction_Dictionary.py'), 'w')
00467         print 'Writing the dictionary containing the new Restriction classes.\t',
00468         results.write(start)
00469         results.write('rest_dict = {}\n')
00470         for name in sorted(classdict) :
00471             results.write("def _temp():\n")
00472             results.write("    return {\n")
00473             for key, value in classdict[name].iteritems() :
00474                 results.write("        %s : %s,\n" % (repr(key), repr(value)))
00475             results.write("    }\n")
00476             results.write("rest_dict[%s] = _temp()\n" % repr(name))
00477             results.write("\n")
00478         print 'OK.\n'
00479         print 'Writing the dictionary containing the suppliers datas.\t\t',
00480         results.write('suppliers = {}\n')
00481         for name in sorted(suppliersdict) :
00482             results.write("def _temp():\n")
00483             results.write("    return (\n")
00484             for value in suppliersdict[name] :
00485                 results.write("        %s,\n" % repr(value))
00486             results.write("    )\n")
00487             results.write("suppliers[%s] = _temp()\n" % repr(name))
00488             results.write("\n")
00489         print 'OK.\n'
00490         print 'Writing the dictionary containing the Restriction types.\t',
00491         results.write('typedict = {}\n')
00492         for name in sorted(typedict) :
00493             results.write("def _temp():\n")
00494             results.write("    return (\n")
00495             for value in typedict[name] :
00496                 results.write("        %s,\n" % repr(value))
00497             results.write("    )\n")
00498             results.write("typedict[%s] = _temp()\n" % repr(name))
00499             results.write("\n")
00500         #I had wanted to do "del _temp" at each stage (just for clarity), but
00501         #that pushed the code size just over the Jython JVM limit. We include
00502         #one the final "del _temp" to clean up the namespace.
00503         results.write("del _temp\n")
00504         results.write("\n")
00505         print 'OK.\n'
00506         results.close()
00507         return

Here is the call graph for this function:

Definition at line 890 of file RestrictionCompiler.py.

00890 
00891     def get(self, block):
00892         #
00893         #   take what we want from the block.
00894         #   Each block correspond to one enzyme.
00895         #   block[0] => enzyme name
00896         #   block[3] => methylation (position and type)
00897         #   block[5] => suppliers (as a string of single letter)
00898         #
00899         bl3 = block[3].strip() 
00900         if not bl3 : bl3 = False #  site is not methylable
00901         return (block[0].strip(), bl3, block[5].strip())

Here is the caller graph for this function:

Definition at line 881 of file RestrictionCompiler.py.

00881 
00882     def getblock(self, file, index):
00883         #
00884         #   emboss_r.txt, separation between blocks is //
00885         #
00886         take = itertools.takewhile
00887         block = [l for l in take(lambda l :not l.startswith('//'),file[index:])]
00888         index += len(block)+1
00889         return block, index

Here is the caller graph for this function:

Definition at line 902 of file RestrictionCompiler.py.

00902 
00903     def information_mixer(self, file1, file2, file3):
00904         #
00905         #   Mix all the information from the 3 files and produce a coherent
00906         #   restriction record.
00907         #     
00908         methfile = self.removestart(file1)
00909         sitefile = self.removestart(file2)
00910         supplier = self.removestart(file3)
00911         
00912         i1, i2= 0, 0
00913         try:
00914             while True:
00915                 block, i1 = self.getblock(methfile, i1)
00916                 bl = self.get(block)
00917                 line = (sitefile[i2].strip()).split()
00918                 name = line[0]
00919                 if name == bl[0]:
00920                     line.append(bl[1])  #   -> methylation
00921                     line.append(bl[2])  #   -> suppliers
00922                 else:
00923                     bl = self.get(oldblock)
00924                     if line[0] == bl[0]:
00925                         line.append(bl[1])
00926                         line.append(bl[2])
00927                         i2 += 1
00928                     else:
00929                         raise TypeError  
00930                 oldblock = block
00931                 i2 += 1
00932                 try:
00933                     line = self.parseline(line)
00934                 except OverhangError :          #   overhang error 
00935                     n = name                    #   do not include the enzyme
00936                     if not bl[2]:
00937                         print 'Anyway, %s is not commercially available.\n' %n
00938                     else:
00939                         print 'Unfortunately, %s is commercially available.\n'%n
00940 
00941                     continue 
00942                 #Hyphens can't be used as a Python name, nor as a
00943                 #group name in a regular expression.
00944                 name = name.replace("-","_")
00945                 if name in enzymedict:
00946                     #
00947                     #   deal with TaqII and its two sites.
00948                     #
00949                     print '\nWARNING :',
00950                     print name, 'has two different sites.\n'
00951                     other = line[0].replace("-","_")
00952                     dna = DNA(line[1])
00953                     sense1 = regex(dna.tostring())
00954                     antisense1 = regex(Antiparallel(dna))
00955                     dna = DNA(enzymedict[other][0])
00956                     sense2 = regex(dna.tostring())
00957                     antisense2 = regex(Antiparallel(dna))
00958                     sense = '(?P<'+other+'>'+sense1+'|'+sense2+')'
00959                     antisense = '(?P<'+other+'_as>'+antisense1+'|'+antisense2 + ')'
00960                     reg = sense + '|' + antisense 
00961                     line[1] = line[1] + '|' + enzymedict[other][0]
00962                     line[-1] = reg
00963                 #
00964                 #   the data to produce the enzyme class are then stored in
00965                 #   enzymedict.
00966                 #
00967                 enzymedict[name] = line[1:] #element zero was the name
00968         except IndexError:
00969             pass
00970         for i in supplier:
00971             #
00972             #   construction of the list of suppliers.
00973             #
00974             t = i.strip().split(' ', 1)
00975             suppliersdict[t[0]] = (t[1], [])
00976         return
00977 
00978     

Here is the call graph for this function:

Here is the caller graph for this function:

DB.install_dict() -> None.

Install the newly created dictionary in the site-packages folder.

May need super user privilege on some architectures.

Definition at line 508 of file RestrictionCompiler.py.

00508 
00509     def install_dict(self):
00510         """DB.install_dict() -> None.
00511 
00512         Install the newly created dictionary in the site-packages folder.
00513 
00514         May need super user privilege on some architectures."""
00515         print '\n ' +'*'*78 + ' \n'
00516         print '\n\t\tInstalling Restriction_Dictionary.py'
00517         try:
00518             import Bio.Restriction.Restriction_Dictionary as rd
00519         except ImportError:
00520             print '\
00521             \n Unable to locate the previous Restriction_Dictionary.py module\
00522             \n Aborting installation.'
00523             sys.exit()
00524         #
00525         #   first save the old file in Updates
00526         #
00527         old = os.path.join(os.path.split(rd.__file__)[0],
00528                            'Restriction_Dictionary.py')
00529         #update_folder = config.updatefolder
00530         update_folder = os.getcwd()
00531         shutil.copyfile(old, os.path.join(update_folder,
00532                                           'Restriction_Dictionary.old'))
00533         #
00534         #   Now test and install.
00535         #
00536         new = os.path.join(update_folder, 'Restriction_Dictionary.py')
00537         try:
00538             execfile(new)
00539             print '\
00540             \n\tThe new file seems ok. Proceeding with the installation.'   
00541         except SyntaxError:
00542             print '\
00543             \n The new dictionary file is corrupted. Aborting the installation.'
00544             return
00545         try:
00546             shutil.copyfile(new, old)
00547             print'\n\t Everything ok. If you need it a version of the old\
00548             \n\t dictionary have been saved in the Updates folder under\
00549             \n\t the name Restriction_Dictionary.old.'
00550             print '\n ' +'*'*78 + ' \n'
00551         except IOError:
00552             print '\n ' +'*'*78 + ' \n'
00553             print '\
00554             \n\t WARNING : Impossible to install the new dictionary.\
00555             \n\t Are you sure you have write permission to the folder :\n\
00556             \n\t %s ?\n\n' % os.path.split(old)[0]
00557             return self.no_install()
00558         return

Here is the call graph for this function:

BD.lastrebasefile() -> None.

Check the emboss files are up to date and download them if they are not.

Definition at line 594 of file RestrictionCompiler.py.

00594 
00595     def lastrebasefile(self):
00596         """BD.lastrebasefile() -> None.
00597 
00598         Check the emboss files are up to date and download them if they are not.
00599         """
00600         embossnames = ('emboss_e', 'emboss_r', 'emboss_s')
00601         #
00602         #   first check if we have the last update:
00603         #
00604         emboss_now = ['.'.join((x,LocalTime())) for x in embossnames]
00605         update_needed = False
00606         #dircontent = os.listdir(config.Rebase) #    local database content
00607         dircontent = os.listdir(os.getcwd())
00608         base = os.getcwd() # added for biopython current directory
00609         for name in emboss_now:
00610             if name in dircontent:
00611                 pass
00612             else:
00613                 update_needed = True
00614                 
00615         if not update_needed:
00616             #
00617             #   nothing to be done
00618             #
00619             print '\n Using the files : %s'% ', '.join(emboss_now)
00620             return tuple([open(os.path.join(base, n)) for n in emboss_now])
00621         else:
00622             #
00623             #   may be download the files.
00624             #
00625             print '\n The rebase files are more than one month old.\
00626             \n Would you like to update them before proceeding?(y/n)'
00627             r = raw_input(' update [n] >>> ')
00628             if r in ['y', 'yes', 'Y', 'Yes']:
00629                 updt = RebaseUpdate(self.rebase_pass, self.proxy)
00630                 updt.openRebase()
00631                 updt.getfiles()
00632                 updt.close()
00633                 print '\n Update complete. Creating the dictionaries.\n'
00634                 print '\n Using the files : %s'% ', '.join(emboss_now)
00635                 return tuple([open(os.path.join(base, n)) for n in emboss_now])
00636             else:
00637                 #
00638                 #   we will use the last files found without updating.
00639                 #   But first we check we have some file to use.
00640                 #
00641                 class NotFoundError(Exception):
00642                     pass
00643                 for name in embossnames:
00644                     try:
00645                         for file in dircontent:
00646                             if file.startswith(name):
00647                                 break
00648                         else:
00649                             pass
00650                         raise NotFoundError
00651                     except NotFoundError:
00652                         print "\nNo %s file found. Upgrade is impossible.\n"%name
00653                         sys.exit()
00654                     continue
00655                 pass
00656         #
00657         #   now find the last file.
00658         #
00659         last = [0]
00660         for file in dircontent:
00661             fs = file.split('.')
00662             try:
00663                 if fs[0] in embossnames and int(fs[1]) > int(last[-1]):
00664                     if last[0] : last.append(fs[1])
00665                     else : last[0] = fs[1]
00666                 else:
00667                     continue
00668             except ValueError:
00669                 continue
00670         last.sort()
00671         last = last[::-1]
00672         if int(last[-1]) < 100 : last[0], last[-1] = last[-1], last[0]
00673         for number in last:
00674             files = [(name, name+'.%s'%number) for name in embossnames]
00675             strmess = '\nLast EMBOSS files found are :\n'
00676             try:
00677                 for name,file in files:
00678                     if os.path.isfile(os.path.join(base, file)):
00679                         strmess += '\t%s.\n'%file
00680                     else:
00681                         raise ValueError
00682                 print strmess
00683                 emboss_e = open(os.path.join(base, 'emboss_e.%s'%number),'r')
00684                 emboss_r = open(os.path.join(base, 'emboss_r.%s'%number),'r')
00685                 emboss_s = open(os.path.join(base, 'emboss_s.%s'%number),'r')
00686                 return emboss_e, emboss_r, emboss_s
00687             except ValueError:
00688                 continue

Here is the call graph for this function:

Here is the caller graph for this function:

BD.no_install() -> None.

build the new dictionary but do not install the dictionary.

Definition at line 559 of file RestrictionCompiler.py.

00559 
00560     def no_install(self):
00561         """BD.no_install() -> None.
00562 
00563         build the new dictionary but do not install the dictionary."""
00564         print '\n ' +'*'*78 + '\n'
00565         #update = config.updatefolder
00566         try:
00567             import Bio.Restriction.Restriction_Dictionary as rd
00568         except ImportError:
00569             print '\
00570             \n Unable to locate the previous Restriction_Dictionary.py module\
00571             \n Aborting installation.'
00572             sys.exit()
00573         #
00574         #   first save the old file in Updates
00575         #
00576         old = os.path.join(os.path.split(rd.__file__)[0],
00577                            'Restriction_Dictionary.py')
00578         update = os.getcwd()
00579         shutil.copyfile(old, os.path.join(update, 'Restriction_Dictionary.old'))
00580         places = update, os.path.split(Bio.Restriction.Restriction.__file__)[0]
00581         print "\t\tCompilation of the new dictionary : OK.\
00582         \n\t\tInstallation : No.\n\
00583         \n You will find the newly created 'Restriction_Dictionary.py' file\
00584         \n in the folder : \n\
00585         \n\t%s\n\
00586         \n Make a copy of 'Restriction_Dictionary.py' and place it with \
00587         \n the other Restriction libraries.\n\
00588         \n note : \
00589         \n This folder should be :\n\
00590         \n\t%s\n" % places
00591         print '\n ' +'*'*78 + '\n'
00592         return
00593         

Here is the caller graph for this function:

Definition at line 689 of file RestrictionCompiler.py.

00689 
00690     def parseline(self, line):
00691         line = [line[0]]+[line[1].upper()]+[int(i) for i in line[2:9]]+line[9:]
00692         name = line[0].replace("-","_")
00693         site = line[1]          #   sequence of the recognition site
00694         dna = DNA(site)  
00695         size = line[2]          #   size of the recognition site
00696         #
00697         #   Calculate the overhang.
00698         #
00699         fst5 = line[5]  #   first site sense strand 
00700         fst3 = line[6]  #   first site antisense strand
00701         scd5 = line[7]  #   second site sense strand
00702         scd3 = line[8]  #   second site antisense strand
00703         
00704         #
00705         #   the overhang is the difference between the two cut
00706         #
00707         ovhg1 = fst5 - fst3
00708         ovhg2 = scd5 - scd3
00709         
00710         #
00711         #   0 has the meaning 'do not cut' in rebase. So we get short of 1
00712         #   for the negative numbers so we add 1 to negative sites for now.
00713         #   We will deal with the record later.
00714         #
00715         
00716         if fst5 < 0 : fst5 += 1
00717         if fst3 < 0 : fst3 += 1
00718         if scd5 < 0 : scd5 += 1
00719         if scd3 < 0 : scd3 += 1
00720 
00721         if ovhg2 != 0 and ovhg1 != ovhg2:
00722             #
00723             #   different length of the overhang of the first and second cut
00724             #   it's a pain to deal with and at the moment it concerns only
00725             #   one enzyme which is not commercially available (HaeIV).
00726             #   So we don't deal with it but we check the progression
00727             #   of the affair.
00728             #   Should HaeIV become commercially available or other similar
00729             #   new enzymes be added, this might be modified.
00730             #
00731             print '\
00732             \nWARNING : %s cut twice with different overhang length each time.\
00733             \n\tUnable to deal with this behaviour. \
00734             \n\tThis enzyme will not be included in the database. Sorry.' %name
00735             print '\tChecking :',
00736             raise OverhangError
00737         if 0 <= fst5 <= size and 0 <= fst3 <= size:
00738             #
00739             # cut inside recognition site
00740             #
00741             if fst5 < fst3:
00742                 #
00743                 #  5' overhang
00744                 #
00745                 ovhg1 = ovhgseq = site[fst5:fst3]       
00746             elif fst5 > fst3:
00747                 #
00748                 #  3' overhang
00749                 #
00750                 ovhg1 = ovhgseq = site[fst3:fst5]  
00751             else:
00752                 #
00753                 #  blunt
00754                 #
00755                 ovhg1 = ovhgseq = ''            
00756             for base in 'NRYWMSKHDBV':
00757                 if base in ovhg1:
00758                     #
00759                     #   site and overhang degenerated
00760                     #
00761                     ovhgseq = ovhg1
00762                     if fst5 < fst3 :  ovhg1 = - len(ovhg1)
00763                     else : ovhg1 = len(ovhg1)
00764                     break
00765                 else:
00766                     continue
00767         elif 0 <= fst5 <= size:
00768             #
00769             #   5' cut inside the site 3' outside
00770             #
00771             if fst5 < fst3:
00772                 #
00773                 #   3' cut after the site
00774                 #
00775                 ovhgseq = site[fst5:] + (fst3 - size) * 'N' 
00776             elif fst5 > fst3:
00777                 #
00778                 #   3' cut before the site
00779                 #
00780                 ovhgseq = abs(fst3) * 'N' + site[:fst5] 
00781             else:
00782                 #
00783                 #   blunt outside
00784                 #
00785                 ovhg1 = ovhgseq = '' 
00786         elif 0 <= fst3 <= size:
00787             #
00788             #   3' cut inside the site, 5' outside
00789             #
00790             if fst5 < fst3:
00791                 #
00792                 #   5' cut before the site
00793                 #
00794                 ovhgseq = abs(fst5) * 'N' + site[:fst3]
00795             elif fst5 > fst3:
00796                 #
00797                 #   5' cut after the site
00798                 #
00799                 ovhgseq = site[fst3:] + (fst5 - size) * 'N'
00800             else:
00801                 #
00802                 #   should not happend
00803                 #
00804                 raise ValueError('Error in #1')
00805         elif fst3 < 0 and size < fst5:
00806             #
00807             #   3' overhang. site is included.
00808             #
00809             ovhgseq = abs(fst3)*'N' + site + (fst5-size)*'N'
00810         elif fst5 < 0 and size <fst3:
00811             #
00812             #   5' overhang. site is included.
00813             #
00814             ovhgseq = abs(fst5)*'N' + site + (fst3-size)*'N'
00815         else:
00816             #
00817             #   5' and  3' outside of the site
00818             #
00819             ovhgseq = 'N' * abs(ovhg1)
00820         #
00821         #   Now line[5] to [8] are the location of the cut but we have to
00822         #   deal with the weird mathematics of biologists.
00823         #
00824         #   EMBOSS sequence numbering give:
00825         #                 DNA = 'a c g t A C G T'
00826         #                             -1 1 2 3 4
00827         #
00828         #   Biologists do not know about 0. Too much use of latin certainly.
00829         #
00830         #   To compensate, we add 1 to the positions if they are negative.
00831         #   No need to modify 0 as it means no cut and will not been used.
00832         #   Positive numbers should be ok since our sequence starts 1.
00833         #
00834         #   Moreover line[6] and line[8] represent cut on the reverse strand.
00835         #   They will be used for non palindromic sites and sre.finditer
00836         #   will detect the site in inverse orientation so we need to add the
00837         #   length of the site to compensate (+1 if they are negative).
00838         #
00839         for x in (5, 7):
00840             if line[x] < 0 : line[x] += 1
00841         for x in (6, 8):
00842             if line[x] > 0 : line[x] -= size
00843             elif line[x] < 0 : line[x] = line[x] - size + 1
00844         #
00845         #   now is the site palindromic?
00846         #   produce the regular expression which correspond to the site.
00847         #   tag of the regex will be the name of the enzyme for palindromic
00848         #   enzymesband two tags for the other, the name for the sense sequence
00849         #   and the name with '_as' at the end for the antisense sequence.
00850         #
00851         rg = ''
00852         if is_palindrom(dna):
00853             line.append(True)
00854             rg = ''.join(['(?P<', name, '>', regex(site.upper()), ')'])
00855         else:
00856             line.append(False)
00857             sense = ''.join(['(?P<', name, '>', regex(site.upper()), ')'])
00858             antisense = ''.join(['(?P<', name, '_as>',
00859                                  regex(Antiparallel(dna)), ')'])
00860             rg = sense + '|' + antisense
00861         #
00862         #   exact frequency of the site. (ie freq(N) == 1, ...)
00863         #
00864         f = [4/len(dna_alphabet[l]) for l in site.upper()]
00865         freq = reduce(lambda x, y : x*y, f)
00866         line.append(freq)
00867         #
00868         #   append regex and ovhg1, they have not been appended before not to
00869         #   break the factory class. simply to leazy to make the changes there.
00870         #
00871         line.append(rg)
00872         line.append(ovhg1)
00873         line.append(ovhgseq)
00874         return line

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 875 of file RestrictionCompiler.py.

00875 
00876     def removestart(self, file):
00877         #
00878         #   remove the heading of the file.
00879         #
00880         return [l for l in itertools.dropwhile(lambda l:l.startswith('#'),file)]

Here is the caller graph for this function:


Member Data Documentation

Definition at line 376 of file RestrictionCompiler.py.

Definition at line 375 of file RestrictionCompiler.py.


The documentation for this class was generated from the following file: