def main():

    special = None
    no_threads = 1
    db = connect_to_mysql()

    cursor = db.cursor()
    [all_species, ensembl_db_name] = get_species(cursor)
    total = 0
    for species in all_species:
        print species
        switch_to_db(cursor, ensembl_db_name[species])
        qry = "select count(1) from usearch_exon"
        rows = search_db(cursor, qry)
        count = int(rows[0][0])
        print "\t usearch exons: ", count
        total += count
        qry = "select count(1) from sw_exon"
        rows = search_db(cursor, qry)
        count = int(rows[0][0])
        print "\t sw exons: ", count
        total += count
    print
    print 'total: ', total
    cursor.close()
    db.close()
def main():
    
    special    = None
    no_threads = 1
    db  = connect_to_mysql()

    cursor = db.cursor()
    [all_species, ensembl_db_name] = get_species (cursor)
    total = 0
    for species in all_species:
        print species
        switch_to_db (cursor, ensembl_db_name[species])
        qry  = "select count(1) from usearch_exon"
        rows = search_db (cursor, qry)
        count = int(rows[0][0])
        print "\t usearch exons: ", count 
        total += count
        qry  = "select count(1) from sw_exon"
        rows = search_db (cursor, qry)
        count = int(rows[0][0])
        print "\t sw exons: ", count 
        total += count
    print
    print 'total: ', total
    cursor.close()
    db.close()
Ejemplo n.º 3
0
def  make_parameter_table (cursor):

    """
    Creates parameter table in the config database.
    @param [cursor] db cursor, assumed top be pointing to the config database
    @retval True  on success
    @retval False on failure;  in that case the seach_db() call is repeated in verbose mode.
    """

    table = 'parameter'

    print "making ", table

    qry  = "create table " + table + "  (id int(10) primary key auto_increment)"
    rows = search_db (cursor, qry, verbose=True)
    if (rows):
        return False

    # make the columns
    for column  in  ['name', 'value']:
        qry = "alter table  %s  add  %s  varchar (50)" % (table, column)
        rows = search_db (cursor, qry, verbose=True)
        if (rows):
            return False
    return False
Ejemplo n.º 4
0
def main():

    db = connect_to_mysql()
    cr = ConfigurationReader()

    cursor = db.cursor()
    fasta_path = cr.get_path('ensembl_fasta')

    [all_species, ensembl_db_name] = get_species (cursor)

    for species in all_species:
    #for species in ['danio_rerio']:
        print species
        dna_path = "{0}/{1}/dna".format(fasta_path, species)
        if (not os.path.exists(dna_path)):
            print "problem:", dna_path, "not found"
            exit(1)

        fasta_files = []
        for r,d,files in os.walk(dna_path):
            for file in files:
                if (not file[-3:] == ".fa"):
                    continue
                fasta_files.append(file)
        
        name2file = {}
        for file in fasta_files:
            print dna_path, file
            cmd = "grep '>' {0}/{1}".format(dna_path, file)
            ret = commands.getoutput(cmd)
            headers = ret.split("\n")
            print "number of headers: ", len(headers)
            for hdr in headers:
                fields = hdr.split(" ")
                name = fields[0].replace (">", "")
                #print name
                if (not name2file.has_key(name)):
                    name2file[name] = []
                name2file[name].append(file)

        qry = "use "+ensembl_db_name[species]
        search_db (cursor, qry)

        for name in name2file.keys():
            file_names = ""
            for file in  name2file[name]:
                if file_names:
                    file_names += " "
                file_names += file
            store_seq_filenames (cursor, name, file_names)
 
    cursor.close()
    db    .close()
Ejemplo n.º 5
0
def check_table_sizes(cursor, all_species, ensembl_db_name):
    for species in all_species:
        print
        print "##########################"
        print species
        qry = "use " + ensembl_db_name[species]
        search_db(cursor, qry)
        qry = "show tables"
        rows = search_db(cursor, qry)
        for row in rows:
            table = row[0]
            qry = " select count(1) from " + table
            rows = search_db(cursor, qry)
            table_size = rows[0][0]
            print "\t ", table, table_size
Ejemplo n.º 6
0
def check_table_sizes (cursor, all_species, ensembl_db_name):
    for species in all_species:
        print
        print "##########################"
        print species
        qry  = "use "+ensembl_db_name[species]
        search_db(cursor, qry)
        qry  = "show tables"
        rows = search_db(cursor, qry)
        for row in rows:
            table = row[0]
            qry = " select count(1) from "+table
            rows = search_db(cursor, qry)
            table_size = rows[0][0]
            print "\t ", table, table_size
def main():

    db     = connect_to_mysql()
    cursor = db.cursor()

    [all_species, ensembl_db_name] = get_species (cursor)

    for species in all_species:
        print species

        switch_to_db (cursor, ensembl_db_name[species])

        qry  = "select seq_region.name, seq_region.file_name from seq_region, gene "
        qry += " where gene.biotype='protein_coding' and gene.seq_region_id =  seq_region.seq_region_id "
            

        rows = search_db (cursor, qry)
        if (not rows):
            print "\t no seq region info found "
            continue
        tot = 0
        no_file = 0
        for row in rows:
            [name,  file_name] = row
            #print name, file_name
            tot += 1
            if (not file_name):
                no_file += 1
                print name, file_name
                #exit (1)

        print "\t tot seq_regions: ", tot, " no file: ", no_file
 
    cursor.close()
    db    .close()
Ejemplo n.º 8
0
def main ():

    
    db_name = "exolocator_db"
    db      = connect_to_mysql(user="******", passwd="tooiram")
    cursor  = db.cursor()
    switch_to_db (cursor, db_name)

    cfg     = ConfigurationReader (user="******", passwd="tooiram", check=False)

    inpath = cfg.get_path('afs_dumps')
    indir   = "%s/exon_map"     % inpath
    infile  = "%s/exon_map.sql" % indir
    if (not os.path.exists(infile)):
        print "not found: ", infile
        sys.exit(1)
    print "reading", infile

    qry = "drop table exon_map"
    rows = search_db(cursor, qry)
    # I could not get this to run, though it runs fine directly from the mysql shell:
    #qry = "source %s" % infile
    #rows = search_db(cursor, qry, verbose=True)
    cursor.close()
    db.close()

    credentials = " -u marioot -ptooiram"
    cmd = "mysql %s  exolocator_db  <  %s" % (credentials, infile)
    print cmd
    ret = commands.getoutput(cmd)
    print ret

 
    return True
def get_seq_region_info(cursor, name):
    qry = "select * from seq_region where name = '%s'" % name
    rows = search_db (cursor, qry)
    if(len(rows) > 1):
        print "more than one entry associated with ", name
        exit (1)
    return rows[0]
Ejemplo n.º 10
0
def main():

    db_name = "exolocator_db"
    db = connect_to_mysql(user="******", passwd="tooiram")
    cursor = db.cursor()
    switch_to_db(cursor, db_name)

    cfg = ConfigurationReader(user="******", passwd="tooiram", check=False)

    inpath = cfg.get_path('afs_dumps')
    indir = "%s/exon_map" % inpath
    infile = "%s/exon_map.sql" % indir
    if (not os.path.exists(infile)):
        print "not found: ", infile
        sys.exit(1)
    print "reading", infile

    qry = "drop table exon_map"
    rows = search_db(cursor, qry)
    # I could not get this to run, though it runs fine directly from the mysql shell:
    #qry = "source %s" % infile
    #rows = search_db(cursor, qry, verbose=True)
    cursor.close()
    db.close()

    credentials = " -u marioot -ptooiram"
    cmd = "mysql %s  exolocator_db  <  %s" % (credentials, infile)
    print cmd
    ret = commands.getoutput(cmd)
    print ret

    return True
