29 avril 2008 – interface sganarrayl

11h24 :
Pour faire l’interface d’ajout du fichier gal, j’ai voulu reprendre celle d’ajout du fichier gff.
celle-ci étant assez moyenne, j’ai donc décidé de la reprendre.
pour que ce soit cohérent avec l’interface finale de sganarrayl, il faut deja pensé a l’intégralité de l’interface.
Depuis la page d’accueil pour ajouter des puce, on pourra donc voir la liste des puces disponibles et aussi du fichier de définition des features utilisé.
on pourra depuis cette page aussi ajouter de nouveaux fichiers de puce et de feature.
l’ajout de feature va renvoyer sur la page add_gff.php
cette page propose un champ browse pour parcourir le disque local et ajouter un fichier.
l’envoie du formulaire va renvoyer sur la meme page.
cette fois ci, comme il y a un fichier uploader, ca va déclencher le script php.
celui-ci copie le fichier uploadé dans un répertoire spécifique.
il va aussi modifier la page pour faire apparaitre le nom du fichier traité et faire disparaitre le champs browse.
la page va aussi avoir un script javascript (add_gff.js).
celui-ci va se déclencher s’il y a un nom de fichier a traiter.
dans ce cas il va faire appelle au script add_gff.py pour traiter le fichier gff et renvoyer la réponse qui correspond au traitement et l’afficher.
add_gff.py parse le fichier gff à l’aide des du parser gff de parser_tools puis utilise la classe garden_state du module sganarrayl_interface pour se connecter à la base luce_la_puce et ajouter les feature par la méthode add_feature_data.

add_gff.py renvoie un fichier xml avec les balises ou selon le déroulement du code.
le script javascript va interpréter ce xml et afficher les messages correspondants dans une balise prévue a cette effet et ingénieusement intitulée gff
voici le flux de données

L’interface pour le fichier gff fonctionne bien maintenant et le code est propre.
passons au fichier gal

déroulement de la séquence.
l’utilisateur doit ajouter une puce dans la base.
il va alors aller sur la page add_gal.php.
il n’y a que 2 champs pour le moment.
le premier pour donner un nom à la puce.
le 2eme pour mettre le fichier gal qui contiendra les info sur les spots.
le nom de la puce sera celui utilisé par la suite pour faire référence à celle-ci.
le script va ensuite ajouter le nom de la puce dans la table array_chip_types s’il n’existe pas encore. s’il existe deja, l’ajout de la puce est refusé. par la suite il devra permettre la mise a jour de la puce.
ensuite il faut parcourir chaque spot, déterminer son type, vérifier dans la table array_spot_type si le type existe et sinon l’ajouter. on recherche ensuite dans les features de la table bank_orf qui ont la meme annotation que le spot.
si on trouve on garde la ref de la feature, sinon, la ref est nulle. on ajoute ensuite les info du spot dans la table array_spots, en ajoutant les liaisons vers les tables array_chip_types array_spot_type et bank_orf.

todo -> modifier sganarrayl_interface pour pouvoir sélectionner les id des orf ayant l’annotation du spot

15 avril 2008 – Parser pour le fichier gff

le parser pour fichier GFF est assez simple
description du format gff –> ici

un header de taille variable marqué par “#”
puis des données en colonne séparées par des tabulations.
il y a 9 colonnes.
il n’y a pas de ligne de titre
exemple :

less /home/gim2/bank/saccharomyces_cerevisiae.gff

##gff-version 3#date Wed Jul 18 19:35:09 2007## Saccharomyces cerevisiae S288C genome## Features from the 16 nuclear chromosomes labeled chrI to chrXVI,# plus the mitochondrial genome labeled chrMito and the 2-micron plasmid.## Created by Saccharomyces Genome Database (http://www.yeastgenome.org/)## Weekly updates of this file are available via Anonymous FTP from:# ftp://ftp.yeastgenome.org/yeast/data_download/chromosomal_feature/saccharomyces_cerevisiae.gff## Please send comments and suggestions to yeast-curator@yeastgenome.org## SGD is funded as a National Human Genome Research Institute Biomedical Informatics Resource from# the U. S. National Institutes of Health to Stanford University.  The staff of SGD is listed at:# http://www.yeastgenome.org/SGD-staff.html#chrI    SGD     chromosome      1       230208  .       .       .       ID=chrI;dbxref=NCBI:NC_001133chrI    SGD     repeat_family   1       62      .       -       .       ID=TEL01L-TR;Name=TEL01L-TR;Note=Terminal%20stretch%20of%20telomeric%20repeats%20on%20the%20left%20arm%20of%20Chromosome%20I;dbxref=SGD:S000028864

