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.

7 mars 2008 – interface pour SganArrayL

11h17 : maintenant que la base de données est construite il faut faire l’interface pour y accéder, et y entrer des données.

Prenons les choses dans l’ordre. Les premières infos a rentrer sont celles des orfs.
reprenons un peu la table bank_orf

Cette table est un peu pauvre, la table des orf peut-etre bcp plus étendue. dans la base sophia, j’ai créé une table d’orf à partir du fichier gff /home/gim2/bank/saccharomyces_cerevisiae.gff
je vais donc faire pareil pour cette table. et cette fois je vais faire un vrai joli code en python pour ca.
de plus je me dit qu’il faut peut-etre aussi stocker les infos sur la date du fichier d’orf.
bon, y’a plus qu’a retravailler sur un parser de gff finalement.

6 mars 2008 – redéfinition des tables de la base pour SganArrayl (suite)

11h41 : la base que j’avais défini précédemment comportait un certain nombre d’erreur et ne prenait pas en compte les appâts multiples sur une même lame (voir explication)
je l’ai reprise en partant cette fois du point de vu de l’utilisateur, ce qui a mon avis est mieux.
Comment j’ai procédé –> j’ai essayé de voir la façon dont allait procéder l’utilisateur pour rentrer des données en me basant sur la version actuelle de SganArrayL et sur ce que je sais des manip.
d’un point de vue théorique, une manip consiste à hybrider les extraits d’une souche appât et d’une souche contrôle sur une lame et cela plusieurs fois en marquant éventuellement les extraits avec différents fluorochromes.
d’un point de vue pratique, une manip consiste le meme jour a hybrider 6 lames avec plusieurs souche appat différentes et plusieurs controle. l’utilisateur va alors scanner toutes ces lames, générés les fichiers gpr correspondant et les introduire dans la base de données.
l’élément central pour l’utilisateur c’est alors la lame. je suis donc parti de ca pour organiser la base. la table hyb_slide est celle autour de laquelle gravitent toutes les autres plus ou moins directement. c’est finalement assez logique.

cette table comprend un id comme clé primaire, une reférence de lame, un champs metatdat qui ne sera jamais rempli. c juste pour me rappeler de traiter les metadonnées du fichier gpr, un champ de commentaire, un lien vers l’image de la lame, et un lien vers le fichier gpr correspondant. de plus cette table est liée a la table des_experiment par le champs exp_id.

cette table contient un champs common_ref, un champ quality et un champs description. voir MIAME
de plus cette table est liée a des_biblio (liste d’article), des_citations (liste de citation), des_authors (listes des auteurs) et aussi a des_experimental_factors.
la table hyb_slide est aussi liée a la table prep_sample

cette table rassemble les éléments d’autres tables., biomaterial_manipulation, labelling_protocol, organism, extract_preparation
cettet table est dan sla partie sample used, extract preparetion and labelling (voir MIAME). dans cette partie on trouve aussi une table prep_strain, qui va associer a un gène une mutation et une utilisation, par exemple,
orf -> YPL093W – mutation -> DAMP – utilisation -> bait
ou aussi
orf -> YFR057W – mutation -> DAMP – utilisation -> control
le type de mutation et d’utilisation sont dans 2 tables liées à celle-ci.
les orf sont dans une table bank_orf et liée aussi a celle-ci.

la table prep_strain est liée à hyb_strain, elle-meme liée à hyb_slide. hyb_strain est liée aussi a hyb_fluorophore, qui contient la liste des marqueurs fluo utilisés (a priori cy3, cy5, alexa). on peut ainsi par cette table dire pour une plaque quelles sont les bait et control et quels marqueurs ont été utilisés.
hyb_slide est aussi liée à hyb_protocol et hyb_scan_protocol et surtout a hyb_mating_date, qui listera toute les differentes date d’hybridation.
les resultats traité ou non, sont dans la partie measurment data and specification.

la table mes_sot_data est liée à hyb_slide. elle va reprednre les info général sur chaque spot, diamètre, et flag. elle est liée à array_spots de la partie array description

cette table contient les info de position et de nom de chaque spot. elle est liée à array_chip_types pour le type de puce, array_spot_type pour le type de spot (feature ou control) et a bank_orf, pour l’orf a laquelle correspond ce spot.
la table mes_raw_signal est la table contenant les valeurs brute de fluorescence des spot. elles contient 7 champs propres correspondant aux valeurs du signal moyen, median et a l’ecart-type ainsin qu’aux valeurs du background moyen et median et a l’ecart-type. il y a aussi une valeur du rapport signal/bruit (SNR). cette table est liée à spd_id pour savoir de quelle spot il s’agit et à hyb_strain pour savoir de quel marqueur (et donc de quel gène) c’est le signal. dans le cas d’une lame à 3 couleurs ont va donc avoir pour chaque spot 3 lignes de resultats soit environ 60 000 lignes par lame. –> cela représente pour les 1000 gènes du projet genogim environ 2000 lames soit 120 millions de lignes pour cette table (voir le post sur les limites de postgresql).
les données doivent ensuite etre traité et entre autre il y a des ratio a effectué entre les différents signaux d’une meme lame. les ratio a effectué seront précisé dans mes_analysed_protocol. cette table est liée a 2 petite table mes_numerator et mes_denominator qui contiennent la litse des gene utilisé comme numérateur du ratio et comme dénominateur du ratio. il y a en plus une table mes_ratio_protocol decrivant les étape de l’analyse des signaux. enfin les valeurs de ratio sont stockées dans mes_analysed_data. cette table est liée a mes_analysed_protocol et contient 3 champs pour le moment, raw_ratio, centered_ratio et norm_ratio, pour les données brute, centrée et normalisée.

–> je remarque que cette table n’est pas directement liée aux spot ce qui est idiot car il y a une perte d’info. il faut ajouter en plus une liaison vers mes_spot_data
voila qui est fait.
j’ai généré les fichier sql pour créer et affacer la base et aussi faire les requètes.
ils sont dans /home/gim2/vpworkspace/
ce sont les fichier llp create.ddl , llp drop.ddl , llp insert.sql , llp select.sql , llp update.sql , llp delete.sql

• pour créer les tables :