Ejemplo n.º 11
0
def search_description(cursor, gene_name):
    qry = "select gene_id, description from gene "
    qry += "where description like '%" + gene_name + "%'"
    rows = search_db(cursor, qry)
    if not rows:
        return ["", ""]
    else:
        return rows[0]
Ejemplo n.º 12
0
def search_description (cursor, gene_name):
    qry  = "select gene_id, description from gene "
    qry += "where description like '%"+gene_name+"%'"
    rows = search_db (cursor, qry)
    if not rows:
        return ["", ""]
    else:
        return rows[0]
Ejemplo n.º 13
0
def get_exon_end(cursor, exon_id):
 
    qry  = "select seq_region_end from exon "
    qry += "where exon_id = %d " % exon_id
    rows = search_db (cursor, qry)
    if (not rows or 'Error' in rows[0]):
        print "start not found for ", exon_id
        return None

    return rows[0][0]
Ejemplo n.º 14
0
def get_phase(cursor, exon_id):

    qry  = "select is_coding, phase, gene_id from gene2exon where exon_id = %d" % exon_id
    rows = search_db(cursor, qry)
    if (rows):
        [is_coding, phase, gene_id] = rows[0]
    else:
        [is_coding, phase, gene_id] = [0,0,0]

    return [is_coding, phase, gene_id]
Ejemplo n.º 15
0
def get_exon_end(cursor, exon_id):

    qry = "select seq_region_end from exon "
    qry += "where exon_id = %d " % exon_id
    rows = search_db(cursor, qry)
    if (not rows or 'Error' in rows[0]):
        print "start not found for ", exon_id
        return None

    return rows[0][0]
Ejemplo n.º 16
0
def  cleanup_endphase (cursor, exon):


    qry = "select phase, end_phase from exon where exon_id =  %d " % exon.exon_id
    rows  = search_db (cursor, qry)
    if not rows:
        exon.phase     = 0
        exon.end_phase = 0
    else:
        exon.phase     = rows[0][0]
        exon.end_phase = rows[0][1]
Ejemplo n.º 17
0
def  make_path_table (cursor, table):

    print "making ", table

    qry  = "create table " + table + "  (id int(10) primary key auto_increment)"
    rows = search_db (cursor, qry, verbose=True)
    if (rows):
        return False

    # make the columns
    column  = 'name'
    qry = "alter table  %s  add  %s  varchar (20)" % (table, column)
    rows = search_db (cursor, qry, verbose=True)
    if (rows):
        return False

    column  = 'path'
    qry = "alter table  %s  add  %s  blob" % (table, column)
    rows = search_db (cursor, qry, verbose=True)
    if (rows):
        return False
Ejemplo n.º 18
0
def transcript_id2exon_ids (cursor, transcript_id):

    exon_ids = []
    qry = "select exon_id from exon_transcript "
    qry += " where transcript_id = %d " %  transcript_id
    rows   = search_db (cursor, qry)
    if (not rows):
        return []
    for row in rows:
        exon_ids.append(row[0])

    return exon_ids
Ejemplo n.º 19
0
def gene_name2gene_id(cursor, gene_name):

    qry = "select ensembl_id from object_xref, external_synonym "
    qry += "where object_xref.ensembl_object_type = 'Gene'  "
    qry += "and object_xref.xref_id= external_synonym.xref_id "
    qry += "and external_synonym.synonym = '%s' " % gene_name
    qry += "group by synonym"
    rows = search_db(cursor, qry)
    if not rows:
        return ""
    else:
        return rows[0][0]
def  map_cleanup (cursor, ensembl_db_name, human_exons):
    
    switch_to_db(cursor,ensembl_db_name['homo_sapiens']) 
    for exon in human_exons:
        qry  = "delete from exon_map where exon_id = %d " % exon.exon_id
        qry += " and exon_known = %d " % exon.is_known
        qry += " and cognate_exon_known > 1 " 
        qry += " and similarity is NULL" 
        rows = search_db (cursor, qry, verbose=False)


    return True
Ejemplo n.º 21
0
def gene_name2gene_id(cursor, gene_name):
    
    qry  = "select ensembl_id from object_xref, external_synonym "
    qry += "where object_xref.ensembl_object_type = 'Gene'  "
    qry += "and object_xref.xref_id= external_synonym.xref_id "
    qry += "and external_synonym.synonym = '%s' " % gene_name
    qry += "group by synonym"
    rows = search_db (cursor, qry)
    if not rows:
        return ""
    else:
        return rows[0][0]
Ejemplo n.º 22
0
def transcript_id2exon_ids(cursor, transcript_id):

    exon_ids = []
    qry = "select exon_id from exon_transcript "
    qry += " where transcript_id = %d " % transcript_id
    rows = search_db(cursor, qry)
    if (not rows):
        return []
    for row in rows:
        exon_ids.append(row[0])

    return exon_ids
Ejemplo n.º 23
0
def  make_seqregion2file_table (cursor):

    table = 'seqregion2file'

    
    qry  = "create table " + table + "  (seqregion_id int(10) primary key)"
    rows = search_db (cursor, qry)
    if (rows):
        return False

    # make the columns
    column  = 'seq_name'
    qry = "alter table  %s  add  %s  varchar (100)" % (table, column)
    rows = search_db (cursor, qry)
    if (rows):
        return False

    column  = 'file_name'
    qry = "alter table  %s  add  %s  blob" % (table, column)
    rows = search_db (cursor, qry)
    if (rows):
        return False
Ejemplo n.º 24
0
def main():

    db_name = "exolocator_db"
    db      = connect_to_mysql(user="******", passwd="tooiram")
    cursor  = db.cursor()
    switch_to_db (cursor, db_name)

    cfg      = ConfigurationReader (user="******", passwd="tooiram", check=False)
    in_path  = cfg.get_path('afs_dumps')
    in_path += "/para_dump"
    if (not os.path.exists(in_path)):
        print in_path, "not found"
        sys.exit(1) # exit on non-existent outdir

    
    ###############
    if 1:
        qry = "drop table paralog"
        search_db (cursor, qry)
        qry = "create table paralog (id int(10) primary key auto_increment) "
        search_db (cursor, qry)
        qry = "alter table paralog  ADD gene_id1 varchar(30) " 
        search_db (cursor, qry)
        qry = "alter table paralog  ADD gene_id2 varchar(30) " 
        search_db (cursor, qry)
        create_index (cursor, db_name,'gene_id_index', 'paralog', ['gene_id1', 'gene_id2'])
        

    ###############
    os.chdir(in_path)
    filenames = glob.glob("*_para_dump.txt")

    ###############
    for infile in filenames:
        print infile
        store(cursor, infile)

    cursor.close()
    db    .close()
