Changeset 239


Ignore:
Timestamp:
Oct 9, 2009, 1:15:52 PM (11 years ago)
Author:
jjbot
Message:

Bug fixes in transfacgeneparser. Added ontology to transfacmatrixparser. Now converts all lists to container.table format.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • parsers/transfac.py

    r236 r239  
    1919    nr_prefix_re = re.compile("(?P<id>\d{2})")
    2020
    21     def parse(self):
     21    # Labels for the parsed lists.
     22    DB_REF_LABS = ['ac_id', 'db', 'accession']
     23    REFERENCE_LABS = ['nr_local', 'nr_global',
     24            'pubmed', 'authors', 'title', 'source']
     25    ACCESSION_LABS = ['ac_id', 'accession']
     26    SPECIES_LABS = ['ac_id', 'simple_name', 'scientific_name']
     27    TEXT_LABS = ['ac_id', 'type', 'text']
     28
     29    def _globalToContainer(self):
     30        """Converts the non class specific lists generated by the parser
     31        to container.table objects.
     32        """
     33        self.db_xrefs = None
     34        if self.rec.db_refs:
     35            self.db_xrefs = table(self.rec.db_refs, self.DB_REF_LABS)
     36
     37        #self.references =
     38
     39        self.accessions = None
     40        if self.rec.accessions:
     41            self.accessions = table(self.rec.accessions, self.ACCESSION_LABS)
     42   
     43        self.species = None
     44        if self.rec.species:
     45            self.species = table(self.rec.species, self.SPECIES_LABS)
     46
     47        self.texts = None
     48        if self.rec.texts:
     49            self.texts = table(self.rec.texts, self.TEXT_LABS)
     50
     51    def _localToContainer(self):
     52        """Converts the lists generated by the 'child' parsers into
     53        container.table objects. Should be overwritten by the child
     54        classes.
     55        """
     56        pass
     57
     58    def toContainer(self):
     59        """Tansforms all the normal lists generated by the parser into
     60        container.table objects.
     61        """
     62        self._globalToContainer()
     63        self._localToContainer()
     64
     65    def parse(self, toCont=False):
    2266        """Handles the actual parsing, uses the fieldmapper specified in the
    2367        init function to map the first two characters of every line to the
     
    3983                    # numbers used by matrix file
    4084                    self.fieldmapper['00'](match.group('str'))
    41    
     85
     86        if toCont:
     87            self.toContainer()
     88
    4289
    4390class TransfacContainer(object):
     
    57104        self.cur_ac = None
    58105        self.accessions = []
    59         self.cur_species = []
     106        self.species = []
    60107        self.cur_taxonomy = []
    61108        self.db_refs = []
     
    63110        self.creation_date = ""
    64111        self.update_date = ""
     112        self.texts = []
    65113       
    66114        self.references = []
     
    178226        species = [s.strip() for s in str.split(',')]
    179227        if(len(species) > 1):
    180             self.cur_species.append( (self.cur_ac, species[0], species[1]) )
     228            self.species.append( (self.cur_ac, species[0], species[1]) )
    181229        else:
    182             self.cur_species.append( (self.cur_ac, species[0], '') )
     230            self.species.append( (self.cur_ac, species[0], '') )
    183231
    184232    def setTaxonomy(self, str):
     
    201249    on the transcription factors.
    202250    """
    203    
     251
     252    BINDING_SITE_LABS       = ['TF_id', 'site', 'quality']
     253    CLASS_LABS              = ['TF_id', 'class']
     254    COMPLEX_LABS            = ['TF_id', 'complex_id']
     255    ENCODING_GENE_LABS      = ['TF_id', 'gene', 'hgnc_name', 'short_name']
     256    FAMILY_LABS             = ['TF_id', 'fam_id', 'type']
     257    FEATURE_LABS            = ['TF_id', 'start', 'end', 'names']
     258    HOMOLOG_WO_SPECIES_LABS = ['TF_id', 'name']
     259    HOMOLOG_W_SPECIES_LABS  = ['TF_id', 'name', 'species']
     260    MATRIX_LABS             = ['TF_id', 'matrix_id']
     261    CELL_SPES_LABS          = ['TF_id', 'feature']
     262    SEQUENCE_LABS           = ['TF_id', 'sequence']
     263    SIZE_LABS               = ['TF_id', 'value', 'unit', 'type']
     264    STRUCT_FEAT_LABS        = ['TF_id', 'feature']
     265    TYPE_LABS               = ['TF_id', 'type']
     266    TFS_LABS                = ['TF_id', 'name']
     267
     268    def _localToContainer(self):
     269        """Transforms all the list specific to the FactorContainer into
     270        container.table objects."""
     271       
     272        self.bindingsites    = table(self.rec.bindingsites, self.BINDING_SITE_LABS)
     273        self.classes         = table(self.rec.classes, self.CLASS_LABS)
     274        self.complexes       = table(self.rec.complexes, self.COMPLEX_LABS)
     275        self.encoding_genes  = table(self.rec.encoding_genes, self.ENCODING_GENE_LABS)
     276        self.families        = table(self.rec.families, self.FAMILY_LABS)
     277        self.homo_w_species  = table(self.rec.homologs_w_species,
     278                                 self.HOMOLOG_W_SPECIES_LABS)
     279        self.homo_wo_species = table(self.rec.homologs_wo_species,
     280                                 self.HOMOLOG_WO_SPECIES_LABS)
     281        self.matrices        = table(self.rec.matrices, self.MATRIX_LABS)
     282        self.poss_cell_sps   = table(self.rec.pos_cell_specificity, self.CELL_SPES_LABS)
     283        self.neg_cell_sps    = table(self.rec.neg_cell_specificity, self.CELL_SPES_LABS)
     284        self.sequences       = table(self.rec.sequences, self.SEQUENCE_LABS)
     285        self.sizes           = table(self.rec.sizes, self.SIZE_LABS)
     286        self.struc_feats     = table(self.rec.structural_features, self.STRUCT_FEAT_LABS)
     287        self.types           = table(self.rec.types, self.TYPE_LABS)
     288        self.tfs             = table(self.rec.tfs, self.TFS_LABS)
     289
    204290    def __init__(self, filename):
    205291        self.filename = filename
     
    249335class TransfacFactorContainer(TransfacContainer):
    250336   
    251     aa_re = re.compile("(?P<length>\d+)\sAA")
    252     ac_re = re.compile("(?P<id>T\d{5})")
    253     gene_name_re = re.compile("(?P<name>G\d+)")
    254     tf_id_re = re.compile("(?P<id>T\d+)")
    255     short_gene_name_re = re.compile("(?P<name>\w+)")
    256     hgnc_name_re = re.compile("HGNC:\s(?P<name>\w+)")
    257     class_re = re.compile("(?P<class>C\d+)")
    258     homologue_re = re.compile(r"""
     337    aa_re               = re.compile("(?P<length>\d+)\sAA")
     338    ac_re               = re.compile("(?P<id>T\d{5})")
     339    gene_name_re        = re.compile("(?P<name>G\d+)")
     340    tf_id_re            = re.compile("(?P<id>T\d+)")
     341    short_gene_name_re  = re.compile("(?P<name>\w+)")
     342    hgnc_name_re        = re.compile("HGNC:\s(?P<name>\w+)")
     343    class_re            = re.compile("(?P<class>C\d+)")
     344    homologue_re        = re.compile(r"""
    259345            (?P<name>[\w|\s|\-]+)           # the name of the gene
    260346            \s                              # white space
     
    262348            .*                              # whatever remains
    263349        """, flags=re.VERBOSE)
    264     feature_re = re.compile(r"""
     350    feature_re          = re.compile(r"""
    265351            ^\s*(?P<start>\d+)              # start of feature
    266352            \s+                             # white space
     
    270356        """, flags=re.VERBOSE)
    271357
    272     types = { #FIXME: add to ontology?
    273         'family':'family',
     358    factor_types = { #FIXME: add to ontology?
     359        'family':   'family',
    274360        'isogroup': 'isogroup',
    275         'basic': 'basic',
    276         'complex': 'complex',
    277         'miRNA': 'miRNA'
     361        'basic':    'basic',
     362        'complex':  'complex',
     363        'miRNA':    'miRNA'
    278364    }
    279365   
     
    281367        super(self.__class__, self).__init__()
    282368
     369        self.cur_ac = None
     370        self.cur_name = None
     371
     372        self.bindingsites = []
     373        self.classes = []
     374        self.complexes = []
     375        self.cur_sequence = ""
     376        self.cur_species = []
     377        self.encoding_genes = []
     378        self.families = []
     379        self.features = []
     380        self.homologs_w_species = []
     381        self.homologs_wo_species = []
     382        self.interaction_factors = []
    283383        self.item_links = []
    284384        self.item_terms = []
    285         self.classes = []
    286         self.families = []
    287         self.interaction_factors = []
     385        self.matrices = []
     386        self.neg_cell_specificity = []
     387        self.pos_cell_specificity = []
     388        self.sequences = []
    288389        self.sizes = []
    289 
    290         self.cur_ac = None
    291         self.cur_name = None
    292         self.cur_species = []
    293         self.cur_sequence = ""
    294 
    295         self.homologs_w_species = []
    296         self.homologs_wo_species = []
    297         self.features = []
    298390        self.structural_features = []
    299         self.pos_cell_specificity = []
    300         self.neg_cell_specificity = []
    301         self.texts = []
    302         self.complexes = []
    303         self.bindingsites = []
    304         self.matrices = []
     391        self.tfs = []
     392        self.types = []
    305393
    306394    def addBindingSite(self, str):
     
    310398        quality = int(vars[2].split(':')[1].strip())
    311399        self.bindingsites.append(
    312             (self.cur_ac,    # current accession
    313             vars[0],        # R-number
    314             quality,        # quality of binding (range(1,6))
     400            ( # append tuple
     401                self.cur_ac,    # current accession
     402                vars[0],        # R-number
     403                quality,        # quality of binding (range(1,6))
    315404            )
    316405        )
     
    334423            names = [x.strip for x in match.group('names').split(';')]
    335424            self.features.append(
    336                 (self.cur_ac,
    337                 match.group('start'),
    338                 match.group('end'),
    339                 names
    340             ) )
     425                ( # add tuple
     426                    self.cur_ac,
     427                    match.group('start'),
     428                    match.group('end'),
     429                    names
     430                )
     431            )
    341432        else:
    342433            print "Found feature (%s) which did not match RegExp." % str
     
    358449
    359450    def startNewRecord(self):
    360         #TODO: add item
    361         #TODO: add sequence
     451        self.tfs.append( (self.cur_ac, self.cur_name) )
     452        if self.cur_sequence:
     453            self.sequences.append( (self.cur_ac, self.cur_sequence) )
    362454
    363455        self.clearTopVars()
     
    380472            short_gene_match = self.short_gene_name_re.match(name)
    381473            hgnc_match = self.hgnc_name_re.match(name)
     474            ac = ''
     475            hgnc = ''
     476            short_gene = ''
    382477            if gene_ac_match:
    383                 self.item_links.append(
    384                         (self.cur_ac,
    385                         gene_ac_match.group('name'),
    386                         'GENE accession',
    387                         'encoding gene')
    388                 )
     478                ac = gene_ac_match.group('name')
    389479            elif hgnc_match:
    390                 self.item_links.append(
    391                         (self.cur_ac,
    392                         hgnc_match.group('name'),
    393                         'HGNC name',
    394                         'encoding gene')
    395             )
     480                hgnc = hgnc_match.group('name')
    396481            elif short_gene_match:
    397                 self.item_links.append(
    398                         (self.cur_ac,
    399                         short_gene_match.group('name'),
    400                         'Gene short name',
    401                         'encoding gene')
    402             )
     482                short_gene = short_gene_match.group('name')
    403483            else:
    404484                pass #FIXME: should throw a warning
     485           
     486            self.encoding_genes.append(
     487                ( # append tuple
     488                    self.cur_ac,    # current accession
     489                    ac,             # gene nr
     490                    hgnc,           # hgnc name
     491                    short_gene      # short gene name (often same as hgnc)
     492                )
     493            )
    405494
    406495    def setSize(self, str):
     
    458547
    459548    def setSuperFamily(self, str):
     549        """Sets the superfamily (family of TFs) of the current TF."""
    460550        names = [x.strip() for x in str.split(';')]
    461551        for name in names:
     
    472562
    473563    def setSubFamily(self, str):
     564        """Sets the subfamily (family of TFs) of the current TF."""
    474565        names = [x.strip() for x in str.split(';')]
    475566        for name in names:
     
    486577
    487578    def setSynonyms(self, str):
     579        """Sets the synonyms of the current TF."""
    488580        syns = str.split(';')
    489581        for syn in syns:
     
    491583
    492584    def setType(self, str):
     585        """Sets the type of the current TF."""
    493586        type = str.strip('.').strip()
    494         if self.types.has_key(type):
    495             self.item_terms.append( (self.cur_ac, self.types[type]) )
     587        if self.factor_types.has_key(type):
     588            self.types.append( (self.cur_ac, self.factor_types[type]) )
    496589
    497590    def addInteractingFactors(self, str):
     
    505598
    506599    def addSequence(self, str):
     600        """Adds the sequence of the current TF."""
    507601        self.cur_sequence = self.cur_sequence + str.strip()
    508602
    509603
    510604class TransfacClassParser(TransfacParser):
     605
     606    FACTOR_LABS     = ['class_id', 'TF_ID', 'name', 'species_simple_name', 'species_official_name']
     607    ITEM_LABS       = ['class_id', 'description']
     608    STRUCT_CLS_LABS = ['class_id', 'class']
     609
    511610    def __init__(self, filename):
    512611        self.filename = filename
     
    530629        }
    531630
     631    def _localToContainer(self):
     632        self.tfs = table(self.rec.factors, self.FACTOR_LABS)
     633        self.struct_classes = table(self.rec.struct_classes, self.STRUCT_CLS_LABS)
     634        self.items = table(self.rec.items, self.ITEM_LABS)
     635
    532636
    533637class TransfacClassContainer(TransfacContainer):
     
    538642        self.cur_ac = None
    539643        self.cur_desc = ""
     644
     645        self.items = []
    540646        self.factors = []
    541         self.item_terms = []
     647        self.struct_classes = []
    542648
    543649    def setDescription(self, str):
     
    545651
    546652    def startNewRecord(self):
    547         #TODO: flush entry
     653        self.items.append( (self.cur_ac, self.cur_desc) )
    548654
    549655        self.clearTopVars()
    550 
    551656        self.cur_desc = None
    552657
    553658    def setFactors(self, str):
    554         #TODO: parse species info
    555         vars = [x.strip for x in str.split(';')]
     659        """Sets this Class's factors.
     660        Entry format:
     661        BF  <TF ID>; <name>; Species: <simple name>, <official name>
     662        """
     663        vars = [x.strip() for x in str.split(';')]
     664        species = vars[2].split(',')
     665        species_simple_name = species[0].strip().replace('Species: ', '')
     666        species_official_name = ''
     667        if len(species) == 2:
     668            species_official_name = species[1].strip()
    556669        self.factors.append(
    557             (self.cur_ac, vars[0], vars[1], vars[2])
     670            (
     671                self.cur_ac, vars[0], vars[1], vars[2],
     672                species_simple_name, species_official_name
     673            )
    558674        )
    559675
    560676    def setStructuralClass(self, str):
    561677        cl = str.strip()
    562         self.item_terms.append( (self.cur_ac, cl) )
     678        self.struct_classes.append( (self.cur_ac, cl) )
    563679
    564680
    565681class TransfacGeneParser(TransfacParser):
     682
     683    ACRONYM_LABS = []
     684    ENCODED_FACTOR_LABS     = ['gene_id', 'tf_id', 'tf_name', 'tf_type']
     685    GENE_LOCATIONS_LABS     = ['gene_id', 'genomic_location']
     686    HOST_GENES_LABS         = ['gene_id', 'host_gene_id', 'host_gene_name']
     687    PROMOTOR_CLASSES_LABS   = ['gene_id', 'class_id']
     688    GENE_LABS               = ['gene_id', 'description']
     689
     690    def _localToContainer(self):
     691        self.encoded_factors = table(self.rec.encoded_factors, self.ENCODED_FACTOR_LABS)
     692        # self.accessions?
     693        self.gene_locations = table(self.rec.gene_locations, self.GENE_LOCATIONS_LABS)
     694        self.host_genes = table(self.rec.host_genes, self.HOST_GENES_LABS)
     695        self.promotor_classes = table(self.rec.promotor_classes, self.PROMOTOR_CLASSES_LABS)
     696        self.genes = table(self.rec.genes, self.GENE_LABS)
    566697
    567698    def __init__(self, filename):
     
    601732class TransfacGeneContainer(TransfacContainer):
    602733    ac_re = re.compile("(?P<id>G\d{6})")
    603     tf_re = re.compile("(?P<tf>T\d{5});\s(?P<name>)\s\((?P<type>\w+)\)\.")
     734    tf_re = re.compile("""
     735            (?P<tf>T\d{5})
     736            ;\s
     737            (?P<name>.+)
     738            \s
     739            \((?P<type>.+)\)
     740            \.
     741    """, flags=re.VERBOSE)
    604742
    605743    def __init__(self):
     
    609747
    610748        self.acronyms = []
     749        self.encoded_factors = []
    611750        self.gene_locations = []
     751        self.genes = []
    612752        self.host_genes = []
    613753        self.intronic_genes = []
    614754        self.promotor_classes = []
    615         self.encoded_factors = []
    616755
    617756    def addEncodedFactor(self, str):
     757        """
     758        Record structure:
     759        FA  <TF id>; <TF name> (<type>)
     760        """
    618761        match = self.tf_re.match(str.strip())
    619762        if(match):
    620763            self.encoded_factors.append(
    621                 (self.cur_ar, match.group('id'), match.group('name'), match.group('type') )
     764                (self.cur_ac, match.group('tf'), match.group('name'), match.group('type') )
    622765            )
    623766        else:
    624             pass
    625             #FIXME insert warning
     767            print "Encoded factor (%s) did not match expected format." % str
    626768
    627769    def setAcronym(self, str):
     770        """Sets the acronym for the current gene.
     771        Record structure:
     772        ID  <>$<>
     773        """
    628774        vars = str.strip().split('$')
    629775        self.acronyms.append( (self.cur_ac, vars[0], vars[1]) )
    630776
    631777    def addNamedAccession(self, str):
     778        """
     779        Record structure:
     780        DE  <name>
     781        """
    632782        self.accessions.append( (self.cur_ac, str.strip() ) )
    633783
     
    638788   
    639789    def setGeneLocation(self, str):
     790        """
     791        Record structure:
     792        CH  <location>
     793        """
    640794        self.gene_locations.append( (self.cur_ac, str.strip() ) )
    641795
    642796    def setHostGene(self, str):
    643         vars = [x.strip() for x in str.strip('.')]
     797        """
     798        Record structure:
     799        HG  <gene id>; <name>
     800        """
     801        vars = [x.strip() for x in str.strip('.').split(';')]
    644802        if(len(vars) == 1):
    645             host_genes.append( (self.cur_ac, vars[0], '') )
     803            self.host_genes.append( (self.cur_ac, vars[0], '') )
    646804        elif(len(vars) == 2):
    647             host_genes.append( (self.cur_ac, vars[0], vars[1]) )
     805            self.host_genes.append( (self.cur_ac, vars[0], vars[1]) )
    648806        else:
    649             pass
    650             # FiXME: should print warning
     807            print "Host gene entry (%s) did not match expected format." % str
    651808
    652809    def setIntronicGene(self, str):
    653         vars = [x.strip() for x in str.strip('.')]
     810        """
     811        Record structure:
     812        IG  <gene id>; <name>
     813        """
     814        vars = [x.strip() for x in str.strip('.').split(';')]
    654815        if(len(vars) == 1):
    655             intronic_genes.append( (self.cur_ac, vars[0], '') )
     816            self.intronic_genes.append( (self.cur_ac, vars[0], '') )
    656817        elif(len(vars) == 2):
    657             introni_genes.append( (self.cur_ac, vars[0], vars[1]) )
     818            self.intronic_genes.append( (self.cur_ac, vars[0], vars[1]) )
    658819        else:
    659             pass
    660             # FiXME: should print warning
     820            print "Intronic gene entry (%s) did not match expected format." % str
    661821       
    662822    def setPromotorClass(self, str):
     823        """
     824        Record structure:
     825        BC  <class>
     826        """
    663827        self.promotor_classes.append( (self.cur_ac, str.strip()) )
    664828
    665829    def startNewRecord(self):
    666         # TODO: flush information
    667 
     830        self.genes.append( (self.cur_ac, self.cur_desc) )
    668831        self.clearTopVars()
    669832
     
    674837
    675838    ac_re = re.compile("(?P<id>R\d{5})")
     839
     840    # accessions?
     841    SITE_LABS           = ['site_id', 'type', 'ref_start_point',
     842                            'start_pos', 'end_pos']
     843    ELEMENT_LABS        = ['site_id', 'element']
     844    GENE_REGIONS_LABS   = ['site_id', 'region']
     845    SEQUENCE_LABS       = ['site_id', 'sequence']
     846
     847    def _localToContainer(self):
     848        self.sites = table(self.rec.sites, self.SITE_LABS)
     849        self.elements = table(self.rec.elements, self.ELEMENT_LABS)
     850        self.gene_regions = table(self.rec.gene_regions, self.GENE_REGIONS_LABS)
     851        self.sequences = table(self.rec.sequences, self.SEQUENCE_LABS)
    676852
    677853    def __init__(self, filename):
     
    679855       
    680856        site_rec = TransfacSiteContainer()
    681         rec = site_rec
     857        self.rec = site_rec
    682858       
    683859        self.fieldmapper = {
     
    701877            #'MM': site_re
    702878            #'CC': site_re
    703             'DR': site_re.setDatabaseRef,
    704             'RN': site_re.setReference,
    705             'RX': site_re.setRefPubmed,
    706             'RA': site_re.setRefAuthors,
    707             'RT': site_re.setRefTitle,
    708             'RL': site_re.setRefSource,
     879            'DR': site_rec.setDatabaseRef,
     880            'RN': site_rec.setReference,
     881            'RX': site_rec.setRefPubmed,
     882            'RA': site_rec.setRefAuthors,
     883            'RT': site_rec.setRefTitle,
     884            'RL': site_rec.setRefSource,
    709885        }
    710886
     
    715891
    716892    ac_re = re.compile("(?P<id>R\d{5})")
    717     desc_re = re.compile("(?P<name>\w+)\s\((?P<names>.+)\);\sGene:\s(?P<gene>G\d+)\.")
     893    desc_re = re.compile("""
     894            (?P<name>.+)
     895            \s
     896            \(
     897                (?P<names>.+)
     898            \);
     899            \sGene:\s
     900            (?P<gene>G\d+)
     901            \.
     902    """, flags=re.VERBOSE)
     903    desc_re_short = re.compile("""
     904            (?P<name>.+)
     905            \s
     906            Gene:\s
     907            (?P<gene>G\d+)
     908            \.
     909    """, flags=re.VERBOSE)
    718910
    719911    def __init__(self):
     
    729921        self.gene_regions = []
    730922        self.sequences = []
     923        self.sites = []
    731924
    732925    def parseDescription(self, str):
     926        # FIXME: why are we storing this as accessions?
    733927        match = self.desc_re.match(str)
     928        short_match = self.desc_re_short.match(str)
    734929        if match:
    735930            self.accessions.append( (self.cur_ac, match.group('name') ) )
    736931            self.accessions.append( (self.cur_ac, match.group('gene') ) )
    737932            #FIXME: add short names?
     933        elif short_match:
     934            self.accessions.append( (self.cur_ac, short_match.group('gene') ) )
     935        elif str.lower() == 'artificial sequence.':
     936            pass
     937            # FIXME: what should we do here?
     938        elif str.lower() == 'consensus.':
     939            pass
    738940        else:
    739941            print "Description (%s) did not match expected form." % str
    740942
    741943    def startNewRecord(self):
    742 
     944        self.sites.append(
     945            (
     946                self.cur_ac,
     947                self.type,
     948                self.reference_start_point,
     949                self.start_pos,
     950                self.end_pos
     951            )
     952        )
     953       
    743954        self.clearTopVars()
    744955
     
    755966            self.start_position = int(str.strip())
    756967        except:
    757             #FIXME: add real error
    758968            print "setStartPosition: Conversion to int failed for value: %s." % str
    759969
     
    762972            self.end_position = int(str.strip())
    763973        except:
    764             #FIXME: add real error
    765974            print "setEndPosition: Conversion to int failed for value: %s" % str
    766975
    767976    def setElement(self, str):
     977        """
     978        Record structure:
     979        EL  <element>
     980        """
    768981        #FIXME: should match this to ontology term
    769982        self.elements.append( (self.cur_ac, str) )
    770983
    771984    def setGeneRegion(self, str):
     985        """
     986        Record structure
     987        RE  <region>
     988        """
    772989        #FIXME: should look up terms in ontology
    773990        self.gene_regions.append( (self.cur_ac, str.strip() ) )
    774991
    775992    def setSequence(self, str):
     993        """
     994        Record structure:
     995        SQ  <sequence>.
     996        """
    776997        self.sequences.append( (self.cur_ac, str.strip('.') ) )
    777998
     
    7861007
    7871008class TransfacCellParser(TransfacParser):
     1009
     1010    DESCRIPTION_LABS = ['cell_id', 'description']
     1011
     1012    def _localToContainer(self):
     1013        self.descriptions = table(self.rec.descriptions, self.DESCRIPTION_LABS)
    7881014
    7891015    def __init__(self, filename):
     
    8051031        }
    8061032
     1033
    8071034class TransfacCellContainer(TransfacContainer):
    8081035
    8091036    ac_re = re.compile("(?P<id>\d{4})")
    810    
     1037
    8111038    def __init__(self):
    8121039        super(self.__class__, self).__init__()
     
    8231050
    8241051class TransfacMatrixParser(TransfacParser):
     1052
     1053    BINDING_FACTOR_LABS = ['matrix_id', 'tf_id', 'tf_name', 'species']
     1054    BINDING_SITE_LABS   = ['matrix_id', 'sequence', 'site_id']
     1055    MATRIX_LABS         = ['matrix_id', 'matrix']
     1056    TFS_LABS            = ['matrix_id', 'tf_name']
     1057
     1058    def _localToContainer(self):
     1059        self.binding_factors = table(self.rec.binding_factors, self.BINDING_FACTOR_LABS)
     1060        self.binding_sites = table(self.rec.binding_sites, self.BINDING_SITE_LABS)
     1061        self.matrices = table(self.rec.matrices, self.MATRIX_LABS)
     1062        self.tfs = table(self.rec.tfs, self.TFS_LABS)
     1063
    8251064    def __init__(self, filename):
    8261065        self.filename = filename
     
    8401079            'P0': matrix_rec.setMatrixHeader,
    8411080            'BA': matrix_rec.addBasis,
    842             #'BS':
     1081            'BS': matrix_rec.addBindingSite,
    8431082            'CC': matrix_rec.addComment,
    8441083            'RN': matrix_rec.setReference,
     
    8781117        self.matrices = []
    8791118        self.cur_matrix = []
    880         self.texts = []
    8811119        self.binding_factors = []
     1120        self.binding_sites = []
    8821121
    8831122    def startNewRecord(self):
     
    9121151        )
    9131152
     1153    def addBindingSite(self, str):
     1154        """Adds a binding site.
     1155        Line format:
     1156        BS  <sequence>; <site_nr>; <?>; <?>;; <?>
     1157        """
     1158        vars = tuple(x.strip() for x in str.split(';'))
     1159        self.binding_sites.append(
     1160            (self.cur_ac, ) + vars[0:1]
     1161        )
     1162
    9141163    def addComment(self, str):
    9151164        self.texts.append( (self.cur_ac, str.strip(), 'comment') )
     
    9231172        if match:
    9241173            self.cur_matrix.append(
    925                 (match.group('a'),
    926                 match.group('b'),
    927                 match.group('c'),
    928                 match.group('d'),
    929                 match.group('e'),
     1174                ( # adding a tuple
     1175                    float(match.group('a')),
     1176                    float(match.group('b')),
     1177                    float(match.group('c')),
     1178                    float(match.group('d')),
     1179                    match.group('e'),
    9301180                )
    9311181            )
Note: See TracChangeset for help on using the changeset viewer.