create table bank_orf (orf_id serial not null, orf_name varchar(255), orf_gene varchar(255), primary key (orf_id));
create table prep_mutation (mut_id serial not null, mut_type varchar(255), primary key (mut_id));
create table prep_strain (pstr_id serial not null, orf_id serial not null, mut_id serial not null, use_id serial not null, primary key (pstr_id));
create table des_authors (auth_id serial not null, auth_first_name varchar(50), auth_last_name varchar(50), loc_id serial not null, primary key (auth_id));
create table des_locations (loc_id serial not null, loc_name varchar(255), loc_address1 varchar(255), loc_address2 varchar(255), loc_zip_code int4, loc_city varchar(255), primary key (loc_id));
create table array_chip_types (ct_id serial not null, ct_name varchar(255), primary key (ct_id));
create table des_experiment_types (et_id serial not null, et_name varchar(255), et_desc varchar(255), primary key (et_id));
create table des_biblio (biblio_id serial not null, biblio_text varchar(255), primary key (biblio_id));
create table des_experiments (exp_id serial not null, exp_common_ref bool, exp_quality text, et_id serial not null, ef_id serial not null, exp_description text, primary key (exp_id));
create table des_citation (cit_id serial not null, cit_text varchar(255), primary key (cit_id));
create table prep_organism (org_id serial not null, orf_name varchar(255), primary key (org_id));
create table prep_orf_usage (use_id serial not null, use_type varchar(10), primary key (use_id));
create table prep_biomaterial_manipulation (biomat_id serial not null, biomat_growth_cond varchar(30), biomat_treatment_type varchar(25), biomat_separation_technique varchar(25), primary key (biomat_id));
create table prep_extraction_preparation (expr_id serial not null, expr_extract_type varchar(15), expr_amplification varchar(15), extp_id serial not null, primary key (expr_id));
create table prep_labeling_protocol (labp_id serial not null, labp_amount varchar(15), labp_label_used varchar(15), labp_incorporation text, primary key (labp_id));
create table hyb_protocol (hybp_id serial not null, hybp_protocol text, primary key (hybp_id));
create table hyb_mating_date (mdate_id serial not null, mdate_date date, primary key (mdate_id));
create table hyd_slide (sl_id serial not null, sl_ref varchar(10), exp_id serial not null, sl_metadata varchar(255), hybp_id serial not null, sl_comment varchar(255), mdate_id serial not null, scan_id serial not null, sl_image_path varchar(255), sl_gpr_path int4, auth_id serial not null, sa_id serial not null, ct_id serial not null, primary key (sl_id));
create table hyb_strain (hstr_id serial not null, hstr_generation_nb float4, sl_id serial not null, fluo_id serial not null, pstr_id serial not null, primary key (hstr_id));
create table hyb_fluorophore (fluo_id serial not null, "fluo name" varchar(10), fluo_lambda int2, primary key (fluo_id));
create table hyb_scan_protocol (scan_id serial not null, scan_protocol text, primary key (scan_id));
create table array_spots (sp_id serial not null, sp_block int4, sp_col int4, sp_row int4, sp_name int4, spt_id serial not null, ct_id serial not null, orf_id serial, primary key (sp_id));
create table mes_spot_data (spd_id serial not null, spd_diameter int4, spd_flag varchar(10), spd_autoflag varchar(10), sl_id serial not null, sp_id serial not null, primary key (spd_id));
create table mes_raw_signal (rsg_id serial not null, rsg_foreground_median int4, rsg_foreground_mean int4, rsg_forground_sd int4, rsg_background int4, rsg_background_median int4, rsg_background_mean int4, rsg_background_sd int4, rsg_snr float4, spd_id serial not null, hstr_id serial not null, primary key (rsg_id));
create table mes_analysed_data (anad_id serial, spd_id serial not null, anad_raw_ratio float8, anad_centered_ratio float8, anad_norm_ratio float8, anap_id serial not null);
create table mes_analysed_protocol (anap_id serial not null, num_id serial not null, den_id serial not null, ratp_id serial not null, primary key (anap_id));
create table mes_numerator (num_id serial not null, str_id serial not null, primary key (num_id));
create table mes_denominator (den_id serial not null, str_id serial not null, primary key (den_id));
create table array_spot_type (spt_id serial not null, spt_type varchar(10), constraint spt_type primary key (spt_id));
create table prep_sample (sa_id serial not null, biomat_id serial not null, labp_id serial not null, expr_id serial not null, org_id serial not null, primary key (sa_id));
create table des_authors_exp (auth_id serial not null, exp_id serial not null, primary key (auth_id, exp_id));
create table des_experimental_factors (ef_id serial not null, ef_factor varchar(30), primary key (ef_id));
create table des_biblio_exp (biblio_id serial not null, exp_id serial not null, primary key (biblio_id, exp_id));
create table des_cit_exp (cit_id serial not null, exp_id serial not null, primary key (cit_id, exp_id));
create table prep_extraction_prot (extp_id serial not null, extp_text text, primary key (extp_id));
create table mes_ratio_protocol (ratp_id serial not null, ratp_text text, primary key (ratp_id));
alter table prep_strain add constraint FKprep_strai403802 foreign key (orf_id) references bank_orf;
alter table prep_strain add constraint FKprep_strai214282 foreign key (mut_id) references prep_mutation;
alter table des_authors add constraint FKdes_author231061 foreign key (loc_id) references des_locations;
alter table des_experiments add constraint FKdes_experi225877 foreign key (et_id) references des_experiment_types;
alter table prep_sample add constraint FKprep_sampl485169 foreign key (org_id) references prep_organism;
alter table prep_strain add constraint FKprep_strai136538 foreign key (use_id) references prep_orf_usage;
alter table prep_sample add constraint FKprep_sampl452472 foreign key (labp_id) references prep_labeling_protocol;
alter table mes_spot_data add constraint FKmes_spot_d918897 foreign key (sp_id) references array_spots;
alter table mes_raw_signal add constraint FKmes_raw_si626364 foreign key (spd_id) references mes_spot_data;
alter table mes_analysed_protocol add constraint FKmes_analys951623 foreign key (num_id) references mes_numerator;
alter table mes_analysed_protocol add constraint FKmes_analys786494 foreign key (den_id) references mes_denominator;
alter table mes_analysed_data add constraint FKmes_analys587731 foreign key (anap_id) references mes_analysed_protocol;
alter table hyd_slide add constraint FKhyd_slide72580 foreign key (mdate_id) references hyb_mating_date;
alter table hyd_slide add constraint FKhyd_slide483698 foreign key (hybp_id) references hyb_protocol;
alter table array_spots add constraint FKarray_spot230773 foreign key (spt_id) references array_spot_type;
alter table array_spots add constraint FKarray_spot154343 foreign key (orf_id) references bank_orf;
alter table prep_sample add constraint FKprep_sampl459810 foreign key (expr_id) references prep_extraction_preparation;
alter table des_authors_exp add constraint FKdes_author795609 foreign key (auth_id) references des_authors;
alter table des_experiments add constraint FKdes_experi36244 foreign key (ef_id) references des_experimental_factors;
alter table des_authors_exp add constraint FKdes_author917097 foreign key (exp_id) references des_experiments;
alter table hyd_slide add constraint FKhyd_slide920516 foreign key (ct_id) references array_chip_types;
alter table des_biblio_exp add constraint FKdes_biblio481512 foreign key (biblio_id) references des_biblio;
alter table des_biblio_exp add constraint FKdes_biblio538208 foreign key (exp_id) references des_experiments;
alter table des_cit_exp add constraint FKdes_cit_ex676417 foreign key (cit_id) references des_citation;
alter table des_cit_exp add constraint FKdes_cit_ex401799 foreign key (exp_id) references des_experiments;
alter table prep_sample add constraint FKprep_sampl686540 foreign key (biomat_id) references prep_biomaterial_manipulation;
alter table prep_extraction_preparation add constraint FKprep_extra865431 foreign key (extp_id) references prep_extraction_prot;
alter table hyd_slide add constraint FKhyd_slide628246 foreign key (exp_id) references des_experiments;
alter table hyd_slide add constraint FKhyd_slide329699 foreign key (sa_id) references prep_sample;
alter table hyb_strain add constraint FKhyb_strain18944 foreign key (pstr_id) references prep_strain;
alter table hyb_strain add constraint FKhyb_strain340557 foreign key (sl_id) references hyd_slide;
alter table hyb_strain add constraint FKhyb_strain6029 foreign key (fluo_id) references hyb_fluorophore;
alter table hyd_slide add constraint FKhyd_slide946515 foreign key (scan_id) references hyb_scan_protocol;
alter table array_spots add constraint FKarray_spot991272 foreign key (ct_id) references array_chip_types;
alter table mes_spot_data add constraint FKmes_spot_d379231 foreign key (sl_id) references hyd_slide;
alter table mes_raw_signal add constraint FKmes_raw_si231276 foreign key (hstr_id) references hyb_strain;
alter table mes_denominator add constraint FKmes_denomi703686 foreign key (str_id) references hyb_strain;
alter table mes_numerator add constraint FKmes_numera792103 foreign key (str_id) references hyb_strain;
alter table mes_analysed_protocol add constraint FKmes_analys48304 foreign key (ratp_id) references mes_ratio_protocol;
alter table hyd_slide add constraint FKhyd_slide369363 foreign key (auth_id) references des_authors;
alter table mes_analysed_data add constraint FKmes_analys921582 foreign key (spd_id) references mes_spot_data;