Ejemplo n.º 25
0
def main():

    db_name = "exolocator_db"
    db = connect_to_mysql(user="******", passwd="tooiram")
    cursor = db.cursor()
    switch_to_db(cursor, db_name)

    cfg = ConfigurationReader(user="******", passwd="tooiram", check=False)
    in_path = cfg.get_path('afs_dumps')
    in_path += "/para_dump"
    if (not os.path.exists(in_path)):
        print in_path, "not found"
        sys.exit(1)  # exit on non-existent outdir

    ###############
    if 1:
        qry = "drop table paralog"
        search_db(cursor, qry)
        qry = "create table paralog (id int(10) primary key auto_increment) "
        search_db(cursor, qry)
        qry = "alter table paralog  ADD gene_id1 varchar(30) "
        search_db(cursor, qry)
        qry = "alter table paralog  ADD gene_id2 varchar(30) "
        search_db(cursor, qry)
        create_index(cursor, db_name, 'gene_id_index', 'paralog',
                     ['gene_id1', 'gene_id2'])

    ###############
    os.chdir(in_path)
    filenames = glob.glob("*_para_dump.txt")

    ###############
    for infile in filenames:
        print infile
        store(cursor, infile)

    cursor.close()
    db.close()
Ejemplo n.º 26
0
def check_ccds(cursor, transcript_stable_id):

    ccds = ""

    qry = "select dna_align_feature.hit_name "
    qry += "from dna_align_feature, transcript, transcript_supporting_feature "
    qry += "   where dna_align_feature.dna_align_feature_id =  transcript_supporting_feature.feature_id "
    qry += "   and transcript_supporting_feature.feature_type ='dna_align_feature' "
    qry += "   and transcript_supporting_feature.transcript_id =transcript.transcript_id "
    qry += "   and transcript.stable_id = '%s' " % transcript_stable_id

    rows = search_db(cursor, qry)

    if not rows:
        return ccds

    for row in rows:
        if 'CCDS' in row[0]:
            ccds = row[0]

    return ccds
Ejemplo n.º 27
0
def dump_orthos (species_list, db_info):

    
    [local_db, ensembl_db_name] = db_info
    db     = connect_to_mysql()
    cfg    = ConfigurationReader()
    cursor = db.cursor()

     # find db ids adn common names for each species db
    [all_species, ensembl_db_name] = get_species (cursor)

    # in the afa headers use 'trivial' names for the species: cow, dog, pig, ...
    trivial_name   = translate_to_trivial(cursor, all_species)

    out_path = cfg.get_path('afs_dumps')
    outfile  = "{0}/orthologue_dump.txt".format(out_path)
    print outfile
    of       = erropen (outfile,"w")

    species  = 'homo_sapiens'
    switch_to_db (cursor,  ensembl_db_name[species])


    qry = "select * from orthologue"
    rows = search_db (cursor, qry)
    for row in rows:
        [pair_id, human_gene_id, cognate_gene_id, genome_db_id, source] =  row
        species = genome_db_id2species (cursor, genome_db_id)
        switch_to_db (cursor,  ensembl_db_name['homo_sapiens'])
        human_stable_id = gene2stable(cursor, human_gene_id)
        switch_to_db (cursor,  ensembl_db_name[species])
        cognate_stable_id = gene2stable(cursor, cognate_gene_id)
        print  >>of,  orthos_tabstring ([human_stable_id, cognate_stable_id, species, trivial_name[species]])


    of.close()
    
    cursor.close()
    db    .close()
Ejemplo n.º 28
0
def check_ccds (cursor, transcript_stable_id):

    ccds = ""

    qry  = "select dna_align_feature.hit_name "
    qry += "from dna_align_feature, transcript, transcript_supporting_feature "
    qry += "   where dna_align_feature.dna_align_feature_id =  transcript_supporting_feature.feature_id "
    qry += "   and transcript_supporting_feature.feature_type ='dna_align_feature' "
    qry += "   and transcript_supporting_feature.transcript_id =transcript.transcript_id "
    qry += "   and transcript.stable_id = '%s' " % transcript_stable_id

    rows = search_db(cursor, qry)

    if not rows:
        return ccds


    for row in rows:
        if 'CCDS' in row[0]:
            ccds = row[0]

    return  ccds
Ejemplo n.º 29
0
def get_theme_ids(cursor, cfg, theme_name):
    resources = cfg.dir_path['resources']
    fnm = resources + '/' + theme_name+'.txt'
    if not os.path.exists(fnm):
        print fnm, "not found"
        exit(1)

    if not os.path.getsize(fnm) > 0:
        print fnm, "empty"
        exit(1)
        
    inf = erropen(fnm, "r")
    gene_ids = []
    for line in inf:
        line.rstrip()
        [stable_id, name] = line.split("\t")
        qry = "select gene_id, description from gene where stable_id='%s'"% stable_id
        rows = search_db (cursor, qry)
        if not rows: continue
        gene_ids.append(rows[0][0])
    inf.close()

    return gene_ids
