Débuter avec l'API Ensembl (Perl)

But : Décou­vrir com­ment on peut accé­der très sim­ple­ment aux infor­ma­tions d'Ensembl à l'aide d'un script Perl.

Niveau : débu­tant.

Pré-requis : Avoir des notions de Perl allant jusqu'à l'utilisation de librai­ries. Avoir accès à une machine où les librai­ries Perl d'Ensembl sont ins­tal­lées.

Par­mi les sites agré­geant de l'information bio­lo­gique, Ensem­bl four­nit une API (Appli­ca­tion Pro­gram­ming Inter­face) Perl qui per­met de déve­lop­per des pro­grammes (en Perl donc) pour accé­der à cette infor­ma­tion.

L'API Ensem­bl est très com­plète et on ne s'intéressera ici qu'aux classes et méthodes de plus haut niveau. Il est pos­sible d'utiliser des fonc­tions plus proches des bases de don­nées, mais c'est en géné­ral une erreur. Sans entrer dans les consi­dé­ra­tions habi­tuelles jus­ti­fiant la créa­tion d'une API, on note­ra quand même que l'accès aux don­nées est très facile car il y a beau­coup de points d'entrée et que l'orientation objet sim­pli­fie gran­de­ment les écri­tures.

Pour illus­trer cette note, nous allons nous inté­res­ser à un trans­crit (ENST00000368759) du gène BCCIP qui code pour une pro­téine inter­agis­sant avec BRCA2 et CDKN1A. Notre but sera de retrou­ver la posi­tion de tous les exons du trans­crit à par­tir de son nom dans Ensem­bl, le stable_​id.

La docu­men­ta­tion est très pra­tique et donne déjà quelques indices sur l'organisation. Vous arri­vez alors à la racine de la docu­men­ta­tion (géné­rée auto­ma­ti­que­ment par Doxy­gen). Il y a quatre sec­tions de base (mar­quées API) : core, varia­tion, com­pa­ra et funct­ge­no­mics. Core contient tous les objets de base, à savoir les chro­mo­somes, gènes, trans­crits, exons, "slice" (lit­té­ra­le­ment, une tranche de génome), etc. Les autres sec­tions sont plus expli­cites. Cli­quez sur le lien "Ensem­bl core data­base API", puis sur "Class Index". Obser­vez tout ce qui est dis­po­nible à par­tir de "core".

Venons-en main­te­nant au cœur du pro­blème. Comme dit pré­cé­dem­ment, toute l'information conte­nue dans Ensem­bl est acces­sible par des objets. Mais avant d'accéder aux objets, il y a 3 étapes à fran­chir.

  1. Il faut créer un objet de type "Bio::EnsEMBL::Registry".
    Ex :
    my $reg = "Bio::EnsEMBL::Registry";  #wow
    
  2. Récu­pé­rer le registre depuis la base de don­nées.
    Ex :
    $reg->load_registry_from_db(
    -host => 'ensembldb.ensembl.org',
    -user => 'anonymous');
  3. Récu­pé­rer un adap­ta­teur cor­res­pon­dant à l'objet qui nous inté­resse, ici, un trans­crit.
    Ex :
    my $ta = $reg->get_adaptor( "human", "core", "transcript" );
    

Il convient de sou­li­gner plu­sieurs points.

À l'étape 2, une connexion est éta­blie avec la base de don­née. D'ailleurs, l'option -ver­bose => 1 per­met­trait de voir toutes les espèces dis­po­nibles. Ce n'est évi­dem­ment pas la seule manière de char­ger le registre. À titre d'exercice, je sug­gère de cher­cher la hié­rar­chie des classes de "core" (il faut cli­quer jusqu'à voir un graphe, bonne chance),  puis cli­quer sur "regis­try" pour voir les dif­fé­rentes méthodes.

À l'étape 3, nous voyons ici la méthode la plus impor­tante et la notion qui en découle : l'adaptateur. Pour chaque objet, il existe un adap­ta­teur. L'adaptateur est lui-même un objet, que l'on pour­rait qua­li­fier d'intermédiaire, et qui contient, entre autres, toutes les méthodes capables de retour­ner un objet du type de l'adaptateur.

À titre d'exercice : une fois dans la docu­men­ta­tion de core, uti­li­ser la "class index" pour trou­ver l'objet transcript_​adaptor (facile). Quelle est la dif­fé­rence entre fetch_​all_​* et fetch_​* ?