• pour effacer les tables


alter table prep_strain drop constraint FKprep_strai403802;
alter table prep_strain drop constraint FKprep_strai214282;
alter table des_authors drop constraint FKdes_author231061;
alter table des_experiments drop constraint FKdes_experi225877;
alter table prep_sample drop constraint FKprep_sampl485169;
alter table prep_strain drop constraint FKprep_strai136538;
alter table prep_sample drop constraint FKprep_sampl452472;
alter table mes_spot_data drop constraint FKmes_spot_d918897;
alter table mes_raw_signal drop constraint FKmes_raw_si626364;
alter table mes_analysed_protocol drop constraint FKmes_analys951623;
alter table mes_analysed_protocol drop constraint FKmes_analys786494;
alter table mes_analysed_data drop constraint FKmes_analys587731;
alter table hyd_slide drop constraint FKhyd_slide72580;
alter table hyd_slide drop constraint FKhyd_slide483698;
alter table array_spots drop constraint FKarray_spot230773;
alter table array_spots drop constraint FKarray_spot154343;
alter table prep_sample drop constraint FKprep_sampl459810;
alter table des_authors_exp drop constraint FKdes_author795609;
alter table des_experiments drop constraint FKdes_experi36244;
alter table des_authors_exp drop constraint FKdes_author917097;
alter table hyd_slide drop constraint FKhyd_slide920516;
alter table des_biblio_exp drop constraint FKdes_biblio481512;
alter table des_biblio_exp drop constraint FKdes_biblio538208;
alter table des_cit_exp drop constraint FKdes_cit_ex676417;
alter table des_cit_exp drop constraint FKdes_cit_ex401799;
alter table prep_sample drop constraint FKprep_sampl686540;
alter table prep_extraction_preparation drop constraint FKprep_extra865431;
alter table hyd_slide drop constraint FKhyd_slide628246;
alter table hyd_slide drop constraint FKhyd_slide329699;
alter table hyb_strain drop constraint FKhyb_strain18944;
alter table hyb_strain drop constraint FKhyb_strain340557;
alter table hyb_strain drop constraint FKhyb_strain6029;
alter table hyd_slide drop constraint FKhyd_slide946515;
alter table array_spots drop constraint FKarray_spot991272;
alter table mes_spot_data drop constraint FKmes_spot_d379231;
alter table mes_raw_signal drop constraint FKmes_raw_si231276;
alter table mes_denominator drop constraint FKmes_denomi703686;
alter table mes_numerator drop constraint FKmes_numera792103;
alter table mes_analysed_protocol drop constraint FKmes_analys48304;
alter table hyd_slide drop constraint FKhyd_slide369363;
alter table mes_analysed_data drop constraint FKmes_analys921582;
drop table bank_orf;
drop table prep_mutation;
drop table prep_strain;
drop table des_authors;
drop table des_locations;
drop table array_chip_types;
drop table des_experiment_types;
drop table des_biblio;
drop table des_experiments;
drop table des_citation;
drop table prep_organism;
drop table prep_orf_usage;
drop table prep_biomaterial_manipulation;
drop table prep_extraction_preparation;
drop table prep_labeling_protocol;
drop table hyb_protocol;
drop table hyb_mating_date;
drop table hyd_slide;
drop table hyb_strain;
drop table hyb_fluorophore;
drop table hyb_scan_protocol;
drop table array_spots;
drop table mes_spot_data;
drop table mes_raw_signal;
drop table mes_analysed_data;
drop table mes_analysed_protocol;
drop table mes_numerator;
drop table mes_denominator;
drop table array_spot_type;
drop table prep_sample;
drop table des_authors_exp;
drop table des_experimental_factors;
drop table des_biblio_exp;
drop table des_cit_exp;
drop table prep_extraction_prot;
drop table mes_ratio_protocol;


• pour inserer des donnée