Ejemplo n.º 30
0
def alt_splice_almt (cursor, cfg, acg, species, ensembl_db_name):

    flank_length = 10

    print "############################"
    print 'checking alt splicing in ', species

    qry = "use " + ensembl_db_name[species]
    search_db(cursor, qry)
    gene_ids = get_gene_ids (cursor, biotype='protein_coding', is_known=1)

    if species == 'homo_sapiens':
        spec_short = 'HSA'
    else:
        spec_short = 'MMU'

    outdir   = "{0}/alt/{1}".format(cfg.dir_path['afs_dumps'], spec_short)
    if not os.path.exists(outdir):
        os.makedirs(outdir)

    ########################################
    ########################################
    ########################################

    #gene_ids.reverse()

    for gene_id in gene_ids:
    #for gene_id in [429349]:
    #for count in range(1000):
        #gene_id = choice (gene_ids)

        stable_gene_id = gene2stable(cursor, gene_id)
        if verbose: print  gene_id, stable_gene_id, get_description (cursor, gene_id)
        transcript_ids = get_transcript_ids(cursor, gene_id)

        tr_w_ccds = []
        for [tr_id, tr_stable] in transcript_ids:
            ccds = check_ccds (cursor, tr_stable)
            if not ccds: continue
            tr_w_ccds.append([tr_id, tr_stable])

        if not tr_w_ccds: continue

        # get all exons for this gene
        all_exons    = gene2exon_list (cursor, gene_id)
        
        exons_w_ccds = set([]) # get the unique_ids

        # find exons which are on the ccds list
        for [tr_id, tr_stable] in tr_w_ccds:
            exon_ids =  transcript_id2exon_ids (cursor, tr_id)
            exons_w_ccds.update( set(exon_ids))
           
        # for these exons check sequence
        is_known = 1
        bad_exon = set([])
        for exon_id in exons_w_ccds:
            exon = get_exon      (cursor, exon_id, is_known)
            seq  = get_exon_seqs (cursor, exon_id, is_known)
            if not seq:
                bad_exon.add(exon_id)
                continue
            [exon_seq_id, protein_seq, pepseq_transl_start, 
             pepseq_transl_end, left_flank, right_flank, dna_seq] = seq

            if exon.covering_exon < 0:
                if not dna_seq:
                     bad_exon.add(exon_id)
            else:
                if exon.covering_exon_known and exon.covering_exon in exons_w_ccds:
                    pass
                else:
                    all_exon_ids =  map(lambda exon: exon.exon_id, all_exons)
                    if not exon.covering_exon in all_exon_ids:
                        bad_exon.add(exon_id)
                        
        # which transcripts seem to be completely ok?
        if verbose: print  "reconstructing alt splice almts for "
        if verbose: print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
        if verbose: print "there are ", len(tr_w_ccds), " transscripts with ccds"

        # get the gene_sequence
        ret = get_gene_seq(acg, cursor, gene_id, species)
        [gene_seq, canonical_exon_pepseq, file_name, seq_name, seq_region_start, seq_region_end]  = ret
        output_seq    = {}
        global_boundaries = []
        local_boundaries  = {}



        # sort exons by the order in which they appear in the gene
        all_exons.sort(key=lambda exon: exon.start_in_gene)


        # a bit of a cleanup
        for exon in all_exons:
            cleanup_endphase (cursor, exon)


        # check if any of the translations is complete:
        no_ok_transcripts = True
        for [tr_id, tr_stable] in tr_w_ccds:
            tr_exon_ids =  transcript_id2exon_ids (cursor, tr_id)
            if bad_exon & set(tr_exon_ids): continue

            if verbose: print tr_stable, " ok "
            no_ok_transcripts = False

        if no_ok_transcripts:
            if verbose: print " no ok transcripts found"
            continue

        # main loop
        cary = "" # for patching up codons split by intron
        for [tr_id, tr_stable] in tr_w_ccds:
            tr_exon_ids =  transcript_id2exon_ids (cursor, tr_id)
            if bad_exon & set(tr_exon_ids): continue

            # translation is from where to where?
            ret = get_translation_coords (cursor, tr_id)
            if not ret:
                continue
            [seq_start, start_exon_id, seq_end, end_exon_id] = ret
            for exon in all_exons:
                if exon.exon_id == start_exon_id: start_exon=exon
                if exon.exon_id == end_exon_id:   end_exon=exon
           
            transl_start_in_gene = start_exon.start_in_gene + seq_start
            transl_end_in_gene   =   end_exon.start_in_gene + seq_end
                

            local_boundaries[tr_stable] = []
            output_seq[tr_stable] = "-"*len(gene_sequence)
            output_seq[tr_stable+"_pep"] = "-"*len(gene_sequence)
            transl_end = ""

            for exon in all_exons:
                if not exon.exon_id in tr_exon_ids: continue
                
                start       = exon.start_in_gene
                start_flank = exon.start_in_gene - flank_length
                if start_flank  < 0: 
                    start_flank  = 0
                else:
                    if not start_flank-1 in global_boundaries: global_boundaries.append(start_flank-1)
                    local_boundaries[tr_stable].append(start_flank)

                end       = exon.end_in_gene
                end_flank = exon.end_in_gene + flank_length
                if end_flank > len(gene_sequence): 
                    end_flank = len(gene_sequence)
                else:
                    if not end_flank in global_boundaries: global_boundaries.append(end_flank)
                    local_boundaries[tr_stable].append(end_flank)
                
                tmp_dna  = output_seq[tr_stable][:start_flank]  + gene_sequence[start_flank:start].lower()
                tmp_dna += gene_sequence[start:end]
                tmp_dna += gene_sequence[end:end_flank].lower() + output_seq[tr_stable][end_flank:]

                output_seq[tr_stable] = tmp_dna


                #################################################
                # now try and handle translation to protein
                prev_transl_end = transl_end

                # where does translation start:
                if exon.end_in_gene < transl_start_in_gene:
                    transl_start = -1
                elif exon.exon_id == start_exon_id:
                    # if this is the first exon, the transl start given above
                    transl_start =  exon.start_in_gene+seq_start-1
                else:
                    # otherwise it is the exon start - except that if this is not the
                    # first exon and the codon is split, we want to start with the
                    # translation of the stitched up exon
                    transl_start = exon.start_in_gene
                    start_flank  = exon.phase

                # where does translation end: 
                if exon.start_in_gene >  transl_end_in_gene:
                    transl_end  = -1
                elif exon.exon_id == end_exon_id:
                    # if this is the first exon, the transl start given above
                    transl_end = exon.start_in_gene+seq_end
                else:
                    # otherwise it is the exon start - except that if this is not the
                    # first exon and the codon is split, we want to start with the
                    # translation of the stitched up exon
                    transl_end  = exon.end_in_gene - exon.end_phase+1
                    end_flank   = exon.end_phase


                if transl_start < 0 or transl_end < 0 :
                     continue

                if exon.phase > 0 and  prev_transl_end:
                    cary = gene_sequence[prev_transl_end:prev_transl_end+exon.phase]
                else:
                    cary = ""

                [phase, pepseq] = translate (cary + gene_sequence[transl_start:transl_end], 
                                             0,  mitochondrial, strip_stop = False)
                prev_transl_end = transl_end

                pepseq_padded = ""
                for aa in pepseq:
                    pepseq_padded += "-"+aa+"-"

                pepseq_name = tr_stable+"_pep"

                tmp_pep  = output_seq[pepseq_name][:transl_start-len(cary)] 
                tmp_pep += pepseq_padded
                tmp_pep += output_seq[pepseq_name][transl_end:]

                output_seq[pepseq_name] = tmp_pep



        global_boundaries.sort()
        for [tr_id, tr_stable] in tr_w_ccds:
            seq =  output_seq[tr_stable]
            tmp_seq   = ""
            prev_bdry = 0
            for bdry in global_boundaries:
                tmp_seq += seq[prev_bdry:bdry] 
                if bdry >= len(seq): continue
                if bdry in local_boundaries[tr_stable]:
                    marker = "-Z-"
                else:
                    marker = "---" 
                tmp_seq += marker 

                prev_bdry = bdry

            output_seq[tr_stable] = tmp_seq

            pepseq_name = tr_stable+"_pep"
            seq =  output_seq[pepseq_name]
            tmp_seq   = ""
            prev_bdry = 0
            for bdry in global_boundaries:
                tmp_seq += seq[prev_bdry:bdry] 
                if bdry >= len(seq): continue
                if bdry in local_boundaries[tr_stable]: # note here
                    marker = "-Z-"
                else:
                    marker = "---" 
                tmp_seq += marker 

                prev_bdry = bdry

            output_seq[pepseq_name] = tmp_seq


        output_seq = strip_gaps(output_seq)


        # define the order in which we  want the sequences output
        name_order = []
        for [tr_id, tr_stable] in tr_w_ccds:
           pepseq_name = tr_stable+"_pep"
           name_order.append (pepseq_name)
           name_order.append (tr_stable)


        afa_fnm  = "{0}/{1}.afa".format(outdir, stable_gene_id)
        ret = output_fasta (afa_fnm, name_order, output_seq)

        print afa_fnm

    return True
