API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2016
167
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 34.52 KB | None | 0 0
raw download clone embed print report
  1. """Maker | Gemaakte functie of taak             | Datum"""
  2. """Diego | database structuur opzetten          | 11-01-15"""
  3. """Diego | downloaden proteomen                 | 11-01-15"""
  4. """Yoena | samenvoegen proteomen                | 11-01-15"""
  5. """Yoena | eiwit info in de database            | 11-01-15"""
  6. """Yoena | twogs en cogs maken                  | 11-01-15"""
  7. """Diego | queries                              | 11-01-15"""
  8.  
  9. """Dit programma, download proteomen van de volgende tien schimmels:
  10.   Aspergillus_fumigatus, Aspergillus_nidulans, Aspergillus_oryzae,
  11.   Melampsora_larici-populina, Mixia_osmundae, Neurospora_crassa,
  12.   Penicillium_canescens, Phanerochaete_chrysosporium,
  13.   Pleurotus_ostreatus, Saccharomyces_cerevisiae] uit de databases
  14.   NCBI, SWISSPROT, Ensembl, JGI, Trembl voor een zo totaal mogelijk
  15.   samengesteld proteom voor elk organisme. Na het downloaden en
  16.   samenvoegen van de proteomen worden alle eiwitten uit de proteomen
  17.   (met een eigen naam geving) in een eerdere gecreerde database
  18.   toegevoegt. Dan worden alle proteomen tegen elkaar geblast om COG's
  19.   te maken. Het maken van deze COG's wordt gedaan, door eerst TWOG's
  20.   (Best Directional Hits) te maken en daarna van deze TWOG's
  21.   COG's te maken door ze te koppelen. Als laatst worden de COG's
  22.   door middel van een COG nummer aan de database toegevoegd.
  23. """
  24.  
  25.  
  26. """Hieronder worden verschillende modules geimporteerd.
  27.   De module os wordt geimporteerd zodat er in dit python bestand
  28.   gebruik kan worden gemaakt van bash (de Unix commandline) met de
  29.   module system van os.
  30.   De psycopg2 wordt geimporteerd zodat er connectie gemaakt kan
  31.   worden met de postgres server en een database gecreerd en
  32.   vullen kan worden.
  33.   De methode collections van de module Counter wordt
  34.   geimporteerd zodat er geteld kan worden hoevaak een
  35.   item in een lijst voorkomt. (Dit wordt gebuikt bij het
  36.   maken van twogs, in de functie proteom_naar_twogs.)"""
  37. import os
  38. import psycopg2
  39. from collections import Counter
  40.  
  41.  
  42.  
  43. def verbinding():
  44.     """Zorgt voor de verbinding tussen python en postgresql
  45.    Deze functie maakt gebruik van de module psycopg2 en maakt de
  46.    verbinding tussen python en postgresql. In de conn_string
  47.    staan de inlog gevevens voor de toegang tot de database dit
  48.    wordt door middel van een try en except statement ingevoerd
  49.    als het word goedegekeurd wordt de conn en cursor teruggestuurd
  50.    voor gebruik bij het aanmaken/vullen/update etc van de database
  51.    anders wordt het programma gestopt door middel van een exit()
  52.    statement.
  53.     Return value(s):
  54.         waneer de connectie gelukt is.
  55.        *conn, de connectie met de postgres server
  56.         *cursor, de cursor van de postgres server
  57.    """
  58.     conn_string = '''host=\'localhost\' dbname=\'postgres\'
  59.    user=\'gebruikersnaam\' password=\'wachtwoord\''''
  60.     try:
  61.         conn = psycopg2.connect(conn_string)
  62.         cursor = conn.cursor()
  63.         print 'Connected! with Database'
  64.         return conn, cursor
  65.     except:
  66.         print 'Connectie mislukt!'
  67.         exit()
  68.  
  69.  
  70. def verbinding_database_stop(vs_conn, vs_cursor):
  71.     """
  72.    Verbinding verbreken met de database.
  73.     Parameter(s):
  74.        *vs_conn, de connectie met de postgres server
  75.     *vs_cursor, de cursor van de postgres server
  76.    """
  77.     vs_conn.commit()
  78.     vs_cursor.close()
  79.     vs_conn.close()
  80.    
  81.  
  82. def droptabel(d_cursor):
  83.     """
  84.    Verwijderen van de tabellen in de database.
  85.    De cursor wordt gebruikt voor het doorvoeren van de queries
  86.     Parameter(s):
  87.            *d_cursor, de cursor van de postgres server.
  88.            Hiermee kunnen execute statements uitgevoert worden
  89.            voor de server.
  90.    """
  91.     d_cursor.execute("""DROP TABLE IF EXISTS "Eiwit_Info" CASCADE""")
  92.     d_cursor.execute("""DROP TABLE IF EXISTS "Twog_Info" CASCADE""")
  93.    
  94.  
  95. def twoginfo(tw_cursor):
  96.     """
  97.    Aanmaken van de twoginfo tabel in de database.
  98.    De cursor wordt gebruikt voor het doorvoeren van de queries
  99.     Parameter(s):
  100.         *tw_cursor, de cursor van de postgres server.
  101.         Hiermee kunnen execute statements uitgevoert
  102.         worden voor de server.
  103.    """
  104.     tw_cursor.execute("""CREATE TABLE "Twog_Info"
  105.    ("Twog ID" VARCHAR PRIMARY KEY, "Eiwit ID 1" VARCHAR,
  106.    "Eiwit ID 2" VARCHAR, "Cog Nummer" VARCHAR)""")
  107.  
  108.  
  109. def eiwit_info(e_cursor):
  110.     """
  111.    Aanmaken van de eiwitinfo tabel in de database.
  112.    De cursor wordt gebruikt voor het doorvoeren van de queries
  113.     Parameter(s):
  114.         *e_cursor, de cursor van de postgres server.
  115.         Hiermee kunnen execute statements uitgevoert
  116.         worden voor de server.
  117.    """
  118.     e_cursor.execute("""CREATE TABLE "Eiwit_Info"(
  119.    "Eiwit ID" VARCHAR UNIQUE NOT NULL PRIMARY KEY,
  120.    "Organisme" TEXT NOT NULL,
  121.    "Stam" TEXT NOT NULL,
  122.    "Cog Nummer" VARCHAR NOT NULL,
  123.    "AA Sequentie" VARCHAR NOT NULL,
  124.    "Gegevens SwissProt" VARCHAR,
  125.    "Gegevens JGI" VARCHAR,
  126.    "Gegevens TrEMBL" VARCHAR,
  127.    "Gegevens Ensembl" VARCHAR,
  128.    "Gegevens NCBI" VARCHAR
  129.                   )""")
  130.                    
  131.  
  132. def database_structuur_opzetten():
  133.     """
  134.    Opzetten van de database structuur.
  135.    In deze functie wordt als eerst de connectie tot stand gebracht
  136.    met de database. De tabellen die hierin staan worden verwijderd in
  137.    de droptabel functie. De volgende 2 functies die worden
  138.    aangeroepen gaan over het maken van de tabellen die aanwezig
  139.    zullen zijn in de database. (eiwit_info en twog_info).
  140.     Return value(s):
  141.        *conn, de connectie met de postgres server
  142.     *cursor, de cursor van de postgres server
  143.    """
  144.     conn, cursor = verbinding()
  145.     droptabel(cursor)
  146.     eiwit_info(cursor)
  147.     twoginfo(cursor)
  148.     return conn, cursor
  149.  
  150.  
  151. def voorbereiden_swissprot_trembl_download():
  152.     """Deze functie, voorbereiden_swissprot_trembl_download,
  153.   download alle eiwitten die beschikbaar zijn op SWISSPROT
  154.   en Trembl. Deze download wordt gedaan met een wget.
  155.   Return value(s):
  156.       * uniprot_treble_bestanden, een dictionary met de naam
  157.        van de database (SWISSPROT of Trembl) en het bestand
  158.        dat gedownload is voor deze database. Van deze dictionary
  159.        wordt gebruik gemaakt in de functie, swissprot_tremble_download
  160.    """
  161.     uniprot_treble_bestanden = {"SWISSPROT": "uniprot_sprot.fasta", "Trembl": "uniprot_trembl.fasta"}
  162.     for bestand in uniprot_treble_bestanden.values():
  163.         os.system("wget ftp://ftp.uniprot.org/pub/databases/uniprot/knowledgebase/"+bestand+".gz")
  164.         os.system("gunzip "+bestand+".gz")
  165.     return uniprot_treble_bestanden
  166.  
  167.  
  168. def ncbi_download(organisme):
  169.     """
  170.    In deze funtie worden de proteomen gedownload van de verschillende
  171.    organismen. Het grootste gedeelte hiervban gebeurt in de else
  172.    statement, maar Saccharomyces_cerevisiae stond op een andere plek
  173.    in de ftp database. Door middel van de 'os' module worden met wget
  174.    de proteomen opgehaald. Deze worden uitgepakt en gegevens die van
  175.    belang waren voor het downloaden worden weer verwijderd.
  176.       * organisme, de naam van het organsime
  177.    """
  178.     if organisme is 'Saccharomyces_cerevisiae':
  179.         os.system('''wget ftp://ftp.ncbi.nih.gov/genomes/genbank/fungi/Saccharomyces_cerevisiae/reference/GCA_000146045.2_R64/GCA_000146045.2_R64_protein.faa.gz''')
  180.     else:
  181.         os.system('''wget -O - ftp://ftp.ncbi.nih.gov/genomes/genbank/fungi/%s/representative/ | egrep href | awk -F '"' '{print $2}' > link.txt'''%(organisme))
  182.         os.system('''wget -O -  %s/ | egrep *protein.faa.gz | awk -F '"' '{print $2}'> link.txt'''%(open('link.txt', 'r').readline().rstrip()))
  183.         os.system('''wget %s'''%(open('link.txt', 'r').readline().rstrip()))
  184.     os.system('''gunzip *''')
  185.     os.system('''mv *protein.faa %s.ncbi.fa'''%(organisme))
  186.     os.system('''rm link*''')
  187.  
  188.  
  189. def ensembl_download(organisme):
  190.     """
  191.    In deze funtie worden de proteomen gedownload van de verschillende
  192.    organismen. Het grootste gedeelte hiervban gebeurt in de else
  193.    statement, maar Mixia_osmundae en Pleurotus_ostreatus stond op een
  194.    andere plek in de ftp database. Door middel van de 'os' module
  195.    worden met wget de proteomen opgehaald. Deze worden uitgepakt
  196.    en gegevens die van belang waren voor het downloaden worden weer
  197.    verwijderd.
  198.       * organisme, de naam van het organsime
  199.    """
  200.     if organisme is 'Mixia_osmundae':
  201.         os.system('''wget ftp://ftp.ensemblgenomes.org/pub/fungi/current/fasta/fungi_basidiomycota1_collection/mixia_osmundae_iam_14324/pep/Mixia_osmundae_iam_14324.GCA_000241205.2.30.pep.all.fa.gz''')
  202.     elif x is 'Pleurotus_ostreatus':
  203.         os.system('''wget ftp://ftp.ensemblgenomes.org/pub/fungi/current/fasta/fungi_basidiomycota1_collection/pleurotus_ostreatus_pc15/pep/Pleurotus_ostreatus_pc15.GCA_000697685.1.30.pep.all.fa.gz''')
  204.     else:
  205.         os.system('''wget -O - ftp://ftp.ensemblgenomes.org/pub/fungi/current/fasta/%s/pep/ | egrep href | egrep fa.gz | awk -F '"' '{print $2}' > link.txt'''%(organisme.lower()))
  206.         os.system('''wget %s'''%(open('link.txt', 'r').readline().rstrip()))
  207.     os.system('''gunzip *''')
  208.     os.system('''mv *pep.all* %s.ensembl.fa'''%(organisme))
  209.     os.system('''rm link*''')
  210.    
  211.  
  212.  
  213. def swissprot_tremble_download(uniprot_treble_bestanden, organisme):
  214.     """Deze functie, swissprot_tremble_download, filterd de bijbehorende
  215.    eiwitten van het binnen gekregen organisme uit de eerder gedownloaden
  216.    bestanden van SWISSPROT en Trembl. Deze worden geschreven naar
  217.    een bestand met de volgende opbouw: 'organisme naam'_'database'.
  218.    Parameters(s):
  219.       * uniprot_treble_bestanden, een dictionary met de naam
  220.       van de database (SWISSPROT of Trembl) en het bestand
  221.       dat gedownload is voor deze database.
  222.       * organisme, de naam van het organsime waar op dat moment
  223.       het SWISSPROT en Trembl proteom moet gedownload (gefilterd)
  224.       worden
  225.    """
  226.     swissprot_tremble_dict = {"Aspergillus_fumigatus": "OS=Neosartorya fumigata \(strain ATCC MYA-4609 / Af293 / CBS 101355 / FGSC A1100\)",
  227.     "Aspergillus_nidulans": "OS=Emericella nidulans \(strain FGSC A4 / ATCC 38163 / CBS 112.46 / NRRL 194 / M139\)",
  228.     "Aspergillus_oryzae": "OS=Aspergillus oryzae \(strain ATCC 42149 / RIB 40\)",
  229.     "Melampsora_laricis-populina": "Melampsora larici-populina \(strain 98AG31 / pathotype 3-4-7\)",
  230.     "Mixia_osmundae": "Mixia osmundae \(strain CBS 9802 / IAM 14324 / JCM 22182 / KY 12970\)",
  231.     "Neurospora_crassa": "Neurospora crassa \(strain ATCC 24698 / 74-OR23-1A / CBS 708.71 / DSM 1257 / FGSC 987\)",
  232.     "Penicillium_canescens": "OS=Penicillium canescens",
  233.     "Phanerochaete_chrysosporium": "OS=Phanerochaete chrysosporium", "Pleurotus_ostreatus": "OS=Pleurotus ostreatus",
  234.     "Saccharomyces_cerevisiae": "OS=Saccharomyces cerevisiae \(strain ATCC 204508 / S288c\)"}
  235.     for bestand in uniprot_treble_bestanden:
  236.         os.system("cat "+uniprot_treble_bestanden[bestand]+" | tr \"\\n\" \"@\" | sed 's/>/\\n>/g' | egrep \""+swissprot_tremble_dict[organisme]+"\" | tr \"@\" \"\\n\" > "+organisme+"_"+bestand)
  237.  
  238.  
  239. def jgi_download():
  240.     """
  241.    Proteomen downloaden van JGI
  242.    Via de curl statement wordt er een cookie aangemaakt voor het
  243.    goedkeuren van de inlog op JGI. Hierna word vanuit de xml
  244.    bestanden de link naar de proteomen opgehaald. Een
  245.    organismen had een andere naamgeving hiervoor is een
  246.    if statement aangemaakt. Hiernaa worden gebruikte bestanden
  247.    verwijderd en de gedownloade bestanden worden uitgepakt.
  248.    """
  249.     jgi_dict = {'Mixia_osmundae': 'Mixos1', 'Penicillium_canescens': 'Penca1', 'Phanerochaete_chrysosporium': 'Phchr2','Pleurotus_ostreatus': 'PleosPC15_2',}
  250.     os.system('''curl --insecure 'https://signon.jgi.doe.gov/signon/create' --data-urlencode 'login=wow.diegoz@gmail.com' --data-urlencode 'password=bpcogs123' -c cookies > /dev/null''')
  251.     for bac in jgi_dict:
  252.         os.system('''curl 'http://genome.jgi.doe.gov/ext-api/downloads/get-directory?organism=%s' -b cookies > files.xml'''%(jgi_dict[bac]))
  253.         if bac == 'Pleurotus_ostreatus':
  254.             os.system('''cat files.xml | egrep %s_GeneModels_AllModels |egrep aa.fasta| awk -F 'url' '{print $2}' | awk -F '"' '{print $2}' > links.txt'''%(jgi_dict[bac]))
  255.         else:
  256.             os.system('''cat files.xml | egrep %s_all_proteins | awk -F 'url' '{print $2}' | awk -F '"' '{print $2}' > links.txt'''%(jgi_dict[bac]))
  257.         os.system('''curl 'http://genome.jgi.doe.gov%s'  -b cookies > %s_JGI.gz'''%(open('links.txt', 'r').readline().rstrip(), bac))
  258.     os.system('''gunzip *_JGI.gz''')
  259.     os.system('''rm cookies files.xml links.txt''')
  260.  
  261.  
  262. def proteomen_downloaden(organisme_lijst):
  263.     """Deze functie, proteomen_downloaden, zorgt er voor dat van alle
  264.   organismes de juiste functies worden aangeroepen om in deze functies
  265.   de proteomen uit alle vijf de databases (NCBI, JGI, Esamble,
  266.   SWISSPORT en Trembl) gedownload kunnen worden.
  267.   Parameters(s):
  268.       * organisme_lijst, een lijst met alle namen van de tien
  269.        schimmels
  270.    """
  271.     uniprot_treble_bestanden = voorbereiden_swissprot_trembl_download()
  272.     for organisme in organisme_lijst:
  273.         ncbi_download(organisme)
  274.         ensembl_download(organisme)
  275.         swissprot_tremble_download(uniprot_treble_bestanden, organisme)
  276.     jgi_download()
  277.  
  278.  
  279. def organisme_proteom_samenvoegen(organisme_lijst, database_lijst):
  280.     """Deze functie, organisme_proteom_samenvoegen, zorgt er voor dat voor
  281.    elke organsime 2 bestanden worden gecreerd die het gehele proteom
  282.    (de proteomen uit NCBI, JGI, SWISSPORT, Tremble en Ensable
  283.    samengevoegt) representeren. De bestanden (full_'organisme naam'
  284.    en uniq_full_'organisme naam') worden aangemaakt, met de juiste
  285.    format. full_'orgaisme naam' bevat alle eiwitten uit alle databases
  286.    (NCBI, JGI, SWISSPROT, Tremble en Ensamble). Dit bestand is niet
  287.    gefilterd op dubbele eiwitten, zodat alle informatie gemakkelijk
  288.    terug te vinden is. (bijvoorbeeld uit welke database welk eiwit
  289.    komt.). Het uniq_full_'organisme naam' bestand is wel gefilterd op
  290.    dubbele eiwitten en hen heeft een eigen naam geving gekregen. Dit
  291.    wordt gedaan om de eiwitten om de eiwitten later makkelijk terug te
  292.    vinden in de database. Om full_'organisme naam' te kunnne maken moet
  293.    eerst wel duidelijk zijn welke eiwitten uit elke database komen. Dit
  294.    wordt gedaan door voor elke database bij elk eiwit de database naam
  295.    net na de '>' te zetten. Hierna wordt simpelweg alle datbase van een
  296.    organisme samngevoegt tot 1 bestand (proteom). Na het creeren van het
  297.    bestand full_'organisme naam' wordt voor elk organisme een afkorting
  298.    gemaakt (de eerste 3 letters van de geslachtsnaam gevolgt door de
  299.    eerste 3 letters van de soortsnaam) (dit wordt gedaan voor de naam
  300.    geving) en het net gecreerde full_'organisme naam' op dubbele eiwitten
  301.    gefilterd en de eigen naam geving toegekend (organisme naam afkorting
  302.    + een getal (dit getal is oplopend in het bestand). Voor alle file
  303.    manipulaties (het veranderen en creeren van bestanden) wordt bash
  304.    gebruikt. Beide gecreerde bestanden in deze functie worden later
  305.    gebruikt om de datbase te vullen. Het bestand uniq_full_organisme
  306.    wordt ook gebruikt bij het process dat COGs maakt. Tenslotte worden
  307.    de alle bestanden 'organsime naam'_'database naam' verwijderd omdat
  308.    deze niet meer nodig zijn.
  309.     Parameters(s):
  310.       * organisme_lijst, een lijst met alle namen van de tien
  311.        schimmels
  312.       * database_lijst, een lijst met alle namen van de database die
  313.        waaruit de data die verwerkt wordt verzameld wordt.
  314.    """
  315.     for organisme in organisme_lijst:
  316.         print organisme
  317.         for database in database_lijst:
  318.             os.system("cat "+organisme+"_"+database+" | sed 's/>/>|"+database+"|/g' | tr -d \"*\" > "+organisme+"__"+database)
  319.         os.system("cat "+organisme+"__* | sed 's/>/\\n>/g' | awk '{if (substr($0, 1, 1) == \">\") print $0\"%\"; else print $0}' | tr -d '\\n' | sed 's/>/@>/g' | tr '@' '\\n' | awk '{if (substr($0, 1, 1) == \">\") print $0\"%\"}' > full_"+organisme)
  320.         orgafk = "".join([orgnaam[0:3] for orgnaam in organisme.split("_")])
  321.         os.system("cat full_"+organisme+" | awk -F \"%\" '{if (substr($1, 1, 1) == \">\") print $(NF-1)}' | sort | uniq | awk '{print \">"+orgafk+"\"NR\"%\"$NF}' > uniq_full_"+organisme)
  322.         os.system("rm "+organisme+"_* uniprot*")
  323.     os.system("cat uniq_full_"+organisme+" | tr \"%\" \"\n\" > "+organisme+".fa")
  324.     print "proteomen samengevoegd"
  325.    
  326.  
  327. def eiwit_info_verzamelen(sequentie_regel, organisme):
  328.     """Deze functie, eiwit_info_verzamelen, filterd het eiwit id
  329.     en de sequentie uit de variable sequentie_regel. Hierna
  330.    wordt in het bestand full_'organisme', in dit bestand
  331.     staan alle eiwitten uit gedownloade databases met hun eigen
  332.     informatie, de sequentie gezocht. Dit wordt gedaan zodat de
  333.     orsprongelijke informatie uit de databases ook in de gecreerde
  334.     database kan worden gezet. Voor elke regel met dezelfde
  335.     sequentie, die gevonden is, wordt de informatie voor de sequentie
  336.     bij de juiste database naam in de dictonary geplaatst.
  337.     Parameter(s):
  338.         * sequentie_regel, een regel uit het bestand
  339.         uniq_full_'organisme' hieruit wordt de nodige
  340.         informatie gefilterd om deze informatie in de
  341.         database te kunnen zetten
  342.         * organisme, de naam van het organsime
  343.     Return value(s):
  344.         * eigen_eiwit_naam, de eigen naam van het eiwit
  345.         dat gecreerd is in dit script.
  346.         * sequentie, de aminozuur sequentie van het eiwit.
  347.         * database_dict, alle informatie hoe het eiwit heet
  348.         in elke database, wanneer het niet bekend is in een
  349.         database staat er NULL.
  350.    """
  351.     eigen_eiwit_naam = sequentie_regel.strip().split("%")[0][1:]
  352.     sequentie = sequentie_regel.strip().split("%")[1]
  353.     os.system("cat full_"+organisme+" | egrep %"+sequentie+"% | tr -d \"'\" > "+eigen_eiwit_naam[1:])
  354.     eiwit_info_b = open(eigen_eiwit_naam[1:], "r")
  355.     eiwit_info = eiwit_info_b.readlines()
  356.     database_dict = {"NCBI": "NULL", "SWISSPROT": "NULL", "Ensembl": "NULL", "JGI": "NULL", "Trembl": "NULL"}
  357.     for database_eiwit_info_seq in eiwit_info:
  358.         database_eiwit_info = database_eiwit_info_seq.strip().split("%")[0].split("|")
  359.         database = database_eiwit_info.pop(1)
  360.         database_dict[database] = "|".join(database_eiwit_info)
  361.     return eigen_eiwit_naam, sequentie, database_dict
  362.    
  363.  
  364. def eiwit_info_voor_database(organisme_lijst, cursor):
  365.     """Deze functie, eiwit_info_verzamelen_voor_database, zoekt, via
  366.     de functie eiwit_info_verzamelen voor alle eiwitten in de
  367.     organismes (bestand uniq_full_'organisme naam')
  368.    alle bijhorende informatie uit het samengevoegde proteom,
  369.    full_'organisme naam', om deze vervolgens door te geven samen met
  370.    de eigen gegeven naam (in uniq_full_'organisme naam' en de sequentie
  371.    van het eiwit aan de functie eiwit_in_database zetten. Tenslotte
  372.    worden de gecreerde bestanden voor elk eiwit verwijderd wanneer
  373.    alle informatie van het eiwit bekend is en de full_'organisme
  374.    naam' en uniq_full_'organisme naam' bestanden verwijderd wanneer
  375.     alle eiwitten uit een organisme behandeld zijn.
  376.     Parameter(s):
  377.        * organisme_lijst, een lijst met alle namen van de tien
  378.        schimmels
  379.        * cursor, de cursor van de postgres server
  380.    """
  381.     for organisme in organisme_lijst:
  382.         organisme_uniq_b = open("uniq_full_"+organisme, "r")
  383.         uniq_full_organisme = organisme_uniq_b.readlines()
  384.         for sequentie_regel in uniq_full_organisme:
  385.             eigen_eiwit_naam, sequentie, database_dict = eiwit_info_verzamelen(sequentie_regel, organisme)
  386.             eiwit_in_database_zetten(eigen_eiwit_naam, sequentie, database_dict, organisme,
  387.                                      stam_bepalen(organisme), cursor)
  388.             os.system("rm "+eigen_eiwit_naam[1:])
  389.         os.system("rm *full_"+organisme)
  390.  
  391.  
  392. def stam_bepalen(s_organisme):
  393.     """
  394.    Stam bepalen
  395.     In deze functie wordt er gekeken tot welke stam de organisme
  396.     behoort.
  397.     Parameter(s):
  398.         * organisme, de naam van het organsime
  399.     Return value(s):
  400.         * 'Ascomycota' of 'Basidiomycota', de naam van de stam
  401.         waar toe het organisme (van het eiwit) toebehoord. Deze
  402.         informatie wordt in de database gezet door de
  403.         onzoeksvraag.
  404.    """
  405.     ascomycota = ['Aspergillus_fumigatus', 'Aspergillus_nidulans',
  406.                   'Aspergillus_oryzae', 'Neurospora_crassa',
  407.                   'Saccharomyces_cerevisiae', 'Penicillium_canescens']
  408.     if s_organisme in ascomycota:
  409.         return 'Ascomycota'
  410.     else:
  411.         return 'Basidiomycota'
  412.  
  413.  
  414. def eiwit_in_database_zetten(eigen_eiwit_naam, sequentie, database_dict,
  415.     organisme, stam, cursor):
  416.     """Deze functie, eiwit_in_database_zetten, zet alle bekende
  417.     informatie van de eiwitten tot nu toe, (alles behalve cog nummer)
  418.     in de Eiwit_info tabel van de eerder gecreerde database
  419.     Parameter(s):
  420.         * eigen_eiwit_naam, de eigen naam van het eiwit
  421.         dat gecreerd is in dit script.
  422.         * sequentie, de aminozuur sequentie van het eiwit.
  423.         * database_dict, alle informatie hoe het eiwit heet
  424.         in elke database, wanneer het niet bekend is in een
  425.         database staat er NULL.
  426.         * organisme, de naam van het organsime
  427.         *stam, de naam van de stam
  428.         waar toe het organisme (van het eiwit) toebehoord. Deze
  429.         informatie wordt in de database gezet door de
  430.         onzoeksvraag.
  431.         * cursor, de cursor van de postgres server
  432.    """
  433.     cursor.execute("""INSERT INTO "Eiwit_Info" VALUES (\'"""+eigen_eiwit_naam+"""\', \'"""+organisme+"""\',\'"""+stam+"""\', \'Geen\', \'"""+sequentie+"""\', \'"""+database_dict['SWISSPROT']+ """\', \'"""+database_dict['JGI']+"""\', \'"""+database_dict['Trembl']+"""\', \'"""+database_dict['Ensembl']+"""\', \'"""+database_dict['NCBI']+"""\')""")
  434.  
  435.  
  436. def blast(br_naam1, br_naam2, br_pos1, br_pos2):
  437.     """Deze functie, blast, voert de blast uit tussen de organisme
  438.     namen die meegegeven worden. Nadat de blast is uitgevoert
  439.     wordt het bestand met de resultaten van de blast ingelezen.
  440.     En terug gegeven aan de functie die de functie blast heeft
  441.     aangeroepen. Als laatste worden de gecreerde bestanden van
  442.     de blast met onder andere de blast resultaten verwijderd,
  443.     deze zijn niet meer nodig.
  444.     Parameter(s):
  445.         *br_naam1, de naam van het organisme waar tegen
  446.         geblast worden (van dit organisme wordt een database gecreerd.
  447.         *br_naam2, de naam van het organisme die geblast gaat
  448.         worden tegen het andere organisme (br_naam2)
  449.         * br_pos1, de positie van de eiwitten van br_naam1
  450.         in het blast resultaat. Dit wordt meegegeven om straks
  451.         gemakkelijker TWOG's te maken.
  452.         * br_pos2, de positie van de eiwitten van br_naam1
  453.         in het blast resultaat. Dit wordt meegegeven om straks
  454.         gemakkelijker TWOG's te maken.
  455.     Return value(s):
  456.         *singles, een dictionary waarbij wanneer een key een TWOG
  457.         is deze als value 2 heeft (aangezien deze single 2 keer
  458.         voor komt)
  459.     """
  460.     singles = []
  461.     os.system("formatdb -p T -i %s.fa -n %sDB"%(br_naam1, br_naam1))
  462.     os.system("blastall -m8 -p blastp -d %sDB -i %s.fa -o %s_"%(br_naam1, br_naam2, br_naam1+br_naam2))
  463.     os.system("awk '!x[$1]++' %s_ > %s"%(br_naam1+br_naam2, br_naam1+br_naam2))
  464.     blast_resulaten_b = open(br_naam1+br_naam2, "r")
  465.     blast_resulaten = blast_resulaten_b.readlines()
  466.     for blast_resulaat in blast_resulaten:
  467.         singles.append((blast_resulaat.split()[br_pos1] + " " + blast_resulaat.split()[br_pos2]))
  468.     os.system("rm *DB* %s* formatdb.log"%(br_naam1+br_naam2))
  469.     return singles
  470.  
  471.  
  472. def proteom_naar_twogs(organisme_1, organisme_2, cursor, twogid):
  473.     """Deze functie, proteom_naar_twogs, zorgt dat de beide proteomen
  474.     van organisme 1 en 2 tegen elkaar geblast worden, via de functie
  475.     blast. En vervolgens gekeken of er TWOG's zijn doormiddel van de
  476.     geimporteerd methode Counter. Een lijst van singles (uitput
  477.     van de blast) wordt omgezet in TWOG's door de methode Counter.
  478.     Wanneer er een TWOG in de singles_tellijst staat wordt deze
  479.     toegevoegt aan de database met een Twog ID en een Cog Nummer
  480.     die op "" staat, wanneer alle TWOG's van alle organismes
  481.     in de database staat wordt dit aangepast, in de functie
  482.     twog_naar_cogs.
  483.     Parameter(s):
  484.         * organisme_1, de naam van organisme 1
  485.         * organisme_2, de naam van organisme 2
  486.         * cursor, de cursor van de postgres server
  487.         * twogid, een getal dat als primary key dient in
  488.         de database
  489.     Return value(s):
  490.         * twogid, een getal dat als primary key dient in
  491.         de database. Deze wordt terug gegeven zodat de
  492.         volgende TWOG's (van andere organisme) vanaf
  493.         het volgende TWOG nummer beginnen.
  494.     """
  495.     print "Blast"
  496.     singles_lijst = []
  497.     singles_lijst.extend(blast(organisme_1, organisme_2, 0, 1))
  498.     singles_lijst.extend(blast(organisme_2, organisme_1, 1, 0))
  499.     singles_tellijst = Counter(singles_lijst)
  500.     for single in singles_tellijst:
  501.         if singles_tellijst[single] == 2:
  502.             twogid += 1
  503.             cursor.execute("""INSERT INTO "Twog_Info" VALUES (\'"""+str(twogid)+"""\', \'"""+single.split()[0]+"""\', \'"""+single.split()[1]+"""\', \'""\');""")
  504.     print "twogs in database"
  505.     return twogid
  506.    
  507.  
  508. def twogs_(orgslijst, cursor):
  509.     """Deze functie maakt alle mogelijke combinaties van een set
  510.    (van 2) organismes. Wanneer er een set is gevonden stuurt
  511.    hij deze naar de functie proteom_naar_twogs, om de TWOG's te
  512.    vinden tussen deze organismen.
  513.    Parameter(s):
  514.        * orgslijst, een lijst met alle namen van de tien
  515.        schimmels
  516.        * cursor, de cursor van de postgres server
  517.    """
  518.     twogid = 0
  519.     for org1_i in range(len(orgslijst)):
  520.         for org2_i in range(len(orgslijst)):
  521.             if org1_i < org2_i:
  522.                 print orgslijst[org1_i], orgslijst[org2_i]
  523.                 twogid = proteom_naar_twogs(orgslijst[org1_i],
  524.                 orgslijst[org2_i], cursor, twogid)
  525.  
  526.                
  527. def check_eiwit(cursor, twogid):
  528.     """Deze functie, check_eiwit, geeft aan wat er in de database
  529.     bij de kolom Cog Nummer staat bij het twogid dat meegeven wordt.
  530.     Deze functie wordt als check gebruikt in de functie
  531.     twogs_naar_cogs.
  532.     Parameter(s):
  533.         * cursor, de cursor van de postgres server
  534.         * twogid, een getal dat als primary key dient in
  535.         de database
  536.     """
  537.     cursor.execute("""SELECT "Cog Nummer" FROM "Twog_Info" WHERE "Twog ID" = \'"""+str(twogid)+"""\';""")
  538.     gecheckt_eiwit = cursor.fetchall()[0]
  539.     return gecheckt_eiwit[0]
  540.  
  541.  
  542. def twogs_naar_cogs(cursor):
  543.     """Deze functie, twogs_naar_cogs, maakt linkt alle
  544.     TWOG's (samen met de functie twogs_vinden_gerealeerd_aan_de_twog)
  545.     aan elkaar om COG's te maken. Alle TWOG's in de database worden
  546.     doorlopen, behalve als zij al eerder gecheckt zijn. Dit is in
  547.     de database te zien doordat er iets anders (een JA, nummer of Geen)
  548.     staat in plaats van "". twogid en cog_nr worden geduurde de
  549.     functie steeds 1 bij opgeteld zodat beide oplopend zijn
  550.     vanaf 1 in de database. Als eerst worden de eiwitten in de
  551.     TWOG opgehaald uit de database (met het bijbehorende Twog ID)
  552.     Hierna wordt het Cog Nummer naar 'JA' veranderd zodat deze
  553.     TWOG niet nog een keer gevonden kan worden, en makkelijk
  554.     van de rest gescheden kan worden en dus het Cog Nummer gemakkelijk
  555.     veranderd kan worden. Hierna wordt (als de twog niet een lege
  556.     string is) gekeken of er meerdere twogs zijn waarin de eiwitten
  557.     van de twog voorkomen, dit wordt gedaan in de functie  
  558.     twogs_vinden_gerealeerd_aan_de_twog. Wanneer er geen andere
  559.     twogs (meer) gevonden kunnen worden wordt alle verzamelde
  560.     informatie naar cog_nr_toevoegen_aan_database gestuurd om
  561.     het Cog Nummer aan te passen in de database. Als laatst wordt
  562.     er bij het twogid 1 opgeteld zodat de volgende TWOG in de
  563.    database gecontroleerd kan worden.
  564.    Parameter(s):
  565.         * cursor, de cursor van de postgres server 
  566.     """
  567.     twogid = 1
  568.     cog_nr = 0
  569.     cursor.execute("""SELECT COUNT("Twog ID") FROM "Twog_Info";""")
  570.     aantal_twogs = cursor.fetchall()[0][0]
  571.     while twogid != (aantal_twogs + 1):
  572.         if check_eiwit(cursor, twogid) == '""':
  573.             twog_in_cog = []
  574.             cursor.execute("""SELECT "Eiwit ID 1", "Eiwit ID 2" FROM "Twog_Info" WHERE "Twog ID" = \'"""+str(twogid)+"""\';""")
  575.             twog = cursor.fetchall()[0]
  576.             twog_in_cog.append(twog)
  577.             cursor.execute("""UPDATE "Twog_Info" SET "Cog Nummer" = 'JA' WHERE "Eiwit ID 1" = \'"""+str(twog[0])+"""\' AND "Eiwit ID 2" = \'"""+str(twog[1])+"""\';""")
  578.             gecheckte_eiwitten = []
  579.             while twog != "":
  580.                 twog = twogs_vinden_gerealeerd_aan_de_twog(gecheckte_eiwitten,
  581.                 twog_in_cog, twog, cursor)
  582.             cog_nr = cog_nr_toevoegen_aan_database(cog_nr, twog_in_cog, gecheckte_eiwitten, cursor)
  583.         twogid += 1
  584.     print "Cogs gemaakt"
  585.  
  586. def cog_nr_toevoegen_aan_database(cog_nr, twog_in_cog, gecheckte_eiwitten, cursor):
  587.     """Deze functie, cog_nr_toevoegen_aan_database, wordt bepaald
  588.    of een cog een echte cog is, doormiddel van de functie cog_check.
  589.    Hierna wordt in de beide tabbellen van de database (Eiwit_Info en Twog_Info)
  590.    het Cog Nummer toegevoegt. Wanneer er geen (echte) COG gevonden
  591.    is wordt het Cog Nummer vervangen door het woord 'Geen'.
  592.    Parameter(s):
  593.          * cog_nr, het oplopende nummer dat als variable in
  594.          de database gezet wordt zodat een COG opgeslagen
  595.          kan worden in de database.
  596.     """
  597.     if len(twog_in_cog) != 1 and cog_check(twog_in_cog) != True:
  598.         cog_nr += 1
  599.         t_cog_nr = cog_nr
  600.     else:
  601.         t_cog_nr = "Geen"
  602.     for twog in twog_in_cog:
  603.         cursor.execute("""UPDATE "Twog_Info" SET "Cog Nummer" = \'"""+str(t_cog_nr)+"""\' WHERE "Eiwit ID 1" = \'"""+str(twog[0])+"""\' AND "Eiwit ID 2" = \'"""+str(twog[1])+"""\';""")
  604.     for eiwit in gecheckte_eiwitten:
  605.         cursor.execute("""UPDATE "Eiwit_Info" SET "Cog Nummer" = \'"""+str(t_cog_nr)+"""\' WHERE "Eiwit ID" = \'"""+str(eiwit)+"""\';""")
  606.     return cog_nr
  607.  
  608. def twogs_vinden_gerealeerd_aan_de_twog(gecheckte_eiwitten,
  609.                                          twog_in_cog, twog, cursor):
  610.     """Deze functie, twogs_vinden_gerealeerd_aan_de_twog,
  611.     wordt voor elk eiwit in de meegegeven TWOG aller eerst
  612.     toegevoegt aan de gecheckte eiwitten (in de cog). Zodat
  613.     eiwitten niet 2 keer gecheckt worden op gerelateerde TWOG's
  614.     Hierna worden alle TWOG's opgehaald waar het eiwit ook in
  615.     zit. elke TWOG waar het eiwit ook in zit wordt toegevoegt
  616.     aan de lijst twog_in_cog (deze bevat alle TWOG's van de COG
  617.     op dat moment). Hierna wordt het Cog Nummer naar 'JA' veranderd
  618.     zodat deze TWOG niet nog een keer gevonden kan worden, en makkelijk
  619.     van de rest gescheden kan worden en dus het Cog Nummer gemakkelijk
  620.     veranderd kan worden. Wanneer voor beide eiwitten gerelateerde
  621.     TWOG's gezocht zijn, wordt er gekeken of er een nieuw eiwit
  622.     bij gekomen is, zoja wordt deze terug gegeven om vervolgens
  623.     door de functie twogs_naar_cogs ook gecheckt te worden door
  624.     deze functie. Wanneer er geen nieuwe eiwitten bij gekomen zijn
  625.     wordt "" terug gegeven aan de functie twogs_naar_cogs. De COG
  626.     is nu compleet en wordt na een check in de database gezet als
  627.     Cog Nummer, in cog_nr_toevoegen_aan_database
  628.     Parameter(s):
  629.         * gecheckte_eiwitten, een lijst met alle eiwitten die
  630.         tot nu toe gecheckt zijn op gerelateerde TWOG's
  631.        * twog_in_cog, een lijst met alle TWOG's die tot nu toe
  632.         aan de COG behoren.
  633.         * twog, een TWOG (lijst van 2 eiwitten) die gecheckt moet
  634.         worden op gerelateerde TWOG's*
  635.         * cursor, de cursor van de postgres server 
  636.     Return value(s):
  637.         * twogg of "", dit is voor de functie twogs_naar_cogs
  638.         een indicator of er nog een TWOG gecheckt moet worden
  639.         of dat alle gerelateerde TWOG's gevonden zijn.
  640.     """
  641.     for eiwit_in_twog in twog:
  642.         if eiwit_in_twog not in gecheckte_eiwitten:
  643.             gecheckte_eiwitten.append(eiwit_in_twog)
  644.             cursor.execute("""SELECT "Eiwit ID 1", "Eiwit ID 2" FROM "Twog_Info" WHERE ("Eiwit ID 1" = \'"""+str(eiwit_in_twog)+"""\' OR "Eiwit ID 2" = \'"""+str(eiwit_in_twog)+"""\') AND "Cog Nummer" = \'""\'; """)
  645.             twogs_waar_eiwit_inzit = cursor.fetchall()
  646.             for nog_niet_gecheckte_twog in twogs_waar_eiwit_inzit:
  647.                 twog_in_cog.append(nog_niet_gecheckte_twog)
  648.                 cursor.execute("""UPDATE "Twog_Info" SET "Cog Nummer" = 'JA' WHERE "Eiwit ID 1" = \'"""+str(nog_niet_gecheckte_twog[0])+"""\' AND "Eiwit ID 2" = \'"""+str(nog_niet_gecheckte_twog[1])+"""\';""")
  649.     for twogg in twog_in_cog:
  650.         for eiwit_in_twogg in twogg:
  651.             if eiwit_in_twogg not in gecheckte_eiwitten:
  652.                 return twogg
  653.     return ""
  654.    
  655.    
  656. def cog_check(cog):
  657.     """Deze functie, cog_check, checkt of een gevonden COG wel een
  658.     'echte' COG is. Dit gebeurd door te kijken of er 2 eiwitten uit
  659.     hetzelfde organisme voorkomen. Wanneer dit het geval is wordt
  660.     True terug gegeven aan de functie twogs_naar_cogs
  661.     Return value(s):
  662.         * True, dit wordt terug gegeven aan de functie twogs_naar_cogs
  663.         wanneer een COG geen 'echte' COG is.
  664.     """
  665.     eiwitten_in_cog = []
  666.     for twog in cog:
  667.         eiwitten_in_cog.extend(twog)
  668.     eiwitten_in_cog = set(eiwitten_in_cog)
  669.     for eiwit1 in eiwitten_in_cog:
  670.         for eiwit2 in eiwitten_in_cog:
  671.             if eiwit1[0:6] == eiwit2[0:6] and eiwit1 != eiwit2:
  672.                return True  
  673.  
  674.  
  675. def main():
  676.     """Deze functie, main, regeld de loop van het gehele script.
  677.     Als eerst wordt de database aangemaakt in de functie
  678.     database_structuur_opzetten. Hierna worden alle organismes
  679.     en gebruikte databases namen opgeslagen in lijsten
  680.     (organisme_lijst en database_lijst). Dan worden de proteomen
  681.     gedownload aan de hand van de organisme_lijst. Hierna worden
  682.     de gedownloaden proteomen per organisme samengevoegt. Daarna
  683.     wordt het samengevoegde proteomen van de organsimen in de
  684.    gecreerde database gezet. Er wordt geblast en TWOG's gemaakt
  685.    en in de database gezet in de functie twogs_. De TWOG's worden
  686.     'vertaald' naar COG's in de functie twogs_naar_cogs. Als
  687.     laatste wordt de verbinding met de database verbroken in
  688.     de functie verbinding_database_stop.
  689.     """
  690.     conn, cursor = database_structuur_opzetten()
  691.     organisme_lijst = ["Aspergillus_fumigatus", "Aspergillus_nidulans",
  692.     "Aspergillus_oryzae", "Melampsora_larici-populina", "Mixia_osmundae",
  693.     "Neurospora_crassa", "Penicillium_canescens",
  694.     "Phanerochaete_chrysosporium", "Pleurotus_ostreatus",
  695.     "Saccharomyces_cerevisiae"]
  696.     database_lijst =  ["NCBI", "SWISSPROT", "Ensembl", "JGI", "Trembl"]
  697.     proteomen_downloaden(organisme_lijst)
  698.     organisme_proteom_samenvoegen(organisme_lijst, database_lijst)
  699.     eiwit_info_voor_database(organisme_lijst, cursor)
  700.     twogs_(organisme_lijst, cursor)
  701.     twogs_naar_cogs(cursor)
  702.     verbinding_database_stop(conn, cursor)
  703.  
  704. """Deze regel roept de main aan, en dus het gehele script."""
  705. main()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!