insert into bank_orf(orf_id, orf_name, orf_gene) values (?, ?, ?);
insert into prep_mutation(mut_id, mut_type) values (?, ?);
insert into prep_strain(pstr_id, orf_id, mut_id, use_id) values (?, ?, ?, ?);
insert into des_authors(auth_id, auth_first_name, auth_last_name, loc_id) values (?, ?, ?, ?);
insert into des_locations(loc_id, loc_name, loc_address1, loc_address2, loc_zip_code, loc_city) values (?, ?, ?, ?, ?, ?);
insert into array_chip_types(ct_id, ct_name) values (?, ?);
insert into des_experiment_types(et_id, et_name, et_desc) values (?, ?, ?);
insert into des_biblio(biblio_id, biblio_text) values (?, ?);
insert into des_experiments(exp_id, exp_common_ref, exp_quality, et_id, ef_id, exp_description) values (?, ?, ?, ?, ?, ?);
insert into des_citation(cit_id, cit_text) values (?, ?);
insert into prep_organism(org_id, orf_name) values (?, ?);
insert into prep_orf_usage(use_id, use_type) values (?, ?);
insert into prep_biomaterial_manipulation(biomat_id, biomat_growth_cond, biomat_treatment_type, biomat_separation_technique) values (?, ?, ?, ?);
insert into prep_extraction_preparation(expr_id, expr_extract_type, expr_amplification, extp_id) values (?, ?, ?, ?);
insert into prep_labeling_protocol(labp_id, labp_amount, labp_label_used, labp_incorporation) values (?, ?, ?, ?);
insert into hyb_protocol(hybp_id, hybp_protocol) values (?, ?);
insert into hyb_mating_date(mdate_id, mdate_date) values (?, ?);
insert into hyd_slide(sl_id, sl_ref, exp_id, sl_metadata, hybp_id, sl_comment, mdate_id, scan_id, sl_image_path, sl_gpr_path, auth_id, sa_id, ct_id) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
insert into hyb_strain(hstr_id, hstr_generation_nb, sl_id, fluo_id, pstr_id) values (?, ?, ?, ?, ?);
insert into hyb_fluorophore(fluo_id, "fluo name", fluo_lambda) values (?, ?, ?);
insert into hyb_scan_protocol(scan_id, scan_protocol) values (?, ?);
insert into array_spots(sp_id, sp_block, sp_col, sp_row, sp_name, spt_id, ct_id, orf_id) values (?, ?, ?, ?, ?, ?, ?, ?);
insert into mes_spot_data(spd_id, spd_diameter, spd_flag, spd_autoflag, sl_id, sp_id) values (?, ?, ?, ?, ?, ?);
insert into mes_raw_signal(rsg_id, rsg_foreground_median, rsg_foreground_mean, rsg_forground_sd, rsg_background, rsg_background_median, rsg_background_mean, rsg_background_sd, rsg_snr, spd_id, hstr_id) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
insert into mes_analysed_data(anad_id, spd_id, anad_raw_ratio, anad_centered_ratio, anad_norm_ratio, anap_id) values (?, ?, ?, ?, ?, ?);
insert into mes_analysed_protocol(anap_id, num_id, den_id, ratp_id) values (?, ?, ?, ?);
insert into mes_numerator(num_id, str_id) values (?, ?);
insert into mes_denominator(den_id, str_id) values (?, ?);
insert into array_spot_type(spt_id, spt_type) values (?, ?);
insert into prep_sample(sa_id, biomat_id, labp_id, expr_id, org_id) values (?, ?, ?, ?, ?);
insert into des_authors_exp(auth_id, exp_id) values (?, ?);
insert into des_experimental_factors(ef_id, ef_factor) values (?, ?);
insert into des_biblio_exp(biblio_id, exp_id) values (?, ?);
insert into des_cit_exp(cit_id, exp_id) values (?, ?);
insert into prep_extraction_prot(extp_id, extp_text) values (?, ?);
insert into mes_ratio_protocol(ratp_id, ratp_text) values (?, ?);


• pour selectionner des données


select orf_id, orf_name, orf_gene from bank_orf;
select mut_id, mut_type from prep_mutation;
select pstr_id, orf_id, mut_id, use_id from prep_strain;
select auth_id, auth_first_name, auth_last_name, loc_id from des_authors;
select loc_id, loc_name, loc_address1, loc_address2, loc_zip_code, loc_city from des_locations;
select ct_id, ct_name from array_chip_types;
select et_id, et_name, et_desc from des_experiment_types;
select biblio_id, biblio_text from des_biblio;
select exp_id, exp_common_ref, exp_quality, et_id, ef_id, exp_description from des_experiments;
select cit_id, cit_text from des_citation;
select org_id, orf_name from prep_organism;
select use_id, use_type from prep_orf_usage;
select biomat_id, biomat_growth_cond, biomat_treatment_type, biomat_separation_technique from prep_biomaterial_manipulation;
select expr_id, expr_extract_type, expr_amplification, extp_id from prep_extraction_preparation;
select labp_id, labp_amount, labp_label_used, labp_incorporation from prep_labeling_protocol;
select hybp_id, hybp_protocol from hyb_protocol;
select mdate_id, mdate_date from hyb_mating_date;
select sl_id, sl_ref, exp_id, sl_metadata, hybp_id, sl_comment, mdate_id, scan_id, sl_image_path, sl_gpr_path, auth_id, sa_id, ct_id from hyd_slide;
select hstr_id, hstr_generation_nb, sl_id, fluo_id, pstr_id from hyb_strain;
select fluo_id, "fluo name", fluo_lambda from hyb_fluorophore;
select scan_id, scan_protocol from hyb_scan_protocol;
select sp_id, sp_block, sp_col, sp_row, sp_name, spt_id, ct_id, orf_id from array_spots;
select spd_id, spd_diameter, spd_flag, spd_autoflag, sl_id, sp_id from mes_spot_data;
select rsg_id, rsg_foreground_median, rsg_foreground_mean, rsg_forground_sd, rsg_background, rsg_background_median, rsg_background_mean, rsg_background_sd, rsg_snr, spd_id, hstr_id from mes_raw_signal;
select anad_id, spd_id, anad_raw_ratio, anad_centered_ratio, anad_norm_ratio, anap_id from mes_analysed_data;
select anap_id, num_id, den_id, ratp_id from mes_analysed_protocol;
select num_id, str_id from mes_numerator;
select den_id, str_id from mes_denominator;
select spt_id, spt_type from array_spot_type;
select sa_id, biomat_id, labp_id, expr_id, org_id from prep_sample;
select auth_id, exp_id from des_authors_exp;
select ef_id, ef_factor from des_experimental_factors;
select biblio_id, exp_id from des_biblio_exp;
select cit_id, exp_id from des_cit_exp;
select extp_id, extp_text from prep_extraction_prot;
select ratp_id, ratp_text from mes_ratio_protocol;


• pour modifier des données


