Configurer des séquences biologiques pour les aligner
Article mis en ligne le 3 juillet 2021
dernière modification le 5 juillet 2021

par Laurent Bloch

Pour programmer un algorithme génial qui méritera le prix Turing, il faudra souvent avoir au préalable acquis les données, généralement depuis un ou plusieurs fichiers, et les avoir mises sous la forme appropriée. C’est un travail peu glorieux, mais ce n’est pas forcément très facile, cela prend du temps et des lignes de code, et oblige à se faire des idées sur le système d’exploitation. C’est l’objet du présent article.

 Codage, caractères, glyphes

Cet article vient à la suite de Premiers programmes en Rust, de Programmation Rust, suite et de Codage de séquences biologiques avec Rust. Je ne suis pas encore arrivé au cœur du sujet, mais au seuil : les programmes de cet épisode peuvent lire un fichier au format FASTA qui contient une (unique) séquence, vérifier que la première ligne est bien conforme au format, l’extraire pour éventuellement documenter la séquence, ensuite retirer du texte proprement dit de la séquence les caractères de saut de ligne (LF, Line Feed) afin d’obtenir une séquence propre, prête à subir les exactions de Messieurs Needleman et Wunsch, ou, si l’on préfère, de Messieurs Smith et Waterman, ce que je prévois de faire dans un prochain épisode.

Pour suivre les conseils de lecteurs compétents, j’ai renoncé au type chaîne de caractères : en effet les caractères de Rust obéissent à la norme UTF-8, qui leur permet d’occuper jusqu’à quatre octets, ce qui est encombrant, mais surtout cette occupation est de taille variable, un caractère peut occuper un, deux, trois ou quatre octets, selon sa signification [1]. Pour éviter ces caractères de taille variable, j’ai décidé d’utiliser pour coder les nucléotides le type unsigned 8, qui correspond à un octet. Je sais qu’il est possible d’utiliser des codages encore plus condensés, mais après tout les algorithmes envisagés valent aussi pour les acides aminés, alors vivent les octets.

Martin Larralde m’a conseillé « de créer un wrapper de Vec, et d’implémenter [moi-même] les traits Display et Debug, de manière à pouvoir visualiser la séquence sous forme de texte (ce qui se fait de façon triviale avec std::str::from_utf8_unchecked , si on respecte l’invariant que le Vec ne contient que des caractères alphanumériques). » Bon, j’ai bien utilisé std::str::from_utf8_unchecked, mais le wrapper attendra que je me sois un peu perfectionné en Rust.

 Typage et dépendances

La grande originalité de Rust, et sa qualité exclusive, est son modèle de mémoire, qui garantit à la compilation l’absence de débordement de buffer ou de toute autre zone de mémoire, et aussi le fait qu’un seul sous-programme puisse, à un instant donné, modifier la valeur d’une variable : toute valeur appartient à une variable et une seule, qui est limitée à une portée donnée par la syntaxe. Si un sous-programme passe une de ses variables à un autre sous-programme, ce dernier en devient le propriétaire, et le premier ne peut plus modifier sa valeur.

Ces caractéristiques font la sûreté du langage, mais elles ont un prix. Pour la cinématique des données, il faut y réfléchir à deux fois avant de passer une variable en argument à un autre sous-programme, parce qu’après on ne pourra plus y toucher ; on peut souvent s’en tirer avec des références, comme en Ada. C prétend avoir un typage fort : cette assertion est spécieuse, parce que si le typage est fort, il peut facilement être contourné pour provoquer les failles de sécurité qui font la joie des pirates. Rust ne plaisante pas avec le typage, on n’y coupe pas. Certaines méthodes de Vec<u8> (données sur le tas) renvoient des tranches (slices) de type array [u8] (données sur la pile), il faut leur appliquer la méthode to_vec() (conversion d’array en Vec) pour les utiliser, ainsi :

  1. ident = (fasta_sequence.split_at(index).0).to_vec();
  2. sequence_nuc = (fasta_sequence.split_at(index).1).to_vec();

Télécharger

La méthode fasta_sequence.split_at(index) renvoie un tuple (type d’objet commode et indulgent que Rust fournit au programmeur pour le consoler de ses souffrances) de deux éléments de type array [u8] dont le premier élément contient les premiers éléments du vecteur fasta_sequence jusqu’à l’indice index (non compris), et le second les éléments depuis index (compris) jusqu’à fasta_sequence.len() (la longueur totale du vecteur), non compris. Finalement c’est bien conçu, mais ces deux lignes m’ont fait transpirer avant que j’aie compris comment cela marchait.

On remarque que fasta_sequence.split_at(index).0 désigne le premier élement du tuple, et fasta_sequence.split_at(index).1 le second.

Incidemment, cette notation des méthodes, empruntée à la programmation par objets, est bien commode, mais Rust n’est pas un langage à objets, avec toutes ces histoires d’héritage multiple et de surcharge d’opérations qui ont finalement introduit plus de confusion qu’autre chose.

 Le programme

Voici le corps du module fasta_files_mgt. Reste à écrire le module sequences_matrix, qui soumettra nos deux séquences à l’algorithme de Messieurs Needleman et Wunsch, ou à celui, cousin, de Messieurs Smith et Waterman. Les autres fichiers, inchangés, sont ceux de l’article Codage de séquences biologiques avec Rust, où l’on trouvera aussi des séquences au format FASTA pour essayer.

Les pages Web dont je me suis inspiré :

Lire un fichier d’octets