À ce stade, nous sommes prêts à creu­ser. En Perl, c'est bien connu : "there is more than one way to do it". Nous allons com­men­cer par le plus gros objet et des­cendre vers le plus petit, c'est-à-dire par­tir du trans­crit et des­cendre vers les exons. En consul­tant la docu­men­ta­tion de l'objet Trans­crip­tA­dap­tor, on trouve une méthode nom­mée fetch_​by_​stable_​id qui prend en argu­ment une variable String et va nous retour­ner un objet Bio::EnsEMBL::Transcript :

my $tr = $ta->fetch_by_stable_id('ENST00000368759');
Ensuite l'objet Bio::EnsEMBL::Transcript contient une méthode get_all_Exons qui va nous retourner une référence sur une liste d'objets de type Bio::EnsEMBL::Exon :
my @exons = @{ $tr->get_all_Exons() };
On peut faire afficher par exemple le nom (stable_id), le start et le end :
foreach my $ex (@exons){
print $ex->stable_id."\t".$ex->start."\t".$ex->end."\n";
}
Au final, le script complet (remplacer $PATH_perl par le chemin qui va bien) :
#!/usr/bin/perl
use lib "$PATH_perl/ensembl64/ensembl/modules";
use lib "$PATH_perl/bioperl-live";
use lib "$PATH_perl/ensembl64/ensembl-variation/modules";
use Bio::EnsEMBL::Registry;
use Data::Printer;

my $reg = "Bio::EnsEMBL::Registry";

load_registry_from_db(
-host => 'ensembldb.ensembl.org',
-user => 'anonymous',
# -verbose => 1
);

my $ta = $reg->get_adaptor( "human", "core", "transcript" );
#p($ta);
my $tr = $ta->fetch_by_stable_id('ENST00000368759');
#p($tr);
my @exons = @{ $tr->get_all_Exons() };
foreach my $ex (@exons){
# p($ex);
print $ex->stable_id."\t".$ex->seq_region_name."\t".ex->start."\t".$ex->end."\n";
}

On pourrait s'arrêter là mais nous allons voir comment adopter une démarche (presque) inverse. Nous allons partir d'un ExonAdaptor et récupérer les exons correspondant au transcript. Pour cela, on voit qu'il existe une méthode fetch_all_by_Transcript qui prend en argument un objet de type Bio::EnsEMBL::Transcript et retourne à nouveau une référence sur une liste de Bio::EnsEMBL::Exon.

On vient de voir comment chercher l'objet correspondant au transcrit, il ne nous reste donc plus qu'à écrire :

print "\n";

my $ea = $reg->get_adaptor("human", "core", "exon");
my $ta2 = $reg->get_adaptor( "human", "core", "transcript" );
my $tr2 = $ta2->fetch_by_stable_id('ENST00000368759');
my @exons2 = @{ $ea->fetch_all_by_Transcript($tr2)};

foreach my $ex (@exons2){
# p($ex);
print $ex->stable_id."\t".$ex->seq_region_name."\t".$ex->start."\t".$ex->end."\n";
}
Résultat :

Copie d'écran de la sortie du script
Copie d'écran de la sortie du script

Voilà qui conclue cette note sur comment débuter avec l'API Perl d'Ensembl. J'espère qu'avec ce tout petit exemple, vous aurez envie d'aller plus avant et de découvrir les monts et merveilles cachés dans la documentation.

Pour aller plus loin

À noter, des sessions de formations sont régulièrement proposées et conduites par des membres de l'équipe de développement. Pour un planning on pourra consulter ce calendrier et également le blog d'Ensembl. J'ai pu assister à une formation (gratuite) de 3 jours à Cambridge (UK) qui donnait les points clefs de Core, Variation, Compara et FunctGenomics (par ordre d'importance dans la formation). Pour des groupes plus larges, il peut être intéressant d'organiser une formation ad hoc à domicile (payant).

Sans attendre une formation ou une prochaine (et incertaine) note, pour ceux qui veulent aller plus loin, vous pouvez consulter les pages ci-dessous faites par les sus-mentionnés membres de l'équipe de formation et de développement :
Vers une formation Core
Vers les formations Compara
Une présentation de Variation
Vers les formation FunctGenomics

Merci de votre attention, ainsi qu'à mes gentils correcteurs Malicia, Norore, Max et Yoann M.



Pour continuer la lecture :


Commentaires

Laisser un commentaire