update bank_orf set orf_name = ?, orf_gene = ? where orf_id = ?;
update prep_mutation set mut_type = ? where mut_id = ?;
update prep_strain set orf_id = ?, mut_id = ?, use_id = ? where pstr_id = ?;
update des_authors set auth_first_name = ?, auth_last_name = ?, loc_id = ? where auth_id = ?;
update des_locations set loc_name = ?, loc_address1 = ?, loc_address2 = ?, loc_zip_code = ?, loc_city = ? where loc_id = ?;
update array_chip_types set ct_name = ? where ct_id = ?;
update des_experiment_types set et_name = ?, et_desc = ? where et_id = ?;
update des_biblio set biblio_text = ? where biblio_id = ?;
update des_experiments set exp_common_ref = ?, exp_quality = ?, et_id = ?, ef_id = ?, exp_description = ? where exp_id = ?;
update des_citation set cit_text = ? where cit_id = ?;
update prep_organism set orf_name = ? where org_id = ?;
update prep_orf_usage set use_type = ? where use_id = ?;
update prep_biomaterial_manipulation set biomat_growth_cond = ?, biomat_treatment_type = ?, biomat_separation_technique = ? where biomat_id = ?;
update prep_extraction_preparation set expr_extract_type = ?, expr_amplification = ?, extp_id = ? where expr_id = ?;
update prep_labeling_protocol set labp_amount = ?, labp_label_used = ?, labp_incorporation = ? where labp_id = ?;
update hyb_protocol set hybp_protocol = ? where hybp_id = ?;
update hyb_mating_date set mdate_date = ? where mdate_id = ?;
update hyd_slide set sl_ref = ?, exp_id = ?, sl_metadata = ?, hybp_id = ?, sl_comment = ?, mdate_id = ?, scan_id = ?, sl_image_path = ?, sl_gpr_path = ?, auth_id = ?, sa_id = ?, ct_id = ? where sl_id = ?;
update hyb_strain set hstr_generation_nb = ?, sl_id = ?, fluo_id = ?, pstr_id = ? where hstr_id = ?;
update hyb_fluorophore set "fluo name" = ?, fluo_lambda = ? where fluo_id = ?;
update hyb_scan_protocol set scan_protocol = ? where scan_id = ?;
update array_spots set sp_block = ?, sp_col = ?, sp_row = ?, sp_name = ?, spt_id = ?, ct_id = ?, orf_id = ? where sp_id = ?;
update mes_spot_data set spd_diameter = ?, spd_flag = ?, spd_autoflag = ?, sl_id = ?, sp_id = ? where spd_id = ?;
update mes_raw_signal set rsg_foreground_median = ?, rsg_foreground_mean = ?, rsg_forground_sd = ?, rsg_background = ?, rsg_background_median = ?, rsg_background_mean = ?, rsg_background_sd = ?, rsg_snr = ?, spd_id = ?, hstr_id = ? where rsg_id = ?;
update mes_analysed_data set anad_id = ?, spd_id = ?, anad_raw_ratio = ?, anad_centered_ratio = ?, anad_norm_ratio = ?, anap_id = ? where ;
update mes_analysed_protocol set num_id = ?, den_id = ?, ratp_id = ? where anap_id = ?;
update mes_numerator set str_id = ? where num_id = ?;
update mes_denominator set str_id = ? where den_id = ?;
update array_spot_type set spt_type = ? where spt_id = ?;
update prep_sample set biomat_id = ?, labp_id = ?, expr_id = ?, org_id = ? where sa_id = ?;
update des_authors_exp set where auth_id = ? and exp_id = ?;
update des_experimental_factors set ef_factor = ? where ef_id = ?;
update des_biblio_exp set where biblio_id = ? and exp_id = ?;
update des_cit_exp set where cit_id = ? and exp_id = ?;
update prep_extraction_prot set extp_text = ? where extp_id = ?;
update mes_ratio_protocol set ratp_text = ? where ratp_id = ?;


• pour effacer des données


delete from bank_orf where orf_id = ?;
delete from prep_mutation where mut_id = ?;
delete from prep_strain where pstr_id = ?;
delete from des_authors where auth_id = ?;
delete from des_locations where loc_id = ?;
delete from array_chip_types where ct_id = ?;
delete from des_experiment_types where et_id = ?;
delete from des_biblio where biblio_id = ?;
delete from des_experiments where exp_id = ?;
delete from des_citation where cit_id = ?;
delete from prep_organism where org_id = ?;
delete from prep_orf_usage where use_id = ?;
delete from prep_biomaterial_manipulation where biomat_id = ?;
delete from prep_extraction_preparation where expr_id = ?;
delete from prep_labeling_protocol where labp_id = ?;
delete from hyb_protocol where hybp_id = ?;
delete from hyb_mating_date where mdate_id = ?;
delete from hyd_slide where sl_id = ?;
delete from hyb_strain where hstr_id = ?;
delete from hyb_fluorophore where fluo_id = ?;
delete from hyb_scan_protocol where scan_id = ?;
delete from array_spots where sp_id = ?;
delete from mes_spot_data where spd_id = ?;
delete from mes_raw_signal where rsg_id = ?;
delete from mes_analysed_data where ;
delete from mes_analysed_protocol where anap_id = ?;
delete from mes_numerator where num_id = ?;
delete from mes_denominator where den_id = ?;
delete from array_spot_type where spt_id = ?;
delete from prep_sample where sa_id = ?;
delete from des_authors_exp where auth_id = ?andexp_id = ?;
delete from des_experimental_factors where ef_id = ?;
delete from des_biblio_exp where biblio_id = ?andexp_id = ?;
delete from des_cit_exp where cit_id = ?andexp_id = ?;
delete from prep_extraction_prot where extp_id = ?;
delete from mes_ratio_protocol where ratp_id = ?;


29 février 2008 – Loreleï

17h44 :

J’ai finalement décider de monter rapidement une petite base de donnée très simplifiée pour pourvoir acceder aux info sur les enzymes de restriction.
J’ai donc créer la table lorelei (pour Liste Of Restriction Enzyme with Location and Enzyme Information). cette table se trouve dans la base bab_el_oueb que je devrais renommé babel_oueb d’ailleurs, étant une sorte de fourre-tout pour mes tables.
j’y ai mis aussi une autre base, congel_location.

code pour creer ces bases