le contenu des colonnes est (dans l’ordre) :

• seqname

Le nom de la séquences, dans le cas de la levure, le chromosome

• source

La source de la feature. soit le programme ayant réalisé la prédiction, ou la base de donnée publique… dans le cas de la levure, c’est en général SGD.

• feature

Le nom de la feature si possible un nom standardisé.

• start, end

debut et fin de la feature, fin doit etre supérieur a debut

• score

score de la feature ou ‘.’ s’il n’y en a pas

• strand

‘+’ ou ‘-’ selon le brin ou alors ‘.’ si ca ne s’applique pas

• frame

‘0′, ‘1′, ‘2′, ou ‘.’ indique la position du premier codon

• Attribute

Cette colonne est différente car elle contient nom pas une valeur mais une liste d’attribut. ceux-ci sont séparé par des “;” et

Le fichier peut contenir des meta données identifées par un “#”

le parser doit donc
parser le header par la méthode par défaut
utiliser une liste de nom de colonne prédéfinie
parser les lignes
puis pour chaque item parser l’élément de la dernière colonne pour en extraire les attributs et les ajouter a item.

class Gff_parser(Items):    def __init__(self, **arg):        '''        x = Gff_parser(**arg)        '''

        arg['column_names']=['chr','origin','type','start','end','score','strand','frame', 'group']

        self.attr_group=set([])        #call the init method of Items        Items.__init__(self, **arg)        self.attr_list.extend(self.attr_group)

    def parse_group(self, item):        group = item.get_attribute('group')

        groups = split(group, ';')

        group_items=(self.parse_group_item(item) for item in groups)

        item.set_attribute(group_items)

        self.attr_group.update(item.get_attr_list())

        return item

    def special_data_parsing_fn(self, item):        return self.parse_group(item)

    def parse_group_item(self, group_item):        return split(group_item, '=')

j’ai modifié la méthode d’assignation des item.
j’ai rajouté une fonction qui s’applique sur chaque item juste après sa création.
cette méthode sera a surclasser dans les parser si besoin

    def list2item(self, data_list):        '''        data_item = x.list2item(data_list)        data_list -> list of list        data_item -> list        create instances of Item for all element of data_list        return all instances in a list        '''        try :            #create instance of Item for all element of data_list            return (self.special_data_parsing_fn(Item(x, self.attr_list)) for x in data_list)        except TypeError :            #if data_list can't be map, return an ampty list            return []

    def special_data_parsing_fn(self, item):        return item

j’ai ajouté un module de test gff qui reste a completer.

    def test_gff_parser(self):        test_gff = Gff_parser(file_arg = '/home/gim2/bank//saccharomyces_cerevisiae.gff')        self.assert_(isinstance(test_gff,Gff_parser))        print test_gff[0].keys()

j’ai en sortie

tmp_file format is not correct..col_0 is not a valide attribute....the argument is not a regular file objectfile toto doesn't existpermission denied for file tmp_parse.txt..----------------------------------------------------------------------Ran 8 tests in 4.603s

OK

7 mars 2008 – Interface pour l’ajout des orf dans luce_la_puce

11h52 : l’ajout va donc se faire a partir d’un fichier gff.
l’interface va donc etre très simple. une page web avec un formulaire de base. un controle pour envoyer un fichier et un controle submit. et puis le code php pour traiter tout ca. bref, pas trop compliqué. la table bank_orf va etre a revoir cependant.
je vais créer une table bank_gff qui va contenir les metadonnées du fichier gff et la date de release du fichier.

pour créer la table bank_orf, je m’aide de la table feature de la base sophia