Ejemplo n.º 31
0
def get_translated_region_talkative(cursor, gene_id, species):

    # get the region on the gene
    is_known = (species == 'homo_sapiens')
    ret = get_gene_region(cursor, gene_id, is_known)
    if ret:
        [gene_seq_id, gene_region_start, gene_region_end,
         gene_region_strand] = ret
    else:
        print "region not retrived for ", species, gene_id, species
        return []

    canonical_transcript_id = get_canonical_transcript_id(cursor, gene_id)
    transcript_ids = get_transcript_ids(cursor, gene_id)
    print transcript_ids
    print "canonical: ", canonical_transcript_id

    transl_region_start = gene_region_end
    transl_region_end = gene_region_start

    print "transl region start:", transl_region_start
    print "transl region end:", transl_region_end

    for [transcript_id, transcript_stable] in transcript_ids:

        qry = "SELECT seq_start, start_exon_id, seq_end, end_exon_id "
        qry += " FROM translation WHERE transcript_id=%d" % transcript_id
        rows = search_db(cursor, qry)
        if (not rows):
            continue
        exon_seq_start = rows[0][0]
        start_exon_id = rows[0][1]
        exon_seq_end = rows[0][2]
        end_exon_id = rows[0][3]

        print
        if transcript_id == canonical_transcript_id:
            print "canonical: "
        print "transcript id: ", transcript_id
        print "start exon id:", start_exon_id, "transl start (in the exon) ", exon_seq_start
        print "end exon id:", end_exon_id, "transl end (in the exon)", exon_seq_end

        if (gene_region_strand > 0):
            start = {}

            start[start_exon_id] = get_exon_start(cursor, start_exon_id)
            start[end_exon_id] = get_exon_start(cursor, end_exon_id)

            this_translation_region_start = start[
                start_exon_id] + exon_seq_start - 1
            this_translation_region_end = start[end_exon_id] + exon_seq_end - 1

        else:
            end = {}

            end[start_exon_id] = get_exon_end(cursor, start_exon_id)
            end[end_exon_id] = get_exon_end(cursor, end_exon_id)

            this_translation_region_start = end[end_exon_id] - exon_seq_end + 1
            this_translation_region_end = end[
                start_exon_id] - exon_seq_start + 1

        if (this_translation_region_start <= transl_region_start):
            transl_region_start = this_translation_region_start

        if (this_translation_region_end >= transl_region_end):
            transl_region_end = this_translation_region_end

    return
Ejemplo n.º 32
0
def pep_seqs (cursor, gene_id, exons):
    

    for exon in exons:
        #####################################                
        if (not exon.is_coding):
            if verbose: print exon.exon_id,  "is not coding "
            continue
        if (exon.covering_exon > 0):
            if verbose: print exon.exon_id,  "has covering exon"
            continue 
        exon_seqs = get_exon_seqs(cursor, exon.exon_id, exon.is_known)
        if (not exon_seqs):
            if verbose: print exon.exon_id,  "no exon_seqs"
            continue                   
        [exon_seq_id, pepseq, pepseq_transl_start, 
         pepseq_transl_end, left_flank, right_flank, dna_seq] = exon_seqs
        if len(dna_seq)<4:
            if verbose: print exon.exon_id,  "short dna"
            continue

        #####################################                
        mitochondrial        = is_mitochondrial(cursor, gene_id)
        [seq_start, seq_end] = translation_bounds (cursor, exon.exon_id, verbose)
        if verbose: print " ** ", seq_start, seq_end
        dna_cropped          = crop_dna (seq_start, seq_end, dna_seq)
        if verbose: print " ** ", dna_cropped
        [offset, length_translated, pepseq, phase_corrected] = translate (dna_cropped, exon.phase, mitochondrial, verbose)

        if ( offset < 0): #  translation failure; usually some short pieces (end in pos 4 and such)
            if verbose: 
                print exon.exon_id,  "translation failure"
                print "mitochondrial:", mitochondrial
                print seq_start, seq_end
            continue

        if seq_start is None: seq_start = 1
        if seq_start == 0: seq_start = 1
        start = seq_start+offset-1
        end   = start + length_translated

        dnaseq  = Seq (dna_seq[start:end], generic_dna)
        if (mitochondrial):
            pepseq2 = dnaseq.translate(table="Vertebrate Mitochondrial").tostring()
        else:
            pepseq2 = dnaseq.translate().tostring()

        if (not pepseq == pepseq2):
            start = -10
            end   = -10
            
        if verbose: 
            print exon.exon_id
            print "pep from translate:", pepseq
            print "dna transl:", pepseq2
            print "start:" , start
            print "end:",  end
            print

        if True:
            qry  = "update exon_seq "
            qry += " set protein_seq   = '%s',  " %  pepseq
            qry += " pepseq_transl_start =  %d, " %  start
            qry += " pepseq_transl_end   =  %d  " %  end
            qry += " where exon_seq_id =  %d    " %  exon_seq_id
            rows = search_db (cursor, qry)
            if (rows):
                rows = search_db (cursor, qry, verbose = True)
                continue
Ejemplo n.º 33
0
def get_translated_region_talkative(cursor, gene_id, species):

    # get the region on the gene
    is_known = (species == 'homo_sapiens')
    ret = get_gene_region (cursor, gene_id, is_known)
    if  ret:
        [gene_seq_id,gene_region_start, gene_region_end, 
         gene_region_strand] = ret
    else:
        print "region not retrived for ", species, gene_id, species
        return []

    canonical_transcript_id = get_canonical_transcript_id (cursor, gene_id)
    transcript_ids = get_transcript_ids(cursor, gene_id)
    print transcript_ids
    print "canonical: ", canonical_transcript_id

    transl_region_start = gene_region_end
    transl_region_end   = gene_region_start

    print "transl region start:", transl_region_start
    print "transl region end:", transl_region_end

    for[ transcript_id, transcript_stable] in transcript_ids:
   
        qry  = "SELECT seq_start, start_exon_id, seq_end, end_exon_id " 
        qry += " FROM translation WHERE transcript_id=%d"  %  transcript_id
        rows = search_db (cursor, qry)
        if (not rows):
            continue
        exon_seq_start = rows[0][0]
        start_exon_id  = rows[0][1]
        exon_seq_end   = rows[0][2]
        end_exon_id    = rows[0][3]
        
        print
        if transcript_id == canonical_transcript_id:
            print "canonical: "
        print "transcript id: ", transcript_id
        print "start exon id:",  start_exon_id, "transl start (in the exon) ", exon_seq_start
        print "end exon id:",    end_exon_id,   "transl end (in the exon)", exon_seq_end
        

        if (gene_region_strand > 0):
            start = {}
 
            start[start_exon_id] = get_exon_start(cursor, start_exon_id)
            start[end_exon_id]   = get_exon_start(cursor, end_exon_id)

            this_translation_region_start = start[start_exon_id] + exon_seq_start - 1
            this_translation_region_end   = start[end_exon_id]   + exon_seq_end   - 1

        else: 
            end   = {}  

            end[start_exon_id] = get_exon_end (cursor, start_exon_id)
            end[end_exon_id]   = get_exon_end (cursor, end_exon_id)

            this_translation_region_start = end[end_exon_id]   - exon_seq_end   + 1
            this_translation_region_end   = end[start_exon_id] - exon_seq_start + 1

        if (this_translation_region_start <= transl_region_start):
            transl_region_start = this_translation_region_start
        
        if (this_translation_region_end >= transl_region_end):
            transl_region_end = this_translation_region_end

    return