Lire et décrire un fichier

  1. // src/fasta_files_mgt/fasta_open_read.rs :
  2.  
  3. pub mod fasta_open_read {
  4.  
  5.     use std::env;
  6.     use std::fs;
  7.     use std::fs::File;
  8.     use std::io::Read;
  9.     use std::fs::Metadata;
  10.     use std::str;
  11.  
  12.     use crate::sequences_matrix::build_sequences_matrix::build_sequences_matrix;
  13.    
  14.     pub struct Config {
  15.         pub filename1: String,
  16.         pub filename2: String,
  17.     }
  18.    
  19.     impl Config {
  20.         pub fn new(args: &[String]) -> Config {
  21.             if args.len() < 3 {
  22.                 panic!("pas assez d'arguments");
  23.             }
  24.             let filename1 = args[1].clone();
  25.             let filename2 = args[2].clone();
  26.            
  27.             Config { filename1, filename2 }
  28.         }
  29.     }
  30.  
  31.     pub fn get_filenames() {
  32.         let args: Vec<String> = env::args().collect();
  33.         let config = Config::new(&args);
  34.        
  35.         println!("Alignement de {} avec {} \n", config.filename1, config.filename2);
  36.        
  37.         let mut data1 = fasta_open_file(config.filename1);
  38.         let mut data2 = fasta_open_file(config.filename2);
  39.  
  40.         read_seq(&mut data1, &mut data2);
  41.     }
  42.  
  43.     fn fasta_open_file(filename: String) -> (File, Metadata) {
  44.         let metadata = fs::metadata(&filename).expect("Fichier non trouvé.");
  45.         let filelength = metadata.len();
  46.  
  47.         let f = File::open(filename).expect("Fichier non trouvé !");
  48.         (f, metadata)
  49.     }
  50.  
  51. // "read_seq" lit chacun des deux fichiers au format FASTA et ses métadonnées.
  52.     fn read_seq(data1: &mut (File, Metadata), data2: &mut (File, Metadata)) {
  53.         let mut seq1 = vec![0; data1.1.len() as usize];
  54.         let mut seq2 = vec![0; data2.1.len() as usize];
  55.         data1.0.read(&mut seq1).expect("débordement de buffer");
  56.         data2.0.read(&mut seq2).expect("débordement de buffer");
  57.        
  58.         let seq1_str = unsafe {
  59.             str::from_utf8_unchecked(&seq1)
  60.         };
  61.         let seq2_str = unsafe {
  62.             str::from_utf8_unchecked(&seq2)
  63.         };
  64.        
  65.         println!("1er caractère : {:?}", &seq1[0]);
  66.         println!("1er caractère : {:?}", &seq1_str.bytes().nth(0));
  67.         let sequence1 = split_seq(seq1);
  68.         let sequence2 = split_seq(seq2);
  69.         print_seq(sequence1);
  70.         print_seq(sequence2);
  71.     }
  72.  
  73. // D'un fichier au format FASTA, extraire d'une part la première ligne, de commentaire,
  74. // identifiée par le caractère ">" en première position, dont le texte documentera la
  75. // séquence sous le nom "ident", d'autre part les lignes suivantes, qui contiennent la
  76. // séquence proprement dite des nucléotides (ou des acides aminés), sous le nom
  77. // "sequence_nuc". Après traitement de "sequence_nuc" par la fonction "remove_LF",
  78. // la fonction "split_seq" renvoie le tuple "(ident, sequence_clean)".
  79.     fn split_seq(fasta_sequence: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
  80.             let mut ident: Vec<u8> = vec![0, 1, 2];
  81.             let mut sequence_nuc: Vec<u8> = vec![3, 4, 5];
  82.             if fasta_sequence[0] == 62 {
  83.                 let index = fasta_sequence.iter().position(|x| *x == 10).unwrap();
  84.                 println!("Position du premier LF : {}", index);
  85.                 ident = (fasta_sequence.split_at(index).0).to_vec();
  86.                 sequence_nuc = (fasta_sequence.split_at(index).1).to_vec();
  87.             }
  88.         let sequence_clean: Vec<u8> = remove_LF(&sequence_nuc);
  89.         (ident, sequence_clean)
  90.     }
  91.  
  92. // Cette fonction "remove_LF" reçoit les lignes de nucléotides ou d'acides aminés
  93. // et en retire les caractères LF (10 selon le code Ascii) pour former une seule ligne.
  94.     fn remove_LF(sequence_nuc: &Vec<u8>) -> Vec<u8> {
  95.         let mut sequence_clean: Vec<u8> = (&sequence_nuc).to_vec();
  96.         for i in (0..sequence_clean.len()).rev() {
  97.             if sequence_clean[i] == 10 {
  98.                 sequence_clean.remove(i);
  99.             }
  100.         }
  101.         sequence_clean
  102.     }
  103.    
  104. // "print_seq" affiche une séquence selon différents formats.
  105.     fn print_seq(sequence: (Vec<u8>, Vec<u8>)) {
  106.                 println!("Ident : {:?}", sequence.0);
  107.                 println!("Séquence : {:?}", sequence.1);
  108.                 let ident_str = unsafe {
  109.                     str::from_utf8_unchecked(&sequence.0)
  110.                 };
  111.                 let sequence_str = unsafe {
  112.                     str::from_utf8_unchecked(&sequence.1)
  113.                 };
  114.                 println!("Ident : {}", &ident_str);
  115.                 println!("Séquence : {}", &sequence_str);
  116.     }
  117.                
  118. }

Télécharger