CREATE TABLE features(ft_index serial NOT NULL,ft_chr varchar(10),ft_origin varchar(10),ft_type varchar(50),ft_start int4,ft_end int4,ft_score varchar(5),ft_strand varchar(1),ft_frame char(1),ft_rev varchar,ft_dbxref varchar,ft_id varchar,ft_name varchar,ft_note varchar,ft_orf_classification varchar,ft_ontology_term varchar,ft_parent varchar,ft_alias varchar,ft_gene varchar,CONSTRAINT ft_id_key PRIMARY KEY (ft_index))WITHOUT OIDS;ALTER TABLE features OWNER TO fricard;

en fait je ne vais pas créer toute ces colonnes, certaines seront générées automatiquement a partir du fichier gff. cependant je vais les mettre qd meme dans le schema de la base.


create table bank_orf (orf_index serial not null, orf_chr varchar(10), orf_origin varchar(10), orf_type varchar(50), orf_start int4, orf_end int4, orf_score varchar(5), orf_strand varchar(1), orf_frame varchar(1), gff_id serial not null, primary key (orf_index));
create table bank_gff (gff_id serial not null, gff_release_date date, gff_metadata text, primary key (gff_id));


je vais utiliser le module DBGFF.py que j’ai créé pour genepy. comme ca le parser gff est deja fait.

je le fait grace a la commande sys.path += ['/home/gim/genepy']

j’ai finalement modifié bank_gff et j’utilise la date comme clé, ce qui permet d’avoir une contrainte d’unicité sur cette valeur. ce qui se gère bien en python/sql

try :
con.query(query)
except pg.ProgrammingError, e :
print e

qui renvoie

ERROR: duplicate key violates unique constraint "bank_gff_pkey"

si la date existe deja.

j’ai ajouté dans DBGFF.py une méthode pour la classe Features renvoyant un dictionnaire dont les clés sont les attributs de l’objet et les valeurs sont le contenu des attributs. on peut de plus passer un prefixe pour le nom des clés en argument.

  def get_attrdict(self, prefixe=''):      attr_tupple = [ (prefixe + attr, self.getattribute(attr)) for attr in self.attrList  ]      return dict(attr_tupple)

l’avantage de cette méthode est donc d’avoir un dictionnaire des couple attributs, valeurs, ce qui est assez pratique avec la méthode insert de pg.DB
le script pour introduire des features dans la base est donc le suivant

#! /usr/bin/python2.5

import cgiimport pgimport sys

sys.path += ['/home/gim/genepy']

import DBGFF

def create_postgres_db(base):#===============================================================================#    creation de la base de donnee postgresql#===============================================================================

    db = DBGFF.DB(base)    db_date=db.get_release_date('DATE')    print db_date    a=2    DBNAME = "luce_la_puce"    HOST = 'berthemorisot.gim.pasteur.fr'    USER = 'postgres'       #con = pg.connect(dbname=DBNAME, host=HOST, user=USER)    llp=pg.DB(dbname=DBNAME, host=HOST, user=USER)    try :        llp.insert('bank_gff', {'gff_release_date' : db_date, 'gff_metadata':db.info})

    except pg.ProgrammingError, e :        print e        return    prefixe = "orf_"    i = 0    listfields = llp.get_attnames('bank_orf').keys()    listfields = set(map(lambda x : x[4:], listfields))    date_dict={'gff_release_date' : db_date}    for feature in db :        attr_list = set(feature.get_attrlist().keys())        diff = attr_list.difference(listfields)

        if diff :               for attr in diff :

                attr_col = "%s%s" % (prefixe, attr)

                llp.query("alter table bank_orf add column %s varchar" % attr_col)

                listfields.add(attr)

        values = feature.get_attrdict(prefixe)        values.update(date_dict)        llp.insert('bank_orf', values)

        i+=1        if not i%1000 :            print i

print "Content-type: text/html"print

print "insertion des donnees"

post_data=cgi.FieldStorage()gff=post_data['gff_file']create_postgres_db(gff.file)

print "script fini"

ce script n’est pas définitif, il faut l’améliorer pour que l’ergonomie soit correcte.