Ejemplo n.º 34
0
def check_alt_splices (cursor, species, ensembl_db_name):

    
    print "############################"
    print 'checking alt splicing in ', species

    qry = "use " + ensembl_db_name[species]
    search_db(cursor, qry)
    gene_ids = get_gene_ids (cursor, biotype='protein_coding', is_known=1)

    no_cover_and_no_seq = 0  
    no_cover_and_no_dna_seq = 0  
    no_seq_info_in_database = 0
    all_ok   = 0   
    cover_already_present  = 0
    cover_not_in_exon_set  = 0     
    cov_exon_not_in_ccds   = 0 
    genes_w_ccds           = 0
    tot_exons = 0
        
    #for gene_id in gene_ids[:100]:
    #for gene_id in [413198]:
    for count in range(1000):
        gene_id = choice (gene_ids)

        #print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
        transcript_ids = get_transcript_ids(cursor, gene_id)

        tr_w_ccds = []
        for [tr_id, tr_stable] in transcript_ids:
            ccds = check_ccds (cursor, tr_stable)
            if not ccds: continue
            tr_w_ccds.append([tr_id, tr_stable])

        if not tr_w_ccds: continue

        genes_w_ccds += 1

        # get all exons for this gene
        all_exons    = gene2exon_list (cursor, gene_id)
        
        exons_w_ccds = set([]) # get the unique_ids

        # find exons which are on the ccds list
        for [tr_id, tr_stable] in tr_w_ccds:
            exon_ids =  transcript_id2exon_ids (cursor, tr_id)
            exons_w_ccds.update( set(exon_ids))
           
        # for these exons check sequence
        is_known=1
        for exon_id in exons_w_ccds:
            tot_exons += 1
            exon = get_exon      (cursor, exon_id, is_known)
            seq  = get_exon_seqs (cursor, exon_id, is_known)
            if not seq:
                #print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
                #print exon_id, " no seq", "covered: ", exon.covering_exon
                #exit (1)
                no_seq_info_in_database += 1
                continue
            [exon_seq_id, protein_seq, pepseq_transl_start, 
             pepseq_transl_end, left_flank, right_flank, dna_seq] = seq

            #print exon_id, exon_seq_id, 
            #print "  %7d   %7d  %7d  " % (exon.start_in_gene, exon.end_in_gene,  exon.covering_exon),
            
            if exon.covering_exon < 0:
                #print protein_seq
                if not protein_seq:
                    no_cover_and_no_seq += 1
                elif not dna_seq:
                    no_cover_and_no_dna_seq += 1
                else:
                    all_ok += 1
            else:
                if exon.covering_exon_known and exon.covering_exon in exons_w_ccds:
                    #print " <<<< "
                    cover_already_present += 1
                else:
                    all_exon_ids =  map(lambda exon: exon.exon_id, all_exons)
                    if not exon.covering_exon in all_exon_ids:
                        cover_not_in_exon_set += 1
                        print "cover_not_in_exon_set: "
                        print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
                        print  exon_id, exon_seq_id, 
                        print "  %7d   %7d  %7d  " % (exon.start_in_gene, exon.end_in_gene,  exon.covering_exon)
                        #print covering_exon
                        print " ************"
                        for e in all_exons:
                            print e
                        exit (1)

                    elif not exon.covering_exon in exons_w_ccds:
                        cov_exon_not_in_ccds += 1
                        #print "covering exon is not in ccds set "
                       


    print "genes_w_ccds", genes_w_ccds
    print "tot_exons", tot_exons
    print "no_seq_info_in_database ",   no_seq_info_in_database
    print "all_ok",  all_ok 
    print "cover_already_present ", cover_already_present
    print "no_cover_and_no_seq   ", no_cover_and_no_seq 
    print "no_cover_and_no_dna_seq   ", no_cover_and_no_dna_seq 
    print "cov_exon_not_in_ccds",   cov_exon_not_in_ccds
    print "cover_not_in_exon_set ", cover_not_in_exon_set

    return True
Ejemplo n.º 35
0
def check_alt_splices(cursor, species, ensembl_db_name):

    print "############################"
    print 'checking alt splicing in ', species

    qry = "use " + ensembl_db_name[species]
    search_db(cursor, qry)
    gene_ids = get_gene_ids(cursor, biotype='protein_coding', is_known=1)

    no_cover_and_no_seq = 0
    no_cover_and_no_dna_seq = 0
    no_seq_info_in_database = 0
    all_ok = 0
    cover_already_present = 0
    cover_not_in_exon_set = 0
    cov_exon_not_in_ccds = 0
    genes_w_ccds = 0
    tot_exons = 0

    #for gene_id in gene_ids[:100]:
    #for gene_id in [413198]:
    for count in range(1000):
        gene_id = choice(gene_ids)

        #print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
        transcript_ids = get_transcript_ids(cursor, gene_id)

        tr_w_ccds = []
        for [tr_id, tr_stable] in transcript_ids:
            ccds = check_ccds(cursor, tr_stable)
            if not ccds: continue
            tr_w_ccds.append([tr_id, tr_stable])

        if not tr_w_ccds: continue

        genes_w_ccds += 1

        # get all exons for this gene
        all_exons = gene2exon_list(cursor, gene_id)

        exons_w_ccds = set([])  # get the unique_ids

        # find exons which are on the ccds list
        for [tr_id, tr_stable] in tr_w_ccds:
            exon_ids = transcript_id2exon_ids(cursor, tr_id)
            exons_w_ccds.update(set(exon_ids))

        # for these exons check sequence
        is_known = 1
        for exon_id in exons_w_ccds:
            tot_exons += 1
            exon = get_exon(cursor, exon_id, is_known)
            seq = get_exon_seqs(cursor, exon_id, is_known)
            if not seq:
                #print  gene_id,  gene2stable(cursor, gene_id), get_description (cursor, gene_id)
                #print exon_id, " no seq", "covered: ", exon.covering_exon
                #exit (1)
                no_seq_info_in_database += 1
                continue
            [
                exon_seq_id, protein_seq, pepseq_transl_start,
                pepseq_transl_end, left_flank, right_flank, dna_seq
            ] = seq

            #print exon_id, exon_seq_id,
            #print "  %7d   %7d  %7d  " % (exon.start_in_gene, exon.end_in_gene,  exon.covering_exon),

            if exon.covering_exon < 0:
                #print protein_seq
                if not protein_seq:
                    no_cover_and_no_seq += 1
                elif not dna_seq:
                    no_cover_and_no_dna_seq += 1
                else:
                    all_ok += 1
            else:
                if exon.covering_exon_known and exon.covering_exon in exons_w_ccds:
                    #print " <<<< "
                    cover_already_present += 1
                else:
                    all_exon_ids = map(lambda exon: exon.exon_id, all_exons)
                    if not exon.covering_exon in all_exon_ids:
                        cover_not_in_exon_set += 1
                        print "cover_not_in_exon_set: "
                        print gene_id, gene2stable(cursor,
                                                   gene_id), get_description(
                                                       cursor, gene_id)
                        print exon_id, exon_seq_id,
                        print "  %7d   %7d  %7d  " % (exon.start_in_gene,
                                                      exon.end_in_gene,
                                                      exon.covering_exon)
                        #print covering_exon
                        print " ************"
                        for e in all_exons:
                            print e
                        exit(1)

                    elif not exon.covering_exon in exons_w_ccds:
                        cov_exon_not_in_ccds += 1
                        #print "covering exon is not in ccds set "

    print "genes_w_ccds", genes_w_ccds
    print "tot_exons", tot_exons
    print "no_seq_info_in_database ", no_seq_info_in_database
    print "all_ok", all_ok
    print "cover_already_present ", cover_already_present
    print "no_cover_and_no_seq   ", no_cover_and_no_seq
    print "no_cover_and_no_dna_seq   ", no_cover_and_no_dna_seq
    print "cov_exon_not_in_ccds", cov_exon_not_in_ccds
    print "cover_not_in_exon_set ", cover_not_in_exon_set

    return True