DROP TABLE lorelei;
DROP TABLE congel_location;
CREATE TABLE congel_location
(
cl_id serial NOT NULL,
cl_loc varchar(255),
CONSTRAINT congel_location_pkey PRIMARY KEY (cl_id)
)
WITHOUT OIDS;
ALTER TABLE congel_location OWNER TO fricard;
CREATE TABLE lorelei
(
lor_id serial NOT NULL,
lor_name varchar(20),
lor_link varchar(255),
lor__site varchar(50),
cl_id int4,
CONSTRAINT lorelei_pkey PRIMARY KEY (lor_id),
CONSTRAINT lorelei_cl_id_fkey FOREIGN KEY (cl_id)
REFERENCES congel_location (cl_id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)
WITHOUT OIDS;
ALTER TABLE lorelei OWNER TO fricard;

lorelei fait référence a congel_location

on stocke dans la base le nom de l’enzyme et le lieu ou est est stockée ainsi qu’un lien vers une base de données donnant les infos sur cette enzyme.

J’ai ensuite créé une interface en php très simplfiée pour voir les donnée, en ajouter et les effacer.
http://berthemorisot.gim.pasteur.fr/lorelei.php

code php

<?php

function add_enz($vals, $db){
$query = "select cl_id from congel_location where cl_loc='".$vals[1]."'";
$res = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
if (pg_numrows($res)==0){
$query="insert into congel_location (cl_loc) values ('".$vals[1]."')";
echo $query;
$res = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
}
$query = "select cl_id from congel_location where cl_loc='".$vals[1]."'";

$res = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
$cl= pg_fetch_row($res, 0);

$cl_id=$cl[0];

$query="insert into lorelei (lor_name, lor_link, cl_id) values ('".$vals[0]."','".$vals[2]."',".$cl_id.")";
$res = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
echo $vals[0]." added<br/>";
}

?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Lorelei</title>
<style type="text/css">
body {
font-family: Arial,Helvetica,sans-serif;
font-size: 12px;
}
h1 {
font-size: 18px;
color: LightSeaGreen;
}
h2 {
font-size: 14px;
}
.initiale{
font-size: 16px;

color: LightSeaGreen;
}
a {
color:steelblue;
text-decoration:none;
}
a:hover{
color:white;
background-color:steelblue;

}
table {
font-size: 13px;
vertical-align:top;
}
td{
vertical-align:top;
}

td.head {
color:white;
background-color:steelblue;

}
td.add{
background-color:YellowGreen;

}
td.del{
background-color:IndianRed;
}
td.add_light{
background-color:#ccff99;
}
td.del_light{
background-color:#ff9999;
}
td.add_dark{
background-color:#003300;
color:white;
}
td.del_dark{
background-color:#330000;
color:white;
}
a.ancre{
color:DarkSlateBlue;
}
a.ancre:hover{
background-color:DarkSlateBlue;
color:white;
}
</style>
</head>
<body>
<table><tr><td rowspan=2>
<img src="lorelei_01.jpg" width=50 height=50 />
</td><td><h1>LORELEÏ</h1></td></tr>
<tr><td>
<h2><span class="initiale">L</span>iste <span class="initiale">O</span>f <span class="initiale">R</span>estriction <span class="initiale">E</span>nzyme with <span class="initiale">L</span>ocation and <span class="initiale">E</span>nzyme <span class="initiale">I</span>nformation</h2>
</td></tr>
</table>
<br/>
<a class="ancre" href="#update">Ajouter ou retirer des enzymes</a>

<balise id="top"></balise>
<br/>
<br/>
<?php
$HOST="berthemorisot.gim.pasteur.fr";
$PORT=5432;
$BASE="bab_el_oueb";
$USER="fricard";
$db = pg_connect("host=$HOST port=$PORT dbname=$BASE user=$USER") or die("impossible de se connecter à la base de données");
if (isset($_POST["add_data"])){
if ($_FILES["file_data"]['name']){
$fichier=$_FILES['file_data']['tmp_name'];
if (file_exists($fichier)) {
$fp2=fopen($fichier, "r");
while(!feof($fp2)){
$line[]=fgets($fp2, 4096);
}
fclose($fp2);
}
}
elseif($_POST["text_data"]){
$line=explode("\n",$_POST["text_data"]);
}
if (count($line)>0){
$sep_list=array("\t",",");
foreach($sep_list as $sep){
if (strpos($line[0],$sep)){
break;
}
}
foreach ($line as $items){
$vals=explode($sep, $items);
add_enz($vals, $db);
}
}
}
if (isset($_POST["del_data"])){
$data_array = $_POST['item_list'];
$in = implode( $data_array, ',');
$query="select lor_name from lorelei where lor_id in ($in)";
$res = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
$query="delete from lorelei where lor_id in ($in)";
$res2 = pg_query($db, $query) or die("La requète $query n'a pas pu aboutir");
for ($i=0;$i<pg_numrows($res);$i++){
$ligne= pg_fetch_row($res, $i);
$enz[]=$ligne[0];
}
if ($i>1){
echo implode( $enz, ', ')." ont été effacées";
}else{
echo implode( $enz, ', ')." a été effacée";
}

}

$query_all = "select lor_id, lor_name, cl_loc, lor_link from lorelei, congel_location where lorelei.cl_id = congel_location.cl_id order by lor_name";
?>
<table>
<tr>
<td> </td><td class="head">Enzyme </td><td class="head">Localisation </td><td class="head">Lien </td></tr>
<?php
$res = pg_query($db, $query_all) or die("La requète n'a pas pu aboutir");
for ($i=0;$i<pg_numrows($res);$i++){
$ligne= pg_fetch_row($res, $i);
echo "<tr>";
foreach($ligne as $val){
if ((strpos($val,"html")) || (strpos($val,"http")) || (strpos($val,"www")) || (strpos($val,"php"))){
echo '<td><a href="'.$val.'">'.$val.'</a></td>';
}
else{
echo "<td>$val</td>";
}
}
echo "</tr>\n";

}
echo "</table>";

?>
<br/>
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<br/>
<a class="ancre" href="#top">Retourner au début de la page</a>
<balise id="update"> </balise>
<br/>
<table>
<tr>
<td class="add_dark">
Pour ajouter des enzymes à la liste
</td>
<td class="del_dark">
Pour effacer des enzymes de la liste
</td>
</tr>
<tr>
<td class="add">
<form name="add_item" method="POST" action="lorelei.php" ENCTYPE="multipart/form-data">
Copier-coller la liste des enzymes ci-dessous selon le format suivant :<br/>
nom localisation lien</br>
en séparant les colonnes par des tabulations ou des virgules<br/> (un copier-coller depuis excel par exemple)
</td>
<td class="del">
sélectionnez la ou les enzymes a effacer<br/>
</td>
</tr>
<tr>
<td class="add_light">
<form name="add_item" method="POST" action="lorelei.php" ENCTYPE="multipart/form-data">

<textarea name="text_data" cols="70" rows="10" wrap="physical" ></textarea>
<br/>
ou uploader un fichier au format décrit ci-dessus<br/>
<input type="file" name="file_data" />
<br/>
<input type="submit" name="add_data" value="Ajouter" />
</form>
</td>
<td class="del_light">
<form name="del_item" method="POST" action="lorelei.php" ENCTYPE="multipart/form-data">
<select name="item_list[]" multiple size=5>
<?php
for ($i=0;$i<pg_numrows($res);$i++){
$ligne= pg_fetch_row($res, $i);
$id=$ligne[0];
$nom=$ligne[1];
echo '<option value="'.$id.'">'.$nom.'</option>';
}
?>
</select>
<br/>
<input type="submit" name="del_data" value="Retirer" />
</form>
</td>
</tr>
</table>
</body>
</head>


25 février 2008 – Explication des manip et redéfinition des tables de la base pour SganArrayl (suite)

10h55 : Suite a certain éclaircissement sur le déroulement des manip, j’ai constaté avoir fait qq erreurs dans la conceptions de la base. outre le fait d’”avoir oublié les info pour conserver les info minimal sur les puces, j’ai mal compris la notion de manip, notamment quand 3 couleurs sont utilisées sur une lame.
le déroulement de la manip est le suivant

1. construction de souches appat (bait)

6 nouvelles souches (A, B, C, D E, F) par ex : delta-EDC3, delta-pex22, …

2. Obtention des doubles mutants

6 cultures de cellules dans les lesquelles on va obtenir 4700 doubles mutants en 18 générations
on réalise aussi 2 cultures de références (R1 et R2) YFR-Delta et YEL-Delta à partir desquelles on va obtenir aussi 4700 doubles mutants.
tous ces double mutants sont obtenus le meme jour et seront identifié par la date –> mating date

3. Marquage de l’ADN avec les fluorophores

on marque une souche avec l’un des marqueurs fluo, par ex Cy3, une autre avec un autre marqueur, Cy5, et une référence marquée par alexa594. ces 3 souches marquées sont alors hybridées sur une lame.
on réalise ainsi 6 lames en croisant les souches et les références de façon que chaque souche soit présente sur 2 lames différentes et que la référence pour ces 2 lames soit à chaque fois différente. De plus il est également interessant de marquer la meme souche avec 2 marqueurs différent pour chacune des hybridations.
avec les souche A, B, C, D, E, F, et les références R1 et R2, on peut alors effectuer le croisement suivant :
lame 1 –> A-Cy3, B-Cy5, R1-Alexa594
lame 2 –> C-Cy3, A-Cy5, R2-Alexa594
lame 3 –> B-Cy3, D-Cy5, R2-Alexa594
lame 4 –> E-Cy3, C-Cy5, R1-Alexa594
lame 5 –> D-Cy3, F-Cy5, R1-Alexa594
lame 6 –> F-Cy3, E-Cy5, R2-Alexa594

4. obtention des rapports bait/control

on va alors calculer tous les rapport A/R1, A/R2, B/R1…F/R2
centrer les données, filtrer (SNR, diametre), eliminer les pics, puis combiner les résultats. pour chaque gène 4 spots existe sur la puce. on va garder la moyenne ou la médiane. ca reste a déterminer.

5. comparaison avec autre date

ces manip seront répétées un mois plus tard. les résultats seront comparés entre eux

il faut donc repenser la base en fonction de ces nouvelles infos. le terme de manip (ou experiment) va regrouper non pas une lame mais les couples appat/référence, la référence pourvant etre différente a chaque fois. une manip est donc principalement identifiée par son appat.
–> Rq : dans le cas de lame 2 couleurs, un couple appat/ref correspond bien a une lame
la hierarchie logique est donc la suivante:
bait --> mating date --> hybridization avec en général pour un appat 2 cultures a des dates différentes et pour chacune de ces cultures 2 hybridations

20h14 : j’ao fini une première version complete de la base.
elle comprend 5 parties correspondant aux 5 éléments décrit par le format MIAME. une partie sur le array design pour contenir les info de construction des puce et 4 partie sur la manip. je vois déja une erreur de conception dans cette base. les info de manip sont descendante, c’est a dire que ca va depuis la conception de la manip a l’analyse des résultats. les liens entre ces parties devraient donc etre descendant aussi. or j’ai des lien ascendant entre la partie sample preparation et experiment design. j’ai surement besoin d’une entité entre les 2.
de plus la table des orf a besoin d’etre sortie de ce contexte car elle est indépendante des puces.

20 février 2008 – installation du module pg pour python2.5 sur berthemorisot

14h59: comme rien n’est jamais simple, il est impossible d’utiliser python2.5 par défaut sur berthemorisot a cause de CENTOS qui nécessite python2.3 pour fonctionner (on croit réver).
mais comme python2.5 est en génral plus rapide que le 2.3 et gère mieux certaines chose, c qd meme pas mal de l’utilser si possible.
il est installé dans ~/tools/python-2.5.0/ et on l’appelle par la commande ~>python2.5
je veux utiliser PyGreSQL dans python2.5. il me faut donc l’installer car il n’est pas par défaut. et bien sur pas possible de passer par les rpm ou yum.
donc deja il faut aller chercher le fichier sur http://www.pygresql.org/ et télécharger ftp://ftp.pygresql.org/pub/distrib/PyGreSQL.tgz
moi j’ai copié l’archive dans ~/tools/python-2.5.0/lib/python2.5/site-package/ mais je ne suis pas sur que ce soit totalement nécésssaire.
là j’ai dezipé l’archive
~>gunzip PyGreSQL.tgz
et dearchivé
~>tar -vxf PyGreSQL.tar
j’ai alors un répertoire PyGreSQL-3.8.1 ou je me rend
je suis les instruction d’installation et je lance la commande ~>python2.5 setyp.py build et la bien sur j’ai une erreur

sh: pg_config: command not found
Traceback (most recent call last):
File "setup.py", line 81, in
pg_include_dir = pg_config('includedir')
File "setup.py", line 51, in pg_config
raise Exception, "pg_config tool is not available."
Exception: pg_config tool is not available.

en fait le programme appelle pg_config (fourni avec la base pgresql) sauf que ce programme n’est pas accessible ainsi. il faut donner son chemin complet /usr/local/pgsql/bin/pg_config et la ca marche
il y a qq erreur mais ca a l’air de marcher qd meme
puis on fait ~>python2.5 setup.py install
encore qq erreur mais ca semble marcher qd meme
et puis je lance python2.5 et je tape import pg
et là miracle, ca marche
donc c cool, ca a fonctionner sans trop de galère. mais j’ai peur qd meme de voir apparaitre qq erreur a l’utilisation, enfin on verra

20 février 2008 – script pour introduire des données dans la base (suite)

9h57 : suite du test sur l’utilisation du module cgi de python
je rajoute
print dir(form)

je récupère
['FieldStorageClass', '_FieldStorage__write', '__contains__', '__doc__', '__getattr__', '__getitem__', '__init__', '__iter__', '__len__', '__module__', '__repr__', 'bufsize', 'disposition', 'disposition_options', 'done', 'file', 'filename', 'fp', 'getfirst', 'getlist', 'getvalue', 'has_key', 'headers', 'innerboundary', 'keep_blank_values', 'keys', 'length', 'list', 'make_file', 'name', 'outerboundary', 'read_binary', 'read_lines', 'read_lines_to_eof', 'read_lines_to_outerboundary', 'read_multi', 'read_single', 'read_urlencoded', 'skip_lines', 'strict_parsing', 'type', 'type_options']

les methodes sont

__contains__
__getattr__
__getitem__
__init__
__iter__
__len__
__repr__
getfirst
getlist
getvalue
has_key
keys
make_file
read_binary
read_lines
read_lines_to_eof
read_lines_to_outerboundary
read_multi
read_single
read_urlencoded
skip_lines

l’objet se comporte un peu comme un dictionnaire, les méthodes has_key et keys permettent d’accéder aux noms des variables passées dans l’adresse
f.keys() renvoie la liste ['toto','tati']

maintenant il faut voir si ca marche avec une requete ajax
mon fichier avec la requete ajax
http://berthemorisot.gim.pasteur.fr/test_ajax.php
et son contenu
la partie javascript

function req_object(method,query, sync){
//fonction renvoyant un objet XMLHttpRequest qui effectue la requete. l'objet est renvoyé juste après avoir effectuer la requete
var xhr_object = null;
if(window.XMLHttpRequest)//Firefox
xhr_object = new XMLHttpRequest();
else if(window.ActiveXObject) // Internet Explorer
xhr_object = new ActiveXObject("Microsoft.XMLHTTP");
else { // XMLHttpRequest non supporté par le navigateur
alert("Your web browser does not support XMLHTTPRequest objects...");
return;
}
xhr_object.open(method,query, sync);
xhr_object.send(null);
return xhr_object;
}
function request(){
//fonction requete qui envoie des données à test_get.py en utilisant la methode get et
//de façon synchrone (sync=false)
query="cgi-bin/sganarrayl/test_get.py?toto=tata&tati=tonton";
method="get";
sync=false;
var xhr_object=req_object(method,query, sync);
if(xhr_object.readyState == 4) {
//quand la requete est effectuée, affiche le résultat renvoyé par test_get.py dans
//une boite de dialogue
var reponseXML =xhr_object.responseText;
alert(reponseXML);
}
}

et la partie html



1
2



ca marche bien et je reçois correctement la réponse du script python.

12h35 : je vais tester la rapidité de python par rapport au php pour l’accès aux bases de données
j’ai écrit 2 script effectuant les meme actions
le premier en python

#! /usr/bin/python

import cgi
import pg
print "Content-type: text/html"
print

DBNAME = 'sophia'
HOST = 'berthemorisot.gim.pasteur.fr'
USER = 'fricard'
con = pg.connect(dbname=DBNAME, host=HOST, user=USER)
query_all = "select * from features"
all = con.query(query_all)
res=all.getresult()
for val in res[0]:
print val

et le second en php

header("Content-type: text/html");

$HOST="berthemorisot.gim.pasteur.fr";
$PORT=5432;
$BASE="sophia";
$USER="fricard";
$db = pg_connect("host=$HOST port=$PORT dbname=$BASE user=$USER") or die("impossible de se connecter à la base de données");
$query_all = "select * from features";

$res = pg_query($db, $query_all) or die("La requète n'a pas pu aboutir");
$ligne= pg_fetch_row($res, 0);
foreach($ligne as $val){
echo $val.'\n';
}

le code python met en moyenne 222 ms pour faire la requete (sur 11 essais) et le code php met 120 ms en moyenne (sur 11 essais). la requete part du meme script ajax, donc tout est bien equivalent. le code python est presque 2 fois plus lent.
je vais le tenter sur une requete plus longue, car il peut s’agir juste d’un problème d’initialisation.
en modifiant le script pour renvoyer l’ensemble des résultats de la table feature (13316 lignes), le temps d’execution du script python passe a 1518 ms en moyenne (sur 10 essais) et le script php 1481 ms en moyenne(12 essais).
la différence venait donc de l’initialisation de python je pense ou quelque chose comme ca. et encore, je suis obligé d’utiliser python2.3 car le module pg n’est pas installé sur python2.5. je vais essayer de l’installer sur python2.5 pour etre plus tranquille. installation ici
15:25 : je test le meme script avec python2.5 et je n’ai aucune différence, c le meme temps d’execution. mais bon, je préfère quand meme pouvoir me servir de python2.5

Au final je vais donc me servir de python puisque c’est a peine plus lent sur les grosse requetes. il serait qd meme interressant de voir s’il est possible de parser le fichier gpr en php de façon assez simple. cela dit le python est plus simple d’utilisation. a voir donc. dans un premier temps python et puis ensuite peut-etre php.

18h38 : la partie essentielle de sganarrayl est de traiter le fichier envoyé par l’utilisateur. il faut donc etre capable d’envoyer et de recevoir un fichier.
pour l’envoie, les formulaires font ca très bien en utilisant cette ligne de commande
form id="ajax_form" name="ajax_form" action="cgi-bin/sganarrayl/test_get.py" method="post" ENCTYPE="multipart/form-data"

il faut donc utiliser la méthode post, j’ai essayé avec get et ca ne marche pas, ce qui finalement est assez normal car le fichier ne peut pas passer dans l’adresse. ne pas oublier non plus l’encodage avec multipart/form-data
il faut aussi ajouter une balise input de type file mais ca c trivial
input type="file" id="fichier" name="fichier"

du coté du cgi, pour traiter ca c assez simple
on créé une première instance de FieldStorage et on récupère ainsi toutes les variable post. quand un fichier est envoyé, il est stocké sous la forme d’un objet FieldStorage (a nouveau) accessible par la clé qui est le nom de la balise input du formulaire. ok c pas clair mais par contre c tres simple a écrire

import cgi #on importe la classe cgi bien sur
post_data=cgi.FieldStorage() #on récupère les données passée en post
f=post_data['fichier'] #on récupère la variable associée a la clé "fichier"
#comme c un fichier l'objet récupéré est un FieldStorage, avec un attribut file qui est un filehandle
for line in f.file: #on parcours alors ce filehandle
print "%s" % line #et on inprime chaque ligne

facile, non ?
ca marche bien, meme avec un gros fichier du type gpr (fichier de resultat de microarray) et c rapide.
par contre, il n’y a pas le choix, il faut pour envoyer le fichier, passer par le formulaire et un bouton submit. c pas possible de traiter ca juste avec AJAX.
c’est très bien expliqué ici