20 mai 2008 – montage d’un systeme de fichier distant (berthemorisot sur douanierousseau)

11h13
J’ai 2 machines, douanierousseau fonctionnant avec ubuntu feisty 7.04 et berthemorisot avec Centos 4
berthemorisot est le serveur de l’unité.
on y stock bcp de choses.
c’est aussi la que se trouvent les script créer pour le labo et fonctionnant avec une interface web
Le but : avoir un répertoire sur ma machine qui reprend le système de fichier de berthemorisot.
Comment faire : en utilisant nfs (Network File System)
il faut configuere les deux coté, le serveur qui va fournir les fichier et le client qui va les lire.
donc ici le serveur est berthemorisot et le client douanierousseau.

1- configuration de berthemorisot
je m’aide de cette page
http://www.centos.org/docs/5/html/Deployment_Guide-en-US/s1-nfs-server-export.html
je configure le fichier /etc/exports pour que douanierousseau soit accepté comme client et que ce soit le repertoire /home/gim qui soit partagé
j’ecris dans ce fichier :
/home/gim/ douanierousseau.gim.pasteur.fr(rw,all_squash)

puis je lance le serveur nfs
sudo /sbin/service nfs start

pour le serveur, c’est fini, passons au client

2- douanierousseau
je m’aide de cette page
http://doc.ubuntu-fr.org/nfs
j’installe le paquet nfs-common
le point de montage sera /home/gim2/berthe/

et je rajoute la ligne
berthemorisot.gim.pasteur.fr:/home/gim /home/gim2/berthe nfs user 0 0
dans /etc/fstab

si le point de montage est tjs vide alors je fais
sudo mount -t nfs berthemorisot.gim.pasteur.fr:/home/gim /home/gim2/berthe

ca marche bien mais je n’ai pas les droit de modification sur les fichiers, c’est chiant

je modifie alors plusieurs choses
d’une par je fais en sorte que l’utilisateur distant soit identifié comme l’utilisateur gim en modifiant /etc/exports
je tape la la ligne
/home/gim/ douanierousseau.gim.pasteur.fr(rw,all_squash,anonuid=501,anongid=100,)

501 étant le code de l’utilisateur gim et 100 celui du group users

et aussi sur douanier rousseau je remplace l’id de l’utilisateur gim2 qui était 1000 par 501 en modifiant le fichier /etc/passwd
j’ai donc maintenant accès a berthemorisot sans probleme.
j’ai modifié /usr/sbin/ntsysv, pour que nfs démarre au démarrage du serveur

20 mai 2008 – analyse des résultat de sage – restriction WT et double mutant (suite)

10h40
après avoir obtenu les segment, je vais donc chercher a les localiser par rapport aux orf environnantes.
Tout d’abord j’exporte la liste des segment sur douanierousseau
scp berthe:sage/total/stats/ratio2_5/WT&mutant/segments_WT_CUTs ~/sage/total/stats/ratio2_5/WT&mutant/
ensuite j’utilise segment.py (dans le workspace genepy) pour transformer ce fichier du format matlab au format csv puis pour localiser les orf
j’ai modifier légèrement segment.py pour que les nom des colonnes correspondent bien a ce qui est dedans.

j’obtiens le fichier segments_WT_CUTs_density_max.csv que j’exporte sur bambino pour appliquer la macro excel de search_features_A_and_B.xls dessus
j’enregistre les résultats dans segments_WT_CUTs_density_max.xls et j’exporte dans le fichier segments_WT_CUTs_dist_to_feature.txt
j’élimine les colonne de texte et j’enregistre en csv
puis j’exporte sur berthemorisot et je l’importe dans matlab

j’obtiens la matrice seg_WT_CUTs_dist2feature et la matrice colheader_seg_WT_CUTs_dist2feature qui contient les intitulés des colonnes.
je représentes les nb de segment de chaque type en fontion de leur distance respectives avec soit le debut ou la fin des orf
j’ai écrit un script qui traces les courbes de façon automatique en
mettant la plupart des bon parametres

function [distance_hist]=plot_dist2feature(data, n, smooth_window)

extreme=cell(1,2);
extreme{1,1}='start';
extreme{1,2}='stop';

sens=cell(1,2);
sens{1,1}='sens';
sens{1,2}='antisens';

classe=cell(2,2);
classe{1,1}='Oligo-dT';
classe{2,1}=8:10;
classe{1,2}='CUTs';
classe{2,2}=1:2;

cols=cell(4,3);

cols{1,1}='start';
cols{1,2}='sens';
cols{1,3}=[8 10 16];

cols{2,1}='start';
cols{2,2}='antisens';
cols{2,3}=[12 14 18];

cols{3,1}='stop';
cols{3,2}='sens';
cols{3,3}=[9 11 17];

cols{4,1}='stop';
cols{4,2}='antisens';
cols{4,3}=[13 15 19];

max_plot=0;
min_plot=0;
distance_hist=cell(8,5);
i=1;
for id_classe=1:2
for id_extreme=1:2
for id_sens=1:2
for j=1:4
feature_extreme=extreme{1,id_extreme};
feature_sens=sens{1,id_sens};
if strcmp(cols{j,1}, feature_extreme) && strcmp(cols{j,2}, feature_sens)
columns=cols{j,3};
end
end

distance_hist{i,1}=mk_distance_hist(data, classe{2,id_classe}, columns, -1000, 1000, n, 20);
distance_hist{i,2}=feature_extreme;
distance_hist{i,3}=feature_sens;
distance_hist{i,4}=classe{1,id_classe};
distance_hist{i,5}=n;
h=zeros(2001,1);
tmp = distance_hist{i,1};
h(min(tmp)+1001:max(tmp)+1001)=hist(tmp,max(tmp)-min(tmp)+1)';
distance_hist{i,6}=h;
distance_hist{i,7}=smooth(h, smooth_window, 0);
i=i+1;
end
end
end
zero_line=[0 0];
figure
set(gcf,'Color','k');
plot_ids = 1:2:7;
for i=1:4
if i max_plot
max_plot= limite(2);
end
end

for i=1:4
subplot(2,2,i)
ylim([min_plot max_plot]);
line(xlim, zero_line, 'Color', 'w');
line(zero_line, ylim, 'Color', 'w');
end


j’ai rajouté qq éléments sur le graphique.
ce qui me donne ca pour n=4 :

quelques chiffres sur ces données
on a sélectioné uniquement les tag provennant de la souche sauvage (oligo-dT) et du double mutant Trf4/Rrp6 (CUTs)
on a :

oligo-dT -> 49284 tags
Cuts -> 66884 tags

environ 1/3 des tags des Cuts a été éliminé de façon aléatoire afin d’avoir le meme nombre pour les 2 catégories.

on a alors

oligo-dT -> 49284 tags
Cuts -> 49077 tags

il y a au total 98361 tags

la détection des segments sur ces tags
permet de trouver 12021 clusters
ces clusters contiennent au moins 1 tag
si on augmente le nb minimal de tag on a :

1-> 12021
2-> 6001
3-> 4047
4-> 3069
5-> 2482
6-> 2072
7-> 1791
8-> 1572
9-> 1410
10-> 1277

le calcul du ratio Oligo-dT / (CUTs + Oligo-dT) puis le fractionnement des clusters dans 10 classes en fonction de ce ratio donne

Nb tag minimum	Classes -> 1	2	3	4	5	6	7	8	9	10
1	6168	179	94	178	330	60	161	216	200	4435
2	2573	179	94	178	330	60	161	216	200	2010
3	1568	179	94	178	97	60	161	216	200	1294
4	1169	179	94	62	97	60	59	216	200	933
5	935	179	46	62	58	60	59	148	200	735
6	787	140	46	42	58	30	59	107	200	603
7	691	117	46	27	40	30	46	107	176	511
8	621	100	37	27	32	20	46	97	152	440
9	572	85	28	24	29	20	41	85	137	389
10	538	73	19	18	24	16	37	74	121	357