Ejemplo n.º 36
0
def  feed_trivial_names (cursor, all_species):

    tax_id  = {}
    trivial = {}

    trivial['ailuropoda_melanoleuca'] = 'panda' 
    trivial['anas_platyrhynchos']     = 'duck'
    trivial['anolis_carolinensis']    = 'anole_lizard' 
    trivial['astyanax_mexicanus']     = 'blind_cavefish'
    trivial['bos_taurus']             = 'cow' 
    trivial['callithrix_jacchus']     = 'marmoset' 
    trivial['canis_familiaris']       = 'dog' 
    trivial['cavia_porcellus']        = 'guinea_pig' 
    trivial['choloepus_hoffmanni']    = 'sloth' 
    trivial['danio_rerio']            = 'zebrafish' 
    trivial['dasypus_novemcinctus']   = 'armadillo' 
    trivial['dipodomys_ordii']        = 'kangaroo_rat' 
    trivial['echinops_telfairi']      = 'madagascar_hedgehog' 
    trivial['equus_caballus']         = 'horse' 
    trivial['erinaceus_europaeus']    = 'european_hedgehog' 
    trivial['felis_catus']            = 'cat' 
    trivial['ficedula_albicollis']    = 'flycatcher'
    trivial['gadus_morhua']           = 'cod' 
    trivial['gallus_gallus']          = 'chicken' 
    trivial['gasterosteus_aculeatus'] = 'stickleback' 
    trivial['gorilla_gorilla']        = 'gorilla' 
    trivial['homo_sapiens']           = 'human' 
    trivial['ictidomys_tridecemlineatus']  = 'squirrel' 
    trivial['latimeria_chalumnae']         = 'coelacanth' 
    trivial['lepisosteus_oculatus']        = 'spotted_gar'
    trivial['loxodonta_africana']          = 'elephant' 
    trivial['macaca_mulatta']              = 'macaque' 
    trivial['macropus_eugenii']            = 'wallaby' 
    trivial['meleagris_gallopavo']         = 'turkey' 
    trivial['microcebus_murinus']          = 'lemur' 
    trivial['monodelphis_domestica']       = 'opossum' 
    trivial['mus_musculus']                = 'mouse' 
    trivial['mustela_putorius_furo']       = 'ferret' 
    trivial['myotis_lucifugus']            = 'bat' 
    trivial['nomascus_leucogenys']         = 'gibbon' 
    trivial['ochotona_princeps']           = 'pika' 
    trivial['oreochromis_niloticus']       = 'tilapia' 
    trivial['ornithorhynchus_anatinus']    = 'platypus' 
    trivial['oryctolagus_cuniculus']       = 'rabbit' 
    trivial['oryzias_latipes']             = 'medaka' 
    trivial['otolemur_garnettii']          = 'galago_lemur' 
    trivial['ovis_aries']                  = 'sheep'
    trivial['pan_troglodytes']             = 'chimpanzee' 
    trivial['papio_anubis']                = 'baboon' 
    trivial['pelodiscus_sinensis']         = 'turtle' 
    trivial['petromyzon_marinus']          = 'lamprey' 
    trivial['poecilia_formosa']            = 'amazon_molly'
    trivial['pongo_abelii']                = 'orangutan' 
    trivial['procavia_capensis']           = 'hyrax' 
    trivial['pteropus_vampyrus']           = 'flying_fox' 
    trivial['rattus_norvegicus']           = 'rat' 
    trivial['sarcophilus_harrisii']        = 'tasmanian_devil' 
    trivial['sorex_araneus']               = 'european_shrew' 
    trivial['sus_scrofa']                  = 'pig' 
    trivial['taeniopygia_guttata']         = 'zebra_finch' 
    trivial['takifugu_rubripes']           = 'fugu' 
    trivial['tarsius_syrichta']            = 'tarsier' 
    trivial['tetraodon_nigroviridis']      = 'pufferfish' 
    trivial['tupaia_belangeri']            = 'tree_shrew' 
    trivial['tursiops_truncatus']          = 'dolphin' 
    trivial['vicugna_pacos']               = 'alpaca' 
    trivial['xenopus_tropicalis']          = 'xenopus' 
    trivial['xiphophorus_maculatus']       = 'platyfish' 



    db_name = get_compara_name (cursor)
    if (not db_name):
        print "compara db not found"
        exit(1)
    qry = "use %s " % db_name
    search_db (cursor, qry)
    for species in all_species:
        tax_id[species] = species2taxid (cursor, species)

    # switch to ncbi taxonomy database
    db_name = get_ncbi_tax_name (cursor)
    if (not db_name):
        print "ncbi taxonomy db not found"
        exit(1)

    qry = "use %s " % db_name
    search_db (cursor, qry)
    for species in all_species:
        if trivial.has_key(species):
            fixed_fields  = {}
            update_fields = {}
            fixed_fields ['tax_id']     = tax_id[species]
            fixed_fields ['name_class'] = 'trivial'
            update_fields['name_txt']   = trivial[species]
            store_or_update (cursor, 'names', fixed_fields, update_fields)
        else:
            print "trivial for ", species, " not found "
            trivial[species] = ""

    return True
Ejemplo n.º 37
0
def  feed_name_shorthands (cursor, all_species):

    short = {}
    short['ailuropoda_melanoleuca'] = 'AME'
    short['anas_platyrhynchos']     = 'APL'
    short['anolis_carolinensis']    = 'ACA'
    short['astyanax_mexicanus']     = 'AMX'
    short['bos_taurus']             = 'BTA'
    short['callithrix_jacchus'] = 'CJA'
    short['canis_familiaris'] = 'CAF'
    short['cavia_porcellus'] = 'CPO'
    short['choloepus_hoffmanni'] = 'CHO'
    short['danio_rerio'] = 'DAR'
    short['dasypus_novemcinctus'] = 'DNO'
    short['dipodomys_ordii'] = 'DOR'
    short['echinops_telfairi'] = 'ETE'
    short['equus_caballus'] = 'ECA'
    short['erinaceus_europaeus'] = 'EEU'
    short['felis_catus'] = 'FCA'
    short['ficedula_albicollis'] = 'FAL'
    short['gadus_morhua'] = 'GMO'
    short['gallus_gallus'] = 'GAL'
    short['gasterosteus_aculeatus'] = 'GAC'
    short['gorilla_gorilla'] = 'GGO'
    short['homo_sapiens'] = ''
    short['ictidomys_tridecemlineatus'] = 'STO'
    short['latimeria_chalumnae'] = 'LAC'
    short['lepisosteus_oculatus'] = 'LOC'
    short['loxodonta_africana'] = 'LAF'
    short['macaca_mulatta'] = 'MMU'
    short['macropus_eugenii'] = 'MEU'
    short['meleagris_gallopavo'] = 'MGA'
    short['microcebus_murinus'] = 'MIC'
    short['monodelphis_domestica'] = 'MOD'
    short['mus_musculus'] = 'MUS'
    short['mustela_putorius_furo'] = 'MPU'
    short['myotis_lucifugus'] = 'MLU'
    short['nomascus_leucogenys'] = 'NLE'
    short['ochotona_princeps'] = 'OPR'
    short['oreochromis_niloticus'] = 'ONI'
    short['ornithorhynchus_anatinus'] = 'OAN'
    short['oryctolagus_cuniculus'] = 'OCU'
    short['oryzias_latipes'] = 'ORL'
    short['ovis_aries'] = 'OAR'
    short['otolemur_garnettii'] = 'OGA'
    short['pan_troglodytes'] = 'PTR'
    short['papio_anubis'] = 'PAN'
    short['poecilia_formosa'] = 'PFO'
    short['pelodiscus_sinensis'] = 'PSI'
    short['petromyzon_marinus'] = 'PMA'
    short['pongo_abelii'] = 'PPY'
    short['procavia_capensis'] = 'PCA'
    short['pteropus_vampyrus'] = 'PVA'
    short['rattus_norvegicus'] = 'RNO'
    short['sarcophilus_harrisii'] = 'SHA'
    short['sorex_araneus'] = 'SAR'
    short['sus_scrofa'] = 'SSC'
    short['taeniopygia_guttata'] = 'TGU'
    short['takifugu_rubripes'] = 'TRU'
    short['tarsius_syrichta'] = 'TSY'
    short['tetraodon_nigroviridis'] = 'TNI'
    short['tupaia_belangeri'] = 'TBE'
    short['tursiops_truncatus'] = 'TTR'
    short['vicugna_pacos'] = 'VPA'
    short['xenopus_tropicalis'] = 'XET'
    short['xiphophorus_maculatus'] = 'XMA'


    db_name = get_compara_name (cursor)
    qry = "use %s " % db_name
    search_db (cursor, qry)

    table = 'species_name_shorthands'
    # if the table does not exist, make it
    if not check_table_exists (cursor, db_name, table):
        qry  = "CREATE TABLE " + table + "  (id INT(10) PRIMARY KEY AUTO_INCREMENT)"
        rows = search_db (cursor, qry)
        if (rows): return False

        qry = "ALTER TABLE %s  ADD %s VARCHAR(100)" % (table, 'species')
        rows = search_db (cursor, qry)
        if (rows): return False
        qry = "ALTER TABLE %s  ADD %s VARCHAR(10)" % (table, 'shorthand')
        rows = search_db (cursor, qry)
        if (rows): return False


    for species in all_species:
        if short.has_key(species):
            fixed_fields  = {}
            update_fields = {}
            fixed_fields  ['species']   = species
            update_fields ['shorthand'] = short[species]
            store_or_update (cursor, table, fixed_fields, update_fields)
        else:
            print "short for ", species, " not found "
            short[species] = ""
Ejemplo n.º 38
0
def main():

    parameter = {}
    # in case I ever have to handle multiple versions of ensembl
    # (but for now I don't have enough space)
    # note though that there are functions in el_utils/mysql.py that assume
    # that whatever ensembl stuff is available to the mysql server corresponds to the same release 
    release_number = '76'
    parameter['ensembl_release_number'] = release_number
    parameter['blastp_e_value']         = "1.e-10" # it will be used as a string  when fmting the blastp cmd
    parameter['min_accptbl_exon_sim']   = 0.33333 #minimum acceptable exon similarity

    dir_path = {}
    dir_path['ensembl_fasta'] = '/mnt/ensembl-mirror/release-'+release_number+'/fasta'
    # local juggling of data from one database base to the other
    dir_path['afs_dumps']     = '/afs/bii.a-star.edu.sg/dept/biomodel_design/Group/ivana/'
    dir_path['afs_dumps']    += 'ExoLocator/results/dumpster'
    dir_path['resources']     = '/afs/bii.a-star.edu.sg/dept/biomodel_design/Group/ivana/'
    dir_path['resources']    += 'pypeworks/exolocator/resources'
    dir_path['scratch']       = '/tmp'
    dir_path['maxentscan']    = '/afs/bii.a-star.edu.sg/dept/biomodel_design/Group/ivana/'
    dir_path['maxentscan']   += 'pypeworks/exolocator/pl_utils/maxentscan'

    util_path = {}
    util_path['mafft']    = '/usr/bin/mafft'
    util_path['blastall'] = '/usr/bin/blastall'
    util_path['fastacmd'] = '/usr/bin/fastacmd'
    util_path['sw#']      = '/usr/bin/swsharp'
    util_path['usearch']  = '/usr/bin/usearch'
    util_path['score3']   = dir_path['maxentscan'] + '/score3.pl'
    util_path['score5']   = dir_path['maxentscan'] + '/score5.pl'

    if 1:
        # check if the paths are functioning (at this point at least)
        for util in util_path.values():
            if (not os.path.exists(util)):
                print util, " not found "
                sys.exit (1)

        for dir in dir_path.values():
            if (not os.path.exists(dir)):
                print dir, " not found "
                sys.exit (1)
            if (not os.path.isdir (dir)):
                print dir, " is not a directory "
                sys.exit (1)
            
    db     = connect_to_mysql()
    cursor = db.cursor()


    #######################################################
    # check if the config db exists -- if not, make it
    db_name   = "exolocator_config"
    qry  = "show databases like'%s'" % db_name
    rows = search_db (cursor, qry)
    if (not rows):
        print db_name, "database not found"
        qry = "create database %s " % db_name
        rows = search_db (cursor, qry)
        if (rows):
            print "some problem creating the database ..."
            rows = search_db (cursor, qry, verbose = True)
    else:
        print db_name, "database found"

    qry = "use %s " % db_name
    search_db (cursor, qry)
        
    # make tables
    for table in ['util_path', 'dir_path', 'parameter']:
        if ( check_table_exists (cursor, db_name, table)):
            print table, " found in ", db_name
        else:
            print table, " not found in ", db_name
            make_table (cursor, table)
   
    # fill util, dir and path tables 
    fixed_fields  = {}
    update_fields = {}
    for [name, path] in util_path.iteritems():
        fixed_fields['name']  = name
        update_fields['path'] = path
        store_or_update (cursor, 'util_path', fixed_fields, update_fields)

    fixed_fields  = {}
    update_fields = {}
    for [name, path] in dir_path.iteritems():
        fixed_fields['name'] = name
        update_fields['path'] = path
        store_or_update (cursor, 'dir_path', fixed_fields, update_fields)

    fixed_fields  = {}
    update_fields = {}
    for [name, value] in parameter.iteritems():
        fixed_fields['name']  = name
        update_fields['value'] = value
        store_or_update (cursor, 'parameter', fixed_fields, update_fields)

    #######################################################
    # add trivial names to ncbi_taxonomy.names
    [all_species, ensembl_db_name] = get_species (cursor)
    feed_trivial_names (cursor, all_species)

    #######################################################
    # add species shorthands (used in ENS* names formation)
    # though we will not needed unit the paralogue alignment reconstruction point)
    feed_name_shorthands (cursor, all_species)

    cursor.close()
    db.close()