on va considerer que les CUTs sont les segments des classes 1 et 2 et les oligo-dT ceux des classes 8,9 et 10. de plus on ne va s’intéresser qu’aux segments ayant au moins 4 tags
ce qui fait
CUTs -> 1348 segments
oligo-dT -> 1349 segments

dans ces segments on a
38 % (508 segments) des oligo-dT sont entre 600 et 0 avant le start des orf en sens
88 % (1198 segments) des oligo-dT sont entre 0 et 400 après le stop des orf en sens
48 % (646 segments) des oligo-dT sont entre -100 et 400 par rapport au stop des orf en antisens
45 % (605 segments) des CUTs sont entre -600 et 400 par rapport au start des orf en sens
45 % (613 segments) des CUTs sont entre -1000 et -200 par rapport au start des orf en antisens
40 % (538 segments) des CUTs sont entre -600 et 100 par rapport au stop des orf en antisens

15 mai 2008 – analyse des résultat de sage – restriction WT et double mutant

10h25
Je vais reprendre l’analyse des sage a la base en ne prennant en compte que les tag obtenu sur les manip wild type et double mutant Trf4/Rrp6

Je dois refaire le clustering afin de n’avoir que des segment correspondant a des groupes de tag de ces manip.

1- ouverture dans matlab du fichier
~/sage/total/stats/tag_tot_genome.mat

j’ai dans ce fichier les matrice correspondant aux 12 manip de sage (header01 à header12)
chaque matrice à une taille de 24 million ce qui corresponde au nombre de nucleotide de l’ensemble du génome mis bout a bout en séparant les brin C et W
les matrice chr_len et chr_ref donnent les positions de chaque chromosome dans cette matrice

2- la recherche des segments (cluster) va se faire uniquement sur les manip 1 et 8, correspondant au Wild Type (WT) et au double mutant Trf4/Rrp6

3- j’utilise le programme segment.m avec la commande
header = header01 + header08;
header(:,2) = header01;
[header_region] = segment(header, dt, nt, chr_ref);
je récupère la matrice ratio2_1_100_1 qui a été crée
et je représente les histogramme des classe de ratio

figurefor i=1:9subplot(3,3,i)hist(ratio2_1_100_1(find(ratio2_1_100_1(:,4)>i-1),1))xlabel('Ratio Oligo-dT / (CUT + Oligo-dT)', 'color',[1 1 1]);ylabel('Number of clusters', 'color',[1 1 1]);title(strcat('n = ', num2str(i)), 'color',[1 1 1])set(gca, 'Xcolor', [1 1 1], 'Ycolor', [1 1 1])end

et j’obtiens la figure suivante

on voit qu’il y a un nb plus important de cluster de la classe 1 que ceux de la classe 10
si on regarde le nb de tag, on constate aussi qu’il y a environ 20 % de plus de CUTSque d’Oligo-dT

On va donc chercher a réduire artificiellement le nb de CUT en en éliminant de façon aléatoire jusqu’à avoir le meme nombre
script : delete_rand_tag

h8 = header08;tag = find(h8);s = size(tag,1);while sum(h8) > 49284p = floor(rand(1000,1) * s);ptag = tag(p);h8(ptag) = 0;end

header_rand = header01 + h8;
header_rand(:,2) = header01;
je fais ensuite [header_region_rand] = segment(header_rand, dt, nt, chr_ref);
je renome ratio2_1_100_1 en ratio2_1_100_1_ rand
puis je représente les memes histogrammes

figurefor i=1:9subplot(3,3,i)hist(ratio2_1_100_1_rand(find(ratio2_1_100_1_rand(:,4)>i-1),1))xlabel('Ratio Oligo-dT / (CUT + Oligo-dT)', 'color',[1 1 1]);ylabel('Number of clusters', 'color',[1 1 1]);title(strcat('n = ', num2str(i)), 'color',[1 1 1])set(gca, 'Xcolor', [1 1 1], 'Ycolor', [1 1 1])end

et j’obtiens

on voit que c’est plus homogène entre les classes extrèmes.
pour vérifier cela, on cherche a voir si la répartition du nombre de tag dans les segment est la meme pour toute les classes.

j’extrait de la matrice ratio2_1_100_1_ rand les lignes pour lesquelles le ratio est faible (inf a 0.2 CUTs) et fort (sup à 0.8 WT) et je fait l’histogramme du nombre de tag (colonne 4). je choisi pour ces histogramme d’avaoir comme nombre de catégorie la valeur maximale de tag pour chaque type (3318 pour le WT et 1522 pour les CUTs.
puis je trace les courbe correspondantes en échelle log

h_0=hist(ratio2_1_100_1_rand(find(ratio2_1_100_1_rand(:,1)0.8),4), max(ratio2_1_100_1_rand(find(ratio2_1_100_1_rand(:,1)>0.8),4)));
figure;
plot(h_0,'r');
hold on
plot(h_1,'g');

on voit que les segments avec un faible nb de tag sont plus nombreux pour les CUTs. cependant a partir de 4 tags par segment on observe la meme répartition.
on peut donc dire que a partir de 4 tags par segment on a un nombre similaire de segments avec le meme nombre de tag dans ceux-ci.

Je me suis rendu compte que les position des tags sont fausses. en fait elles sont décalée par rapport a ce qu’on veux car on s’interresse a la fin des tag et non au début
j’ai fait un programme qui corrige ca (tag_position_correction)
je corrige donc les 2 matrice contenant les résultats des WT et CUTs

chr_WT=tag_position_correction(header01,chr_len);chr_CUTs=tag_position_correction(h8,chr_len);chr_WT_CUTs = chr_WT + chr_CUTs;chr_WT_CUTs(:,2)=chr_WT;[regionWT_CUTs] = segment(chr_WT_CUTs, dt, nt, chr_ref);

cpt =

       12021

et je récupère la matrice segments_WT_CUTs
je vais maintenant rechercher le max de densité de chaque segment
je calcul d’abord la matrice de densité pour les tag WT et CUts
density_WT_CUTs = densite_sage(chr_WT_CUTs(:,1), 100);
puis je cherche le max de densité
segments_WT_CUTs=find_max_segment(density_WT_CUTs, segments_WT_CUTs);
j’exporte avec save(strcat('segments_WT_CUTs','.mat.csv'),'segments_WT_CUTs', '-ascii','-tabs');

TODO -> export sur douanierousseau, localiser les segment par rapport aux orf et faire les graph

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

17 avril 2008 – génération des tables pour le fichier gal

17h34
les table reprennant les infos de la puce sont
array_chip_type
array_spot
array_spot_type

array_chip_type pourrait a mon avis contenir plus de choses. en gros toutes les infos globales sur une puces.
array_spot rassemble les infos liées aux spot de la puce
et array_spot_type regroupe les différents types de spots, pour l’instant je pense feature, control ou empty.

le type de la puce est SLRI-Yeast-Barcode-13k
les infos sont dans barcode12k_v2final.gal
comment doit se dérouler le programme :
1- récupérer le nom de la puce (et plus tard toute sa description)
2- ajouter ce nom dans le fichier array_chip_type
3- récupérer le fichier gal
4- le parser et pour chaque ligne
5- extraire le type (feature, spotting buffer ou empty)
6- ajouter le type dans la table s’il n’existe pas
7- extraite l’ID
8- eliminer les element en trop de l’ID
9- rechercher dans la base des feature si la feature existe et récupérer sont identifiant
10-ajouter ensuite la ligne dans array_spot en la liant au type de la puce, au type de spot qui va bien et à la feature qui va bien.

en reprennant le code pour introduire les données de features (ici) je me rend compte que le code est assez moyen, et surtout pas adapté a l’utilisation dans un cgi.
de plus il n’utilise pas le nouveau parser que j’ai créé.
donc je reprends tout, enfin en partie.

imaginons la structure de l’interface.
le plus simple, une page web avec un champ parcourir pour aller chercher le gff et un bouton valider
ca envoie la requete sur une page qui va traiter la requete.
cette page va récuperer le fichier et l’enregistrer dans un répertoire temporaire.
puis un objet loader va le tester pour savoir s’il existe bien, et ouvrir le filehandle
puis il va etre transmis au parser qui va vérifier le format (rajouter la fonction check dans le parser) et puis traiter toutes les données.
il faut ensuite une fonction pour ajouter ces données dans la base
il me faut alors une classe pour effectuer cette action.
ca va etre finalement une classe d’interface avec luce_la_puce.
cette classe pourrait s’appeler Garden_state qui traitera par une méthode appropriée l’objet de feature.
il me faut donc un loader.
c’est assez simple, le loader doit récupérer un nom de fichier
vérifier qu’il existye et l’ouvrir
récupérer le parser qui va le traiter
appliquer ce parser et renvoyer l’objet créér

class file_loader():

    def __init__(self, **arg):        filename = arg.get('filename', '')        try :            self.fhin = self._open_file(filename)        except IOError, e :            raise

    def _open_file(self, filename):        '''        fhin = x._open_file(filename)        filename -> str        fhin -> file        open a file and return the filehandle        '''        #test id the file exists and is a file        if not isfile(filename) :            raise IOError, "file %s doesn't exist" % filename        #test if reading access is granted        if not access(filename, R_OK) :            raise IOError, "permission denied for file %s" % filename        return open(filename, 'r')

    def get_filehandle(self):        try :            return self.fhin        except AttributeError :            return None

    def apply_parser(self, parser=None):        try :            if not parser:                parser = self.parser        except AttributeError :            raise

        return parser(file=self.fhin)

    def set_parser(self, parser=None):        self.parser = parser

peut-etre aussi faut’il rajouter le moyen de réouvrir le file handle et puis par la suite une méthode pour copier le fichier dans un autre emplacement.
ensuite il faut donc que je créé l’interface pour luce_la_puce Garden_state

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

15 avril 2008 – Parser pour le fichier gal

11h04
maintenant que le parser global est construit, je vais faire un parser pour le fichier gal dérivé de celui-ci
Format d’un fichier GAL -> GenePix Array List
exemple du fichier /home/gim2/bioinfo/microarray/barcode12k_v2final.gal
la commande
less /home/gim2/bioinfo/microarray/barcode12k_v2final.gal
donne
ATF 1
51 6
Type=GenePix ArrayList V1.0
BlockCount=48
BlockType=0
"Block1= 3530, 8000, 120, 24, 180, 24, 180"
"Block2= 8030, 8000, 120, 24, 180, 24, 180"
"Block3= 12530, 8000, 120, 24, 180, 24, 180"
"Block4= 17030, 8000, 120, 24, 180, 24, 180"
"Block5= 3530, 12500, 120, 24, 180, 24, 180"
"Block6= 8030, 12500, 120, 24, 180, 24, 180"
"Block7= 12530, 12500, 120, 24, 180, 24, 180"
"Block8= 17030, 12500, 120, 24, 180, 24, 180"
"Block9= 3530, 17000, 120, 24, 180, 24, 180"
"Block10= 8030, 17000, 120, 24, 180, 24, 180"
"Block11= 12530, 17000, 120, 24, 180, 24, 180"
"Block12= 17030, 17000, 120, 24, 180, 24, 180"
"Block13= 3530, 21500, 120, 24, 180, 24, 180"
"Block14= 8030, 21500, 120, 24, 180, 24, 180"
"Block15= 12530, 21500, 120, 24, 180, 24, 180"
"Block16= 17030, 21500, 120, 24, 180, 24, 180"
"Block17= 3530, 26000, 120, 24, 180, 24, 180"
"Block18= 8030, 26000, 120, 24, 180, 24, 180"
"Block19= 12530, 26000, 120, 24, 180, 24, 180"
"Block20= 17030, 26000, 120, 24, 180, 24, 180"
"Block21= 3530, 30500, 120, 24, 180, 24, 180"
"Block22= 8030, 30500, 120, 24, 180, 24, 180"
"Block23= 12530, 30500, 120, 24, 180, 24, 180"
"Block24= 17030, 30500, 120, 24, 180, 24, 180"
"Block25= 3530, 35000, 120, 24, 180, 24, 180"
"Block26= 8030, 35000, 120, 24, 180, 24, 180"
"Block27= 12530, 35000, 120, 24, 180, 24, 180"
"Block28= 17030, 35000, 120, 24, 180, 24, 180"
"Block29= 3530, 39500, 120, 24, 180, 24, 180"
"Block30= 8030, 39500, 120, 24, 180, 24, 180"
"Block31= 12530, 39500, 120, 24, 180, 24, 180"
"Block32= 17030, 39500, 120, 24, 180, 24, 180"
"Block33= 3530, 44000, 120, 24, 180, 24, 180"
"Block34= 8030, 44000, 120, 24, 180, 24, 180"
"Block35= 12530, 44000, 120, 24, 180, 24, 180"
"Block36= 17030, 44000, 120, 24, 180, 24, 180"
"Block37= 3530, 48500, 120, 24, 180, 24, 180"
"Block38= 8030, 48500, 120, 24, 180, 24, 180"
"Block39= 12530, 48500, 120, 24, 180, 24, 180"
"Block40= 17030, 48500, 120, 24, 180, 24, 180"
"Block41= 3530, 53000, 120, 24, 180, 24, 180"
"Block42= 8030, 53000, 120, 24, 180, 24, 180"
"Block43= 12530, 53000, 120, 24, 180, 24, 180"
"Block44= 17030, 53000, 120, 24, 180, 24, 180"
"Block45= 3530, 57500, 120, 24, 180, 24, 180"
"Block46= 8030, 57500, 120, 24, 180, 24, 180"
"Block47= 12530, 57500, 120, 24, 180, 24, 180"
"Block48= 17030, 57500, 120, 24, 180, 24, 180"
Block Column Row ID Name Sequence
1 1 1 YHR185C-D-R PFS1 AGAGATCCACTTCCCATAATT
1 2 1 YHR185C-D-R PFS1 AGAGATCCACTTCCCATAATT
1 3 1 YIR043C-D CTGCACATTCGATTACAGCG
1 4 1 YIR043C-D CTGCACATTCGATTACAGCG
1 5 1 YHR067W-D RMD12 TTATGCACCGTGACGAGGCT
1 6 1 YHR067W-D RMD12 TTATGCACCGTGACGAGGCT
1 7 1 YBR296C-U PHO89 CACGACCGACAATATGGTGA
1 8 1 YBR296C-U PHO89 CACGACCGACAATATGGTGA
1 9 1 YOL076W-U MDM2 ACGGATGGATCAGTTGCTAT
1 10 1 YOL076W-U MDM2 ACGGATGGATCAGTTGCTAT
1 11 1 YNL204C-U SPS18 GCGCTGGCACAAGAATACCA
1 12 1 YNL204C-U SPS18 GCGCTGGCACAAGAATACCA
1 13 1 YLR205C-U HMX1 AACTGAACATACCCGGTGAC
1 14 1 YLR205C-U HMX1 AACTGAACATACCCGGTGAC
1 15 1 YJL039C-D NUP192 TTGAGCCCGATCAGTCGATG
1 16 1 YJL039C-D NUP192 TTGAGCCCGATCAGTCGATG
1 17 1 YGR029W-D ERV1 TTACGTCCCGGATGCCGTTT
1 18 1 YGR029W-D ERV1 TTACGTCCCGGATGCCGTTT
1 19 1 YEL072W-D RMD6 TGCAGCACGCAAGACCATGA
1 20 1 YEL072W-D RMD6 TGCAGCACGCAAGACCATGA
1 21 1 YDR022C-D CIS1 GGTCGATAATAACACGCCAC
1 22 1 YDR022C-D CIS1 GGTCGATAATAACACGCCAC
1 23 1 YBL086C-U ACCACTCACTAAGGAGGATC
1 24 1 YBL086C-U ACCACTCACTAAGGAGGATC
1 1 2 YLR327C-D-R GATAACGACTCAGTGC
1 2 2 YLR327C-D-R GATAACGACTCAGTGC
1 3 2 YIL033C-D BCY1 GGATATTAGCCATCTACGTG


description des différentes parties
le fichier est spéraré en 3 parties
les 2 première ligne donne des info sur la structure du fichier
il y a ensuite le header du fichier
puis les données
1ere ligne -> ATF : conforme au format Axon Text File
1 : version du format
2eme ligne -> 51 : nombre de ligne dans le header
6 : nombre de colonne dans les données
3éme à 53 ème ligne ->header
Type=GenePix ArrayList V1.0 -> type du fichier
BlockCount=48 -> nombre de block
BlockType=0 ->Type de block decrit :
0 = rectangulaire.
1 = orange-packing #1.
2 = orange-packing #2.
“Block1= 3530, 8000, 120, 24, 180, 24, 180″ ->position et dimension de chaque block
xOrigin : position x du centre de la feature la plus en haut a gauche
yOrigin : position y du centre de la feature la plus en haut a gauche
FeatureDiameter : Diamètre des features du block
xFeature : Nombre de colonnes de features dans le block
xSpacing : espacement des colonnes
yFeature : Nombre de lignes de features dans le block
ySpacing : espacement des lignes
54eme ligne -> ligne de titre des colonnes
55eme ligne a la fin -> information pour chaque features

Le parser doit donc spécifiquement
lire la première ligne et stocker le format de fichier et sa valeur
lire la 2eme ligne et stocker le nb de ligne de header et le nb de colonne (pas vraimenet utile)
lire toute les ligne du header, les parser pour séparer la clé des données
(possible de rajouter un mini parser pour les données de block)
puis lire les données.
je vais donc faire un parser héritant de la classe Items.
je vais surclasser parse_header pour traiter les 1ere ligne et le header
puis parser le rester par les méthodes de Items.

le code du parser

class Gal_parser(Items):'''Gal_parserparser for *.gal filesx = Gal_parser(**arg)options :file_arg -> file path or file handleitem_list -> list of item instances

'''

def __init__(self, **arg):'''x = Gal_parser(**arg)'''#call the init method of ItemsItems.__init__(self, **arg)

def parse_header(self, fhin):'''x.parse_header(fhin)fhin -> fileparse the header of the file.

'''#get the format of the file (1st line of the file)file_format = fhin.readline()#check if it's a ATF fileif not "ATF" in file_format :    raise FormatError("%s format is not correct" % fhin.name)#store the file_format dataself.file_format=split(file_format, '\t')

#get the file structure data (2nd line of the file)try :    self.nb_header_rows, self.nb_cols=split(fhin.readline(), '\t')except ValueError :    self.nb_header_rows = fhin.readline()

self.nb_header_rows = int(self.nb_header_rows)

#create the structure for the headerself.header={}#get all the header lines and parse themfor i in range(self.nb_header_rows) :    try :        k,v = self.parse_header_line(fhin.readline())    except AttributeError :        continue    except ValueError :        continue    self.header[k] = v#set the parse_header flag to true, so it won't be parsed again laterself.flag['parse_header'] = True

def parse_header_line(self, line):'''k,v = x.parse_header_line(line)clean the line and split the key and the value'''#cleaning of the linetry :    #remove backspace    line = remove_end_line(line)    #remove "    line=replace(line,'"', '')    #remove tab    line=replace(line,'\t', '')

except AttributeError :    print "no replace for %s" % line    raise#split the line with the field separator =#and return the resulting tuple ok key/valuetry :    return split(line,"=")except ValueError :    print "no = in %s" % line    raise

def get_header(self, *arg):'''header = x.get_header(*arg)return the header dictionnaryarg ->    keys : return keys of header    values : return values of header    items : return tuple ok key/value of header'''#check the arg optionif 'keys' in arg : return self.header.keys()if 'values' in arg : return self.header.values()if 'items' in arg : return self.header.items()#if no optionreturn self.header

class FormatError(exceptions.Exception):def __init__(self, msg=''):self.errmsg = msg

def __str__(self):return self.errmsg

j’ai ajouté un classe FormatError pour gérer les erreur de format de fichier.
j’ai modifié la fonction de test

def test_gal_parser(self):'''test si l'heritage fonctionne bien'''file_format="ATF"file_format_version = 1header_row_nb = 2data_col_nb = 3header_key_1 = "key1"header_val_1 = "val1"header_key_2 = "key2"header_val_2 = "val2"col_1 = "col_1"col_2 = "col_2"col_3 = "col_3"data_l1_c1 = "data_l1_c1"data_l1_c2 = "data_l1_c2"data_l2_c1 = "data_l2_c1"data_l2_c2 = "data_l2_c2"data_l2_c3 = "data_c3"data_l1_c3 = "data_c3"test_file='''%s\t%s%s\t%s%s=%s"%s=%s"%s\t%s\t%s%s\t%s\t%s%s\t%s\t%s''' % (file_format, file_format_version,header_row_nb, data_col_nb,header_key_1, header_val_1,header_key_2, header_val_2,col_1, col_2, col_3,data_l1_c1, data_l1_c2, data_l1_c3,data_l2_c1, data_l2_c2, data_l2_c3)self.write_tmp_file(filetext = test_file)test_gal = Gal_parser(file_arg = 'tmp_file')self.assert_(isinstance(test_gal,Gal_parser))self.assert_(len(test_gal.get_header())==2)

self.assert_(test_gal.get_header('keys')==[header_key_2, header_key_1])self.assert_(test_gal.get_header('values')==[header_val_2, header_val_1])self.assert_(len(test_gal)==2)self.assert_(test_gal[0].get_attribute(col_1)==data_l1_c1)

file_format="ATG"test_file='''%s\t%s%s\t%s%s=%s"%s=%s"%s\t%s\t%s%s\t%s\t%s%s\t%s\t%s''' % (file_format, file_format_version,header_row_nb, data_col_nb,header_key_1, header_val_1,header_key_2, header_val_2,col_1, col_2, col_3,data_l1_c1, data_l1_c2, data_l1_c3,data_l2_c1, data_l2_c2, data_l2_c3)self.write_tmp_file(filetext = test_file)self.assertRaises(FormatError, Gal_parser, filename = 'tmp_file')

remove('tmp_file')

test_gal = Gal_parser(file_arg = '/home/gim2/bioinfo/microarray/barcode12k_v2final.gal');self.assert_(isinstance(test_gal,Gal_parser))self.assert_(len(test_gal.get_header())==51)

et le test me renvoie

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 7 tests in 2.844s

OK

j’ai donc un parser de fichier gal qui fonctionne bien.
quel est le but de tout ca ?
l’idée est de parser le fichier de description de la puce et de mettre les infos dans la base de donnée. je cherche également a liéer les spot aux orf du genome de la levure.
j’ai précédemment examiné le fichier gal et d’autre fichiers décrivant les puces (12 mars, 13 mars (1) et 13 mars (2)
l’analyse de ces fichier a permis de constater que l’annotation de certain spot ne coorespond plus a une orf existante. mais que cette ancienne annotation est généralement toujours présente dans les alias des orf.
l’analyse plus fine de cela a meme permis de déterminer que seule 7 annotations avaient réellement totalement disparues.
YAR037W YAR040C YAR043C YCL006C YCL013W YCL026C YCL053C
ce qui correspond a 30 spot au total
grep YCL053C ~/bioinfo/microarray/barcode12k_v2final.gal
1 23 19 YCL053C-U CTATTGTTGAAATGCCGGGA
1 24 19 YCL053C-U CTATTGTTGAAATGCCGGGA
39 23 20 YCL053C-D CATAGTCGAGAACCGGAGAC
39 24 20 YCL053C-D CATAGTCGAGAACCGGAGAC
grep YAR043C ~/bioinfo/microarray/barcode12k_v2final.gal
34 3 8 YAR043C-U ATTCTAGCGGCAGATCCGTG
34 4 8 YAR043C-U ATTCTAGCGGCAGATCCGTG
grep YCL013W ~/bioinfo/microarray/barcode12k_v2final.gal
13 23 22 YCL013W-D CGCTCGAACATAATTGGGTA
13 24 22 YCL013W-D CGCTCGAACATAATTGGGTA
25 23 22 YCL013W-U CCTGTCAGTAAACCGAGAGA
25 24 22 YCL013W-U CCTGTCAGTAAACCGAGAGA
grep YCL026C ~/bioinfo/microarray/barcode12k_v2final.gal
5 23 21 YCL026C-D CCTCCGAACAGAGAGTCTTA
5 24 21 YCL026C-D CCTCCGAACAGAGAGTCTTA
13 3 4 YCL026C-A-U FRM2 GCTCACCGAACATCAGATTA
13 4 4 YCL026C-A-U FRM2 GCTCACCGAACATCAGATTA
17 3 21 YCL026C-U-R CCTCTGCTAAGTAGTAGA
17 4 21 YCL026C-U-R CCTCTGCTAAGTAGTAGA
17 23 21 YCL026C-U CCCTCTGCTAAAGTAGTAGA
17 24 21 YCL026C-U CCCTCTGCTAAAGTAGTAGA
42 5 19 YCL026C-A-D FRM2 GGCGGACTACAACACATTCA
42 6 19 YCL026C-A-D FRM2 GGCGGACTACAACACATTCA
grep YCL006C ~/bioinfo/microarray/barcode12k_v2final.gal
23 23 23 YCL006C-D CCCGCTAGTCAATAATCGTA
23 24 23 YCL006C-D CCCGCTAGTCAATAATCGTA
29 5 15 YCL006C-D CCCGCTAGTCAATAATCGTA
29 6 15 YCL006C-D CCCGCTAGTCAATAATCGTA
35 23 23 YCL006C-U CCTGAAGATAAATCCCGTCA
35 24 23 YCL006C-U CCTGAAGATAAATCCCGTCA
41 5 15 YCL006C-U CCTGAAGATAAATCCCGTCA
41 6 15 YCL006C-U CCTGAAGATAAATCCCGTCA
grep YAR040C ~/bioinfo/microarray/barcode12k_v2final.gal
7 3 9 YAR040C-U CCATCTCAGTGGGTGCAATG
7 4 9 YAR040C-U CCATCTCAGTGGGTGCAATG
grep YAR037W ~/bioinfo/microarray/barcode12k_v2final.gal
23 3 9 YAR037W-U AGCTAGACTATCGCCCAATG
23 4 9 YAR037W-U AGCTAGACTATCGCCCAATG
a
l’ideal serait de faire cette identification lorsque j’ajoute le fichier gal dans la base.
si on suppose que la liste des orf est dans la base de donnée.
il faut donc extraire le nom des annotation des spot, retirer les caractère qui ont été ajouté pour les puc (U, D et R) en faire une liste d’occurences uniques et les rechercher dans la base de données.
je vais faire une premiere version mais en utilisant un fichier gff au lieu de de la base de donnée.
il faut deja récupéré les ID des spots.
pour ca j’utilise la méthode get_attr_list qui me renvoie la liste des valeur d’un attribut pour l’ensemble des items.
j’utilise ensuite un set pour stocker ces valeur, ainsi je n’ai que celles qui sont distincte.
j’utilise ensuite une expression régulière pour eliminer les -D, -U, et -R

def extract_annotation_id(annot_id):return re.sub(r'-[RUD]+[1-9]*','',annot_id)

def analyse_gal_file():gal_file = '/home/gim2/bioinfo/microarray/barcode12k_v2final.gal'gal = Gal_parser(file_arg = gal_file)id = gal.get_attr_list('ID')print "il y a %i ID de spot dans %s" % (len(id), gal_file)id_set = set(id)print "il y a %i ID distintes dans %s" % (len(id_set), gal_file)id=map(extract_annotation_id, id)id_set = set(id)print "il y a %i annotations d'orf dans %s" % (len(id_set), gal_file)

j’obtiens

il y a 27648 ID de spot dans /home/gim2/bioinfo/microarray/barcode12k_v2final.galil y a 12677 ID distintes dans /home/gim2/bioinfo/microarray/barcode12k_v2final.galil y a 5920 annotations d'orf dans /home/gim2/bioinfo/microarray/barcode12k_v2final.gal

j’arrive donc a récupérer les 5920 orf utilisée dans ces puces
il faut ensuite aller les comparer avec celles du fichiers gff
je refais donc un parser gff rapide (ici)

puis je sélectionne les id des orf
gff_file = '/home/gim2/bank//saccharomyces_cerevisiae.gff'
gff = Gff_parser(file_arg = gff_file)
id2 = gff.get_attr_list('ID')
il y a 16316 ID dans /home/gim2/bank//saccharomyces_cerevisiae.gff
si je prends les tag name et gene en plus j’ai :
id2 = gff.get_attr_list('ID') + gff.get_attr_list('Name') + gff.get_attr_list('gene')
il y a 48948 ID, Name et gene dans /home/gim2/bank//saccharomyces_cerevisiae.gff
si j’utilise les set pour connaitre n’avoir que des valeurs distinctes j’ai :
il y a 16316 ID dans /home/gim2/bank//saccharomyces_cerevisiae.gff
il y a 8098 ID distinctes dans /home/gim2/bank//saccharomyces_cerevisiae.gff
il y a 48948 ID, Name et gene dans /home/gim2/bank//saccharomyces_cerevisiae.gff
il y a 12879 ID, Name et gene distincts dans /home/gim2/bank//saccharomyces_cerevisiae.gff
j’ai besoin aussi des alias des orf car ce sont parfois les anciens noms de ces orfs

alias=gff.get_attr_list('Alias')  for x in alias :      if not x : continue      x=split(x,',')      id2 += x  print len(id2)  print 'il y a %i ID, Name, gene et alias dans %s' % (len(id2), gff_file)  id_set2 = set(id2)  print 'il y a %i ID, Name, gene et alias distincts dans %s' % (len(id_set2), gff_file)

et j’obtiens

il y a 65786 ID, Name, gene et alias dans /home/gim2/bank//saccharomyces_cerevisiae.gffil y a 15774 ID, Name, gene et alias distincts dans /home/gim2/bank//saccharomyces_cerevisiae.gff

je vais donc comparer les id du fichier gal et ceux du fichier gff en faisant une simple différence de set
print "il y a %i ID presente dans %s qui sont absentes de %s" % (len(id_set2), gal_file, gff_file)
print "ce sont les ID : ", id_set.difference(id_set2)

il y a 15774 ID presentes dans /home/gim2/bioinfo/microarray/barcode12k_v2final.gal qui sont absentes de /home/gim2/bank/saccharomyces_cerevisiae.gffce sont les ID :  set(['YCL053C', 'YAR043C', 'Spotting Buffer', 'YCL013W', 'Empty', 'YCL026C', 'YCL006C', 'YAR040C', 'YAR037W'])

Ca correspond a celles trouvées précédemment

14 avril 2008 – ajout du module de conversion des données

10h48
suite de la construction du parser global.
pour mieux utiliser les données dans le parser, il est utile de les convertir au bon format.
elles sont toutes reconnues comme texte.
les seuls autres types pouvant exister pour des données sont integer ou float.
il pourrait y avoir des booléens mais on va partir du principe qu’il n’y en a pas.
les types listes ou autre propres a python ne sont pas présents dans des fichiers de données.
la conversion des données est intéressante mais ralenti le parsing.
il me semble que malgré tout il y a un gain de temps par la suite
La conversion utilise la fonction try. qui permet e s’affranchir de pas mal de test qui sont réalisé par les fonction de conversion elle-meme. ces fonctions sont int et float.
code du convertisseur

 def set_type(self, value):     '''     val = x.set_type(value)     value -> str     val -> str, int or float     convert the data to the correct data type     '''     #store the data into the return variable     val = value     #try converting     try :         #try first to convert into a float         val = float(value)         #if succeed, try to convert into an integer         val = int(value)     except ValueError:         #catch a converting error, either from float or int         pass     #return the stored value     return val

et le code du test correspondant

 def test_type_parsed_data(self):     '''     teste si le type des donnees parsees est correcte     '''     header_info_1 = "header_01"     header_info_2 = "header_02"     col_1 = "col_1"     col_2 = "col_2"     col_3 = "col_3"     data_l1_c1 = "texte"     data_l1_c2 = 1     data_l2_c1 = 1.5     data_l2_c2 = "1e+5"     test_file='''#%s#%s%s\t%s%s\t%s%s\t%s''' % (header_info_1, header_info_2, col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(type(test_item[0].get_attribute(col_1)) == type(data_l1_c1))     self.assert_(type(test_item[0].get_attribute(col_2)) == type(data_l1_c2))     self.assert_(type(test_item[1].get_attribute(col_1)) == type(data_l2_c1))     self.assert_(type(test_item[1].get_attribute(col_2)) == type(float(data_l2_c2)))

     remove('tmp_file')

ce qui donne en sortie de la fonction test

..the argument is not a regular file objectfile toto doesn't existpermission denied for file tmp_parse.txt..----------------------------------------------------------------------Ran 4 tests in 0.065s

OK

11h34
le parser est bien avancé. il lui manque quelques fonctions comme l’impression

c’est facile a ajouter. l’impression sera par defaut basique en utilisant les marker et séparateur par défaut.
touts les attributs seront imprimé par défaut.
il sera cependant possible de spécifier ces paramètres

DANS Items def __str__(self, text_sep='', attr_list=[]):     '''     print x  x.__str__()     print the data in a text format, using default options

     '''     #if no text separator was specified, use the default one     if not text_sep : text_sep = self.text_sep     #if no attribute list was specified, use the default one if exist or nothing     if not attr_list :         try :             attr_list = self.attr_list         except AttributeError :             pass     #if header exist add the header_mark at the top of the each line     #and add all lines into the text to print     try :         text_list = map(lambda x: self.header_mark + x , self.header)     except AttributeError :         text_list = []     #if exist, add the attribute list, join by the text separator     if attr_list : text_list += [join(attr_list,text_sep)]     #call the print method of the item using the text separator and the attribute list as options     #and add the resulting text into the text to print     text_list += [item.__str__(text_sep=text_sep, attr_list=attr_list) for item in self]     #join element of the text to print by a \n and return it     return join(text_list, '\n')

DANS Item def __str__(self, text_sep = '\t', attr_list = []):     '''     print x  x.__str__()     print all element of x using tabulation as default text separator     options :     x.__str__([text_sep, [attr_list]])     print only the values of the attributes specified in attr_list     return the values as text using text_sep as text separator

     '''     #if no attribute list, use all the attributes of self         if not attr_list : attr_list = self.keys()     #get the value of the attributes in attr_list or an empty string if attribute does'nt exist     text_val = [self.get(attr, '') for attr in attr_list]     #return the values in a text format join by text_sep     return join(map(str,text_val), text_sep)

et j’ai donc ajouté un module de test pour cette fonction

 def test_printed_data(self):     '''     teste si les donnees parsees sont imprimees correctement     '''     header_info_1 = "header_01"     header_info_2 = "header_02"     col_1 = "col_1"     col_2 = "col_2"     data_l1_c1 = "data_l1_c1"     data_l1_c2 = "data_l1_c2"     data_l2_c1 = "data_l2_c1"     data_l2_c2 = "data_l2_c2"

     #test with a complete file     test_file='''#%s#%s%s\t%s%s\t%s%s\t%s''' % (header_info_1, header_info_2, col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     #test using a specific attribute list     test_file='''#%s#%s%s\t%s%s\t%s%s\t%s''' % (header_info_1, header_info_2, col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     attr_list=[col_1]     test_file='''#%s#%s%s%s%s''' % (header_info_1, header_info_2, col_1, data_l1_c1, data_l2_c1)     self.assert_(test_item.__str__(attr_list=attr_list) == test_file)

     #test using a specific text separator     test_file='''#%s#%s%s\t%s%s\t%s%s\t%s''' % (header_info_1, header_info_2, col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     attr_list=[col_1]     test_file='''#%s#%s%s;%s%s;%s%s;%s''' % (header_info_1, header_info_2, col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.assert_(test_item.__str__(text_sep=";") == test_file)

     #test with no header     test_file='''%s\t%s%s\t%s%s\t%s''' % (col_1, col_2, data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     #test with no attribute list     test_file='''%s\t%s%s\t%s''' % (data_l1_c1, data_l1_c2, data_l2_c1, data_l2_c2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     #test with no data     test_file='''%s\t%s''' % (col_1, col_2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     #test with only header     test_file='''#%s#%s''' % (header_info_1, header_info_2)     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     #test with nothing     test_file=''     self.write_tmp_file(filetext = test_file)     test_item = Items(file_arg = 'tmp_file')     self.assert_(test_item.__str__() == test_file)

     remove('tmp_file')     def valid_object(self, nb_header_line, nb_col, nb_line):     '''     x.valid_object(nb_header_line, nb_col, nb_line)     create a tmp file with the given parameters     parse the file using Items     test if all data have been correctly parsed     '''     #create the name of the file using the parameters (it could have been an arbitrary filename)     filename = 'file_%s_%s_%s' % (nb_header_line, nb_col, nb_line)     #call the method for creating the file     self.create_tmp_file(filename, nb_header_line, nb_col, nb_line)

     self.valid_item(filename=filename, nb_header_line=nb_header_line, nb_col=nb_col, nb_line=nb_line)

     #delete te tmp file     self.delete_tmp_file(filename)

qui renvoie

...the argument is not a regular file objectfile toto doesn't existpermission denied for file tmp_parse.txt..----------------------------------------------------------------------Ran 5 tests in 0.065s

OK

je vais aussi ajouter une fonction assez pratique au parser.
il s’agit d’une sorte d’index des infos qui sont dans les attributs.
je ne suis pas sur que ce soit pertinenet car ca risque d’etre lourd d’un point de vue traitement.
il faut probablement que ce soit fait a la demande.
comment procéder ?
il faut une fonction de requete.
cette fonction va créer l’index nécessaire s’il n’existe pas et rechercher dedans par la suite.
elle va donc passer par une fonction de création d’index. cette fonction var créer l’index souhaité pour le ou les attributs passé en argument.
en laissant la possibilité d’avoir plusieurs attributs en argument, on s’assure que la fonction pourra etre utilisée dans d’autre cas, comme la création de ces index de manière explicite.
si aucun argument est passé a cette fonction alors l’ensemble des index pour chaque attribut sera créé (risque d’etre long)

def create_indexes(self, attr_list=[]):       '''       x.create_indexes([attr_list])       attr_list -> list of string or str       create indexes for a list of attribute       '''       #test if there is an argument       if not attr_list :           #if not try to get the default attribute list           try :               attr_list = self.attr_list           except AttributeError :               #catch the error if it does'nt exist               print "no attribute for these data, indexes cannot be created"               #and stop function by raising error               raise       #build the index for each item       map(lambda x : self.build_index(x, attr_list), self)

   def build_index(self, item, attr_list):       '''       x.build_index(item, attr_list)       item -> instance of item       attr_list -> list of str or str       '''       #if attr_list is a single string, convert, put it in a list       if type(attr_list) == str : attr_list=[attr_list]       #for each attr       for attr in attr_list :           #test if it's a valid attribute           if attr not in self.attr_list :               print "%s is not a valide attribute" % attr               continue           #try to access to the value associated with the key attr           #if it doesn't exist, create the key as an empty dict and return it           try :               attr_index_list = self.indexes.setdefault(attr,{})           except AttributeError :               #catch the error if the attribute indexes does'nt exist,               #and create it               self.indexes = {}               attr_index_list = self.indexes.setdefault(attr,{})           #get the list associated with the key of the attribute of the item           #or an empty list if the key does'nt already exist           attr_index_item_list = attr_index_list.setdefault(item.get_attribute(attr), [])           #add item into this list           attr_index_item_list.append(item)

   def get_items_by_value(self, attr, value):       '''       item_list = x.get_items_by_value(attr, value)       attr -> str       value -> str, int or float       item_list -> instance of Items       return a list of items having a specified value for the attribute attr       '''

       try :           #check if the attr is in the attribute list           if attr not in self.attr_list :               #if not raise a keyError               print "%s is not a valide attribute" % attr               raise IndexError, "%s is not a valide attribute" % attr       except AttributeError :           #catch the AttributeError if ther is no attribute list           print "no attribute list available"           raise       #try to access to the index of the given attribute       try :           attr_index_list = self.indexes[attr]       except AttributeError :           #catch the error if the attribute indexes doesn't exist           #or if the key attr does'nt exist           #the index for the given attribuite is created           self.create_indexes(attr)           #and put into attr_index_list           attr_index_list = self.indexes[attr]       except KeyError :           #catch the error if the attribute indexes doesn't exist           #or if the key attr does'nt exist           #the index for the given attribuite is created           self.create_indexes(attr)           #and put into attr_index_list           attr_index_list = self.indexes[attr]       #return an instance of items with the list of the items matching with the given value       return Items(item_list = attr_index_list.get(value, []))   

j’ai du coup du modifier un peu le __init__ pour qu’il accepte des liste de item pour créer l’objet. cela permet dans une fonction de recherche de renvoyer un sous ensemble de l’objet de la meme forme que l’objet (une instance de items) plutot que une simple liste.
j’ai ajouté le code de test correspondant

def test_indexed_data(self):       '''       teste si les index creer sont correct       '''       header_info_1 = "header_01"       header_info_2 = "header_02"       col_1 = "col_1"       col_2 = "col_2"       col_3 = "col_3"       data_l1_c1 = "data_l1_c1"       data_l1_c2 = "data_l1_c2"       data_l2_c1 = "data_l2_c1"       data_l2_c2 = "data_l2_c2"       data_l2_c3 = "data_c3"       data_l1_c3 = "data_c3"       test_file='''#%s#%s%s\t%s\t%s%s\t%s\t%s%s\t%s\t%s''' % (header_info_1, header_info_2, col_1, col_2, col_3, data_l1_c1, data_l1_c2, data_l1_c3, data_l2_c1, data_l2_c2, data_l2_c3)       self.write_tmp_file(filetext = test_file)       test_item = Items(file_arg = 'tmp_file')       items_index_1 = test_item.get_items_by_value(col_1, data_l1_c1)       self.assert_(isinstance(items_index_1,Items))       self.assert_(len(items_index_1)==1)       self.assert_(isinstance(items_index_1[0], Item))       self.assert_(items_index_1[0].get_attribute(col_1) == data_l1_c1)

       items_index_2 = test_item.get_items_by_value(col_3, data_l1_c3)       self.assert_(isinstance(items_index_2,Items))       self.assert_(len(items_index_2)==2)       self.assert_(isinstance(items_index_2[0], Item))       self.assert_(isinstance(items_index_2[1], Item))       self.assert_(items_index_2[0].get_attribute(col_3) == data_l1_c3)       self.assert_(items_index_2[1].get_attribute(col_3) == data_l2_c3)

       items_index_3 = test_item.get_items_by_value(col_1, 'toto')       self.assert_(isinstance(items_index_3,Items))       self.assert_(len(items_index_3)==0)       self.assertFalse(items_index_3)

       self.assertRaises(IndexError, test_item.get_items_by_value, attr = 'col_0', value = 'toto')     

       remove('tmp_file')

le test renvoie alors

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 6 tests in 0.170s

OK

Le parser a l’air a peu pret complet, a voir a l’usage.
–> todo list tester le parser sur un plus gros fichier, type gal

9 avril 2008 – recherche du maximum de densité des segments (2)

10h43
suite de recherche du maximum de densité des segments
je dois donc modifier mon code pour tenir compte du décalage de 18 nucléotides.
2 possibilités:
- je modifie les positions des tags sur chr1278
- je rajoute une étape dans le script de find_max_segment qui repositionne le segment comme par rapport au start des sages.

la 2eme solution est simple (la première aussi cela dit) mais elle implique que le génome utilisé sera toujours décalé de 18.
c’est finalement idiot, il serait mieux de partir avec un génome bien recalé.
quand j’étudie en détail les position je constate que:
- les positions sur les brins watson sont celles du premier nucléotide du sage (coté 5′)
- les positions sur les brins crick sont celles du dernier nucléotide avant le sage (en 5′)
ce qui nous intéresse c’est finalement la position du premier nucléotide après le sage, en 3′
je dois donc faire :
-> pos + 18 pour les tag sur les brin watson
-> pos – 19 pour les tag sur le brin crick

la matrice chr_len donne les positions de chaque chromosome et brin sur le génome linéarisé. a partir de cette matrice je peux effectuer les corrections nécessaires.
j’ai écrit un script pour ca

function res = tag_position_correction(genome, chr_len)%res = tag_position_correction(genome, chr_len)%fonction permettant de modifier la position des tag sur un génome linearisé%de +18 s'ils sont sur le brin watson et -19 sur le brin crick%la position des brin est donnée dans chr_len

%recupere la taille du genomenb_chr = size(chr_len,1);%alloue l'espace pour le resultatres = zeros(size(genome));%pour chaque birn de chaque chromosomefor i = 1:nb_chr %recupère l'information du brin strand = chr_len{i,2}; if strcmp('c', strand)     %si c'est crick alors decalage de -19     decalage = -19; else     %si c'est watson alors decalage de +18     decalage = 18; end %teste de la valeur de i dans la boucle if i>1     %si i>1 alors on recupère la position du début du chromosome sur la     %ligne précédente     %on ajoute +1 car la ligne précédente donne le dernier nucléotide     %du brin précédent     %on rajoute + 19 pour anticiper le décalage     deb = chr_len{i-1,4} + 1 + 19; else     %si i=1 alors il n'y a pas de ligne précédente, on demarre au début     %du chromosome

     deb=1 + 19; end %on récupère la position de fin et on retire 18 pour anticiper le %décalage fin = chr_len{i,4} - 18; %on copie dans res la partie du génome entre deb et fin %on les affecte au position deb + decalage à fin + decalage res(deb + decalage:fin + decalage) = genome(deb:fin);end

je l’appelle avec la commande chr1278_2 = tag_position_correction(chr1278, chr_len);

je peux maintenant réappliquer le script density sur cette matrice
density = densite_sage(chr1278_2, 20);
et j’applique le script find_max_segment dessus
res=find_max_segment(density, ratio2_5_100_1);
dans ratio2_5_100_1 j’avais également une erreur de position pour les segment des brin crick qui sont decalés de +1
j’ai créé segment_list a partir de ratio2_5_100_1 en corrigeant ce décalage.
es brins ont tous une référence (de 1 à 34)
les brins crick sont tous impaires
je cherche pour chaque segment si la référence du brin sur lequel il se trouve
est paire ou non

l=mod(res(:,6),2);

comme j’ai 1 pour les brin crick et 0 pour les brin watson, et que le décalage est de +1
je retire la matrice l aux colonnes contenant les positions des brins

segment_list(:,[2 3 7 8]) = segment_list(:,[2 3 7 8]) - l*ones(1,4);

puis je recherche le max de densité des segments

res=find_max_segment(density, segment_list);

le résultat semble correct.
toutefois quand les tags d’un meme segments sont éloignés d’une distance supérieur à la fenetre utilisée pour calculer la densité, le max de densité est mal placé.
il faut peut-etre utiliser 100 comme fenetre pour etre sur de couvrir les segments les plus grand.
density_100 = densite_sage(chr1278_2, 100);
res_100=find_max_segment(density_100, segment_list);
cette fois il ne semble plus y avoir de probleme

il faut donc exporter ce résultat.
le résultat est enregistré dans la matrice seg_list_dist_density_max
avant de l’exporter j’ajoute une colonne avec l’ancienne valeur de milieu de segment.
cela permettra de ne pas modifier les références des segments des brins crick.
je modifierai les références plus tard.
pour ajouter la valeur du milieu du segment je fais
seg_list_dist_density_max(:,end+1)=floor(mean(ratio2_5_100_1(:,7:8)'))';
je sauve ensuite la matrice en csv
save(strcat('seg_list_dist_density_max','.mat.csv'),'seg_list_dist_density_max', '-ascii','-tabs');
puis je l’exporte sur douanier rousseau
scp berthe:/home/gim/sage/total/stats/ratio2_5/max_segments/seg_list_dist_density_max.mat.csv /home/gim/sage/total/stats/ratio2_5/max_segments/

j’execute sur ce fichier les script de segment.py
en modifiant le nom du fichier d’entrée.
j’ai modifié aussi le script de matlab2csv pour qu’il ajoute dans la ligne de titre les colonnes density_max et mid

le fichier contenant les résultat brut en csv est ~/sage/total/stats/ratio2_5/max_segments/seg_list_dist_density_max.csv
le fichier contenant les distances avec les features environanantes est dans ~/sage/total/stats/ratio2_5/max_segments/segments_description_density_max.csv

je transfert ce fichier sur bambino
j’applique dessus la macro classification du fichier F:/users/christophe/search_features_A_and_B.xls a
je récupère le fichier F:/users/christophe/sements_description_density_max.xls
je l’exporte sur douanierousseau dans
~/sage/total/stats/ratio2_5/max_segments/segments_description_density_max.xls
j’élimine les colonnes avec du texte
je sauve dans ~/sage/total/stats/ratio2_5/max_segments/segments_distance_to_feature_using_density_max.csv
j’exporte sur berthemorisot
je l’ouvre dans matlab dans la matrice data_using_density_max
j’ouvre data_using_max et data_using_mid dans distances_using_max.mat
je compare les résultats obtenus avec les autres matrices.
j’ai écrit un script qui affiche les courbes pour les 3 matrices en fn de la classe, et de la config des features

function plot_with_n_variable(classe, feature_extreme, feature_sens, data_using_max, data_using_density_max, data_using_mid)  cols=cell(4,3);

  cols{1,1}='start';  cols{1,2}='sens';  cols{1,3}=[10 16];

  cols{2,1}='start';  cols{2,2}='antisens';  cols{2,3}=[12 18];

  cols{3,1}='end';  cols{3,2}='sens';  cols{3,3}=[9 17];

  cols{4,1}='end';  cols{4,2}='antisens';  cols{4,3}=[15 19];

  for i=1:4      if strcmp(cols{i,1}, feature_extreme) && strcmp(cols{i,2}, feature_sens)          columns=cols{i,3};      end  end

  figure;  title(strcat('distance from MAX of segment to ',feature_extreme, '  of features in  ',   feature_sens));  hold all;  for i=1:10  distance_c1_start_sens=mk_distance_hist(data_using_max, classe, columns, -1000, 1000, i, 20);  hist_c1_start_sens=frequence(distance_c1_start_sens,-1000,1000,200);  plot(hist_c1_start_sens(:,1),hist_c1_start_sens(:,2))  end

  figure;  title(strcat('distance from DENSITY MAX of segment to ',feature_extreme, ' of features in ', feature_sens));  hold all;  for i=1:10  distance_c1_start_sens=mk_distance_hist(data_using_density_max, classe, columns, -1000, 1000, i, 20);  hist_c1_start_sens=frequence(distance_c1_start_sens,-1000,1000,200);  plot(hist_c1_start_sens(:,1),hist_c1_start_sens(:,2))  end

  figure;  title(strcat('distance from MID of segment to ',feature_extreme, ' of features in ', feature_sens));  hold all;  for i=1:10  distance_c1_start_sens=mk_distance_hist(data_using_mid, classe, columns, -1000, 1000, i, 20);  hist_c1_start_sens=frequence(distance_c1_start_sens,-1000,1000,200);  plot(hist_c1_start_sens(:,1),hist_c1_start_sens(:,2))  end

je peux alors utiliser la commande
plot_with_n_variable(1, 'start', 'sens', data_using_max, data_using_density_max, data_using_mid)




on observe une dispersion légèrement plus faible pour les résultats obtenus en utilisant le maximum de densité des segments.

8 avril 2008 – recherche du maximum de densité des segments

17h52 :
au lieu de localiser les segments par rapport à la position du maximum de tag dans un segment, je vais le faire par rapport à la position du maximum de densité.
pour evaluer la densité, je fais avancer une fenetre dont la taille L est a déterminer.
je compter alors le nb de sage dans la fenetre et cette valeur sera alors la densité pour la position correspondant au milieu de la fenetre.
ainsi si plusieurs tag se suivent mais sans se chevaucher, la fenetre de densité va augmenter qd meme en s’approchant du milieu du segment car c’est a cet endroit qu’il y aura un max de segment environnant.



le schema ci-dessus représente un comptage théorique pour un segments dont aucun tag ne se chevauchent. les points bleus représentent la courbe de densité qui serait obtenu. on voit que le max de densité serait environ au 2/3 du segment.
j’ai écrit une fonction pour le calcul de la densité

function density = densite_sage(chr, window)%density = densite_sage(chr, window)%-input%  chr -> entire genome%  window -> size of the window to determine the densitty%-output%  density -> result, matrice with the size of chr

%recupere la taille du genometaille_genome=length(chr);%alloue l'espace mémoire necessaire pour le resultatdensity=zeros(taille_genome,1);%calcul la taille de demi-fenetre%je ne garde que la partie entièrew=floor(window/2);%calcul la somme de tout les tag pour une position i sur une fenetre%encandrant cette position%la fenetre est de taille window si window est impaire et window +1 si%window est pairefor i=1+w:taille_genome-w    density(i)=sum(chr(i-w:i+w));end

le calcul est très simple et renvoie une matrice de densité
j’ouvre le fichier /data/users_data/helen/454/sageData/total/stats/ratio2_5/max_segments/matlab.mat
puis je créé la matrice chr1278 qui contient tous les tags des manip 1, 2 7 et 8 réparti sur l’ensemble du génome.
chr1278=header(:,5)
puis j’execute la commande
density = densite_sage(chr1278, 20);
j’ai donc ma matrice densité.
il faut maintenant associer a chaque segment son max de densité.
j’ai une matrice de segment ratio2_2_100_1
chaque ligne correspond a un segment dont j’ai les coordonnées dans les 2eme et 3eme colonnes.
je vais donc parcourir cette matrice
récupérer les coordonnées du segment sur le génome linéarisé (chr1278)
puis regarder dans cette section sur density ou se trouve le max
s’il y a plusieurs positions max, ca sera la plus centrale qui sera prise.
la position trouvée est inscrite dans la matrice des segment dans la dernière colonne

j’ai écrit un script pour ca

function segment_data = find_max_segment(chr_data, segment_data)%fn pour trouver dans chr_data le max pour chaque segment de segment_data%si chr_data est la liste des tag réparti sur le génome alors la fonction%renvoie la position du nb max de tag%si chr_data est la densité de sage sur tout le génome, alors la fonction%renvoie la position de la densité max de tag dans le segment   [l,c] = size(segment_data);   for i=1:l      start_seg = segment_data(i,2);      stop_seg = segment_data(i,3);      segment=chr_data(start_seg:stop_seg,1);      max_seg=find(segment==max(segment));      pos = floor(mean(length(max_seg)));      segment_data(i,c+1)=segment_data(i, 7) + max_seg(pos) - 1;   end

script très simple.
je le teste par la commande res=find_max_segment(density, ratio2_5_100_1);
le programme marche bien mais en regardant les résultats j’ai constaté que les valeurs étaient assez étrange et souvent mal placée.
en regardant de plus pret j’ai compris l’erreur que j’avais faite.
les positions des tag sur le génnome correspondent au debut des sage sur les chromosome alors que les position des segments dans la liste des segment correspondent à la première position après la fin du sage, soit 18 nucleotides plus loin. la recherche du max se fait donc avec un decalage de 18, mais pas toujours dans le meme sens selon que la partie du génome considérée soit sur le brin watson ou crick.
je vais devoir corriger cela