Molecular Modelling and GNU/Linux

Récupérer les données d'une page internet avec Python

S. Téletchéa — 2026-04-22T09:44:43Z

Sommaire

En bioinformatique, il est courant de devoir récupérer les informations de différents endroits pour les recouper et les organiser différemment. Par exemple, une liste de gènes d'intérêt peut être identifiée sur le site du National Center for Biotechnology Information (NCBI). Les maladies associées à ces gènes vont être disponibles sur le site Online Mendellian Inheritance In Men (OMIM). Grâce aux projets de séquençage à haut débit, les changements nucléotidiques simples (Single Nucleotide Polymorphism) sont disponibles sur le site du Broad Institute : Genome Aggregration Database (gnomAD). Dans cette dernière base de données, la diversité des séquences de chacun de nos gènes est décrite, mais la conséquence de ces changements nucléotidiques est souvent inconnue. Pour terminer cette introduction rapide sur les sources de données, il faut noter que les données sur les protéines vont être accessibles sur le site UniProt et que les structures des protéines vont être disponibles sur la Protein Data Bank.

En pratique, cela veut dire que l'on peut récupérer beaucoup d'informations de manière assez rapide, en se rendant sur chacun des sites un par un, puis en recoupant celles-ci dans un fichier texte ou dans un tableur. Ce travail est essentiel en biologie, mais très vite fastidieux, car il existe plusieurs allèles d'un gène, au moins une dizaine de SNP par allèle, au moins une protéine par allèle, et très fréquemment plusieurs structures du même gène, par exemple de la protéine libre et de la protéine liée à une petite molécule ou à un autre partenaire protéique. Dans ce cas, cela devient très vite compliqué d'assembler de manière claire ces informations. C'est là que python intervient.

Python, requests et BeautifulSoup

Le langage python a été inventé par Guido van Rossum pour enseigner l'informatique. La courbe d'apprentissage du langage est rapide, car sa syntaxe est claire et concise. Il est possible d'écrire un programme sous forme de suite d'instructions à réaliser, mais très vite, il est plus clair d'organiser chaque élément en fonction, ce qui va permettre de réutiliser des éléments du code.

Quand certaines fonctions couvrent des besoins qui vont être transversaux, que chaque développeuse ou développeur va utiliser, les auteurs de ces fonctions les regroupent dans des paquets python que l'on va pouvoir appeler en début de notre programme pour les utiliser.

La librairie requests permet de récupérer le contenu d'une page internet, mais aussi d'interagir avec, par exemple pour remplir et envoyer un formulaire automatiquement.

La librairie beautifulsoup permet de parcourir le contenu d'une page internet qui a été téléchargée, d'analyser sa structure, et de récupérer des éléments selon un mot-clé, une balise (tag) ou tout autre élément remarquable.

Accéder aux informations biologiques

La plupart du temps, les sites indiqués ci-dessus vont fournir une interface d'interrogation programmatique, ou Application Programming Interface : API, qui permet de communiquer directement avec le site d'intérêt. Pour UniProt il est ainsi possible de récupérer la séquence d'une protéine directement via un lien, comme cela est indiqué dans la documentation officielle ici : https://www.uniprot.org/help/api. Pour chacun des autres sites mentionnés, il faudra utiliser une syntaxe spécifique, mais le principe est le même, une manière d'accéder à une information précise est prévue.

Dans la suite de l'article, nous allons traiter un cas générique pour illustrer comment python peut nous aider dans l'extraction de données sur des pages génériques.

Organisation d'une page internet (web)

Une page internet est un document texte organisée avec des éléments ouvrants et fermants pour définir du contenu à interpréter par le navigateur web ou à afficher pour l'utilisateur. Chaque balise, que l'on traduit donc par markup en Anglais, va avoir un rôle unique, indiqué rapidement ci-dessous :

balise p : sert à délimiter un élément de paragraphe. Un paragraphe va correponsdre à un bloc de texte qui se termine par un retour à la ligne forcé. Utilisation : le texte
balise b : sert à indiquer un élément en gras (bold en Anglais). Utilisation : le texte
balise i : sert à mettre un élément en italique. Utilisation : le texte

Il existe d'autres balises (head, body, h1, h2, ...) qui servent à délimiter d'autres éléments de la page, qui ne sont pas détaillées ici. Pour une liste plus complète, il vaut mieux se référer aux sites établis (https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements).

Il est possible de retenir que l'ensemble d'une page internet est consituée d'un bloc principal défini par la balise ... contenu ... , qu'à l'intérieur de ce bloc se situent deux autres blocs, ... diverses commandes ... qui contient les instructions pour le navigateur, les élements de style et l'appel aux bibliothèques javascript, et enfin la partie du corps de la page celle qui est visible pour l'utilisateur, définie par la balise ... contenu visibile pour l'utilisateur ... .

La complexité de lecture d'une page web par un humain vient du fait que ces balises sont imbriquées les unes dans les autres, et que souvent les espaces sont enlevés pour optimiser le chargement et l'interprétation des pages.

Cas pratique : lister toutes les maladies génétiques à gène identifié

Une page wikipédia recense des maladies où un gène unique est lié à une maladie : https://fr.wikipedia.org/wiki/Liste_des_maladies_g%C3%A9n%C3%A9tiques_%C3%A0_g%C3%A8ne_identifi%C3%A9.

Cette liste est affichée sous forme d'un tableau qui a comme titres de colonnes :

Nom
OMIM
Transmission
Chromosome
Type de mutation
Gène en cause

Ce tableau est défini en HTML par la balise

contenu du tableau

, chaque ligne du tableau est définie avec la balise ... contenu de la ligne ... puis chaque cellule est délimitée par la balise contenu de la cellule ... .

Il est possible de voir l'organisation du tableau en faisant un clic droit sur la page et en choisissant l'entrée de menu "Afficher le code source de la page".

Nous allons maintenant utiliser python pour récupérer le contenu de la page et transformer le tableau en données exploitables. A ce stade, il faut noter qu'il est aussi possible de ne sélectionner à la souris que le tableau et de le copier dans un tableur (Microsoft Excel, LibreOffice Calc, etc) qui devrait reconnaître le format et récupérer les éléments (le temps de traitement peut être un peu long).

Version 1 : téléchargement de la page avec requests

Nous allons utiliser la librairie requests pour télécharger en local le texte de la page.

#!/usr/bin/env python3 from bs4 import BeautifulSoup import requests import sys def telecharge_url(url): """ Télécharge une page distante avec la bibliothèque requests et renvoie le contenu au format texte https://www.w3schools.com/python/module_requests.asp """ # Wikipedia demande un User Agent headers = {"User-Agent": "Mozilla/5.0"} html = requests.get(url,headers=headers) # print(f"Contenu de la page \n:{html}") return html def main(): # Récupération des données # Liste des maladies génétiques avec un gène identifié lien = "https://fr.wikipedia.org/wiki/Liste_des_maladies_g%C3%A9n%C3%A9tiques_%C3%A0_g%C3%A8ne_identifi%C3%A9" page = telecharge_url(lien) if __name__ == "__main__": main()

Version 2 : analyser le code HTML avec BeautifulSoup

#!/usr/bin/env python3 from bs4 import BeautifulSoup import requests import sys def telecharge_url(url): """ Télécharge une page distante avec la bibliothèque requests et renvoie le contenu au format texte https://www.w3schools.com/python/module_requests.asp """ # Wikipedia demande un User Agent headers = {"User-Agent": "Mozilla/5.0"} html = requests.get(url,headers=headers).text # print(f"Contenu de la page \n:{html}") return html def analyse_page(page): """ Analyse le contenu d'une page web pour récupérer ce qui correspond à une balise spécifique Renvoie une liste à partir du tableau de données Documentation : thunderbit.com/fr/blog/beautifulsoup-in-python """ data=[] # Analyser la page avec beautifulsoup soup = BeautifulSoup(page, 'html.parser') # Récupérer tous les tableaux tables = soup.find_all('table') # Extraire les données de chaque tableau for t in tables: # Lire chaque ligne trouvée for ligne in t.find_all('tr'): # Lire chaque cellule de la ligne cellules = ligne.find_all('td') # Transformer la ligne de cellules en liste l = [c.text.strip() for c in cellules] try: if l[5] != '' and l[0] != 'Nom': data.append(l) except: # The table has no disease data pass return data def main(): # Récupération des données # Liste des maladies génétiques avec un gène identifié lien = "https://fr.wikipedia.org/wiki/Liste_des_maladies_g%C3%A9n%C3%A9tiques_%C3%A0_g%C3%A8ne_identifi%C3%A9" page = telecharge_url(lien) liste = analyse_page(page) print(liste) if __name__ == "__main__": main()

Version 3 : exporter le résultat dans un fichier Microsoft Excel

La libraire PANDAS permet d'exporter des données dans un fichier excel. Pour manipuler les données, elle représente celles-ci sous une forme de feuille de calcul (DataFrame), ce qui permet d'accéder rapidement à de nombreuses fonctions, comme l'export de fichier au format excel.

#!/usr/bin/env python3 from bs4 import BeautifulSoup import pandas as pd import requests import sys def telecharge_url(url): """ Télécharge une page distante avec la bibliothèque requests et renvoie le contenu au format texte https://www.w3schools.com/python/module_requests.asp """ # Wikipedia demande un User Agent headers = {"User-Agent": "Mozilla/5.0"} html = requests.get(url,headers=headers).text # print(f"Contenu de la page \n:{html}") return html def analyse_page(page): """ Analyse le contenu d'une page web pour récupérer ce qui correspond à une balise spécifique Renvoie une liste à partir du tableau de données Documentation : thunderbit.com/fr/blog/beautifulsoup-in-python """ data=[] # Analyser la page avec beautifulsoup soup = BeautifulSoup(page, 'html.parser') # Récupérer tous les tableaux tables = soup.find_all('table') # Extraire les données de chaque tableau for t in tables: # Lire chaque ligne trouvée for ligne in t.find_all('tr'): # Lire chaque cellule de la ligne cellules = ligne.find_all('td') # Transformer la ligne de cellules en liste l = [c.text.strip() for c in cellules] try: if l[5] != '' and l[0] != 'Nom': data.append(l) except: # The table has no disease data pass return data def main(): # Récupération des données # Liste des maladies génétiques avec un gène identifié lien = "https://fr.wikipedia.org/wiki/Liste_des_maladies_g%C3%A9n%C3%A9tiques_%C3%A0_g%C3%A8ne_identifi%C3%A9" page = telecharge_url(lien) liste = analyse_page(page) # Export en fichier formaté df = pd.DataFrame(liste, columns=['Nom', 'OMIM', 'Transmission', 'Chromosome', 'Type de mutation', 'Gène en cause']) # Enregistrement au format Microsoft Excel df.to_excel("liste_maladies_genes_identifies.xlsx", index=False) if __name__ == "__main__": main()

Dépendances et utilisation du programme V3

Le programme (v3) ci-dessous fait appel à requests, beautifulsoup, pandas, openpyxl (pour l'export python). Si vous utiliser un IDE comme PyCharm vous pouvez les installer via celui-ci, sinon vous pouvez créer un environnement virtuel léger python comme suit :

sudo apt install python3-virtualenv ou sous Mac OS : brew install virtualenv virtualenv -p python3 venv source venv/bin/activate pip install beautifulsoup4 pandas openpyxl requests

Pour utiliser le programme ci-dessus, vous pouvez l'exécuter via PyCharm ou via le terminal :

source venv/bin/activate chmod +x programme_v3.py ./programme_v3.py

Le fichier excel "liste_maladies_genes_identifies.xlsx" sera créé au même endroit que le programme, et vous pouvez ouvrir ce fichier pour étudier son contenu, effectuer des tris, etc.

Pour aller plus loin

Python : bonnes pratiques pour mettre en place un programme

S. Téletchéa — 2024-04-19T09:39:45Z

Sommaire

La langage python est récemment devenu très populaire de par sa facilité apparente d'utilisation. Il reste néanmoins un langage informatique qui comporte des notions complexes, et une fois les premiers programmes écrits (scripts), il faut assez rapidement réfléchir à structurer le programme pour qu'il devienne exploitable sur le moyen terme, au risque sinon de devenir du code mort, jetable, et donc perdu.

Pour éviter cette dérive, voici quelques conseils avec des exemples rapides d'utilisation.

Version 1 du programme, un "script"

Prenons comme exemple un petit programme en python suivant, qui permet d'afficher un simple "coucou" dans un terminal, que l'on enregistre dans le fichier programme_v1.py :

print("Coucou")

Pour voir le résultat ce petit programme, on peut l'exécuter ainsi :

python programme_v1.py

... qui affiche donc dans le terminal

Coucou

Version 2 : programme, le rendre exécutable

Cela peut devenir vite fastidieux de mettre à chaque fois le mot "python" devant chacun des programmes que l'on utilise, alors qu'au final c'est le programme dont on a besoin. Il existe une commande pour changer cela, mais qui nécessite de revoir un peu la structure de notre petit programme, il faut lui ajouter un shebang à la première ligne.

#!/usr/bin/env python3 print("Coucou")

Le nouvelle programme s'appelle maintenant programme_v1.1.py.

Remarquez que comme il s'agit d'une version mineure du programme, j'ai incrémenté son numéro simplement (passage de 1 à 1.1). Nous reviendrons sur cette notion plus loin.

Pour rendre ce programme exécutable et le lancer, il faut taper :

 chmod +x programme_v1.1.py ./programme_v1.1.py Coucou

Remarquez qu'il faut préciser l'emplacement du fichier pour que le système lance le programme, en spécifiant "./" au début du nombre du programme. Le point suivi d'une barre oblique "./" indique que l'on utilise le répertoire courant, et qu'il faut exécuter le programme "programme_v1.1.py".

Le résultat ne change pas.

Version 2 du programme, du script au programme

Le "script" par définition est un petit programme qui a vocation à être court, pour répondre à un besoin précis, on peut souvent le réécrire sans trop reprendre un ancien script. C'est l'une des raisons de l'utilisation du shell bash, c'est qu'il permet d'enchaîner plusieurs traitements rapidement, par exemple faire le déplacement et le renommage de milliers de fichiers.

Si l'on utilise python c'est souvent parce que le traitement que l'on envisage va faire beaucoup plus d'étapes qu'envisagé initialement. Il est donc utile de mieux organiser son programme dès le départ, en suivant quelques bonnes pratiques.

La version 2 de notre programme ne va pas faire évoluer grandement encore notre programme, mais elle va permettre de le structurer.

Le fichier programme_v2.py devient ainsi à partir du fichier programme_v1.1.py :

#!/usr/bin/env python3 def main() : print("Coucou") if __name__ == "__main__" : main()

Quand on rend exécutable le programme et qu'on le lance, le résultat est toujours le même, pour le moment.

Version 3 : découper les fonctionnalités du programme

Un programme est un ensemble d'étapes que l'on veut faire faire à un ordinateur. La tâche la plus compliquée est de découper les actions pour qu'elles soient réutilisables dès le début, c'est à la fois utile pour clarifier les étapes à exécuter, mais aussi pour mieux isoler les endroits du programme où il faudra réfléchir sur le meilleur moyen d'arriver au résultat, qui le bien souvent doit faire appel à un algorithme simple ou complexe.

Pour réaliser le programme, on va donc le découper en fonction, chaque fonction va contenir des commentaires au format docstrings.

# !/usr/bin/env python3 def affiche_coucou() : """ Fonction qui permet d'afficher le texte Coucou """ print("Coucou") def main() : affiche_coucou() if __name__ == "__main__" : main()

Après avoir donné les permissions d'exécution au programme, le texte "Coucou" s'affiche à nouveau dans le terminal quand lance le programme.

Documenter son programme

L'intérêt d'avoir mieux organisé son programme est qu'il est maintenant plus modulaire, ce qui permet de le rendre plus visible, donc de produire une documentation !

Il existe plusieurs moyens de documenter son programme, mais une manière simple est de faire appel à pydoc3.

Pour l'installer sur son système il faut utiliser la commande pip :

pip install pdoc3

Cela va créer dans votre espace de travail ($HOME) une commande dans le répertoire $HOME/.local/bin.

Il suffit maintenant de générer un fichier HTML du code en version 3 :

$HOME/.local/bin/pdoc3 programme_v3.py —html —force

Cette commande va générer un fichier au format HTML qu'il est possible de regarder en ligne directement avec un navigateur.

Version 4 : continuer à développer son programme

Une fois la première ébauche du programme réalisée, il faut commencer à réfléchir à toutes les étapes que l'on voudrait réaliser, les documenter avec des docstrings, puis ensuite les écrire une par une. Une fois cette implémentation préliminaire réalisée, il sera possible d'avoir des programmes python très complexes, bien documentés et réutilisables.

# !/usr/bin/env python3 def affiche_texte(letexte) : """ Fonction qui permet d'afficher le texte fourni en argument """ print(letexte) def demande_texte() : """ Fonction qui demande un mot à afficher à l'utilisateur, pour l'instant elle ne fait rien """ pass def main() : demande_texte() affiche_texte("Coucou") affiche_texte("Bonjour") if __name__ == "__main__" : main()

Dans cette version v4 du programme la fonction affiche_coucou() a été renommée et modifiée pour devenir affiche_texte(letexte), elle devient ainsi plus générique car l'argument passé à la fonction (enregistré dans la variable letexte) est le texte à afficher, et non une valeur statique.

Une seconde fonction a été ajoutée (demande_texte()), elle ne fait pour l'instant rien, mais aura comme objectif de demander à l'utilisateur le mot à afficher. Comme il y a plusieurs moyens pour interroger un utilisateur, en ligne de commande, ou via une interface graphique par exemple, ce point ne sera pas détaillé ici.

En conclusion

Le petit exemple présenté dans un article fait partie des bonnes pratiques qu'il est important de suivre à chaque fois que l'on écrit un programme en python. Avec un peu de rigueur cela permet d'obtenir rapidement un code propre, clair et fonctionnel. Cela permet aussi d'obtenir très rapidement un résultat qui correspond à ce dont on a besoin, c'est donc en plus d'une bonne pratique, une méthode efficace de développement.

Comme indiqué précédemment, un des éléments importants pour éviter d'avoir x version du même programme est de le versionner de manière incrémentale. Cependant cela devient vite compliqué de fonctionner ainsi, c'est pour cela qu'il vaut mieux tout de suite utiliser un gestionnaire de version comme git avec un hébergement sur github, gitlab ou encore un dépôt local. Cela vous permettra de mieux suivre vos changements, même en travaillant seul sur un projet, en faisant des changements importants entre chaque commit.

Le code détaillé rapidement ici est ainsi présent sur mon dépôt github public : https://github.com/TeletcheaLab/pythondemo/.

Introduction à l'informatique pour les étudiants en biologie

S. Téletchéa — 2024-03-13T10:42:55Z

Sommaire

Dans le cadre d'enseignements de licence, j'ai l'occasion de faire une introduction à l'informatique à des étudiants en deuxième année de biologie, voici ci-après les documents de cours et les TD associés qui sont mis à la disposition des étudiants. Si vous trouvez ces contenus utiles, merci de me contacter pour me l'indiquer, je pourrai vous transmettre les documents au format éditable sans souci. Ces documents sont fournis sous licence creative commons CC-BY-NC-SA (https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr).

Document de cours

Documents de TD

TD 1

TD 2

TD 3

Cette page sera mise à jour régulièrement pour ajouter des explications et des documents additionnels.

Ajouter des polices Windows sous Ubuntu

S. Téletchéa — 2023-12-19T12:44:13Z

Les systèmes GNU/Linux contiennent de nombreuses polices de caractères qui sont largement suffisantes pour un usage du quotidien. Il peut cependant arriver que vous ayez à travailler sur un document qui sera partagé avec des collègues sous Windows, qui utiliseront par défaut la police de caractères "Calibri", ce qui rendra le rendu sous linux sous-optimal, car une police de remplacement sera affichée.

Pour installer les polices complémentaires de celles du système, il est possible d'installer la police "fonts-crosextra-carlito" qui permettra d'avoir un rendu compatible avec celui que produirait la police Calibri (même taille de caractères.

sudo apt install fonts-crosextra-carlito

Il est aussi possible d'installer automatiquement quelques polices True Type Font (TTF) de Microsoft.

sudo apt install ttf-mscorefonts-installer

Pour ce qui est de la police "Calibri" à proprement parler, il est possible de la télécharger ici : https://www.fontpalace.com/font-download/Calibri/.

Une fois le fichier calibri.ttf, aller avec le navigateur de fichier (nautilus) sur son emplacement, faites un clic droit sur le fichier, sélectionnez "Ouvrir avec Polices", puis une fois l'application lancée, cliquez sur "Installer".

Vous avez ainsi enrichi rapidement votre distribution d'un certain nombre de polices classiques sous d'autres OS.

Introduction to Structural bioinformatics

S. Téletchéa — 2023-10-18T07:38:49Z

This article contains useful links and documents part of an introductory lecture given to lab member of the US2B laboratory (https://us2b.univ-nantes.fr) in October 2023. This page will be updated regularly to add useful information from their feedback.

As much as possible, the origin and references are given for a more complex introduction to the field, feel free to contact me for further precisions. The documents attached below are released under a permissive.

Previous introductions

I did in the past two recorded introductions with common parts on the field. One in French and the second in English. Here are the vidéos.

Introduction to Structural bioinformatics, 2018, English (video)

Unfortunately this video has some interferences for sound records, so some parts contains sound scratches, overall most of the video is useful. This was an introductory lecture for a GGMM sponsored thematic school In Nantes, France (https://dynamoppi.sciencesconf.org/).

Introduction to structural bioinformatics (bad noise)

Stéphane Téletchéa

Introduction à la bioinformatique structurale, 2020, French (video)

This lecture was given to third-year bachelor students, and includes a little section about SARS-CoV-2 proteins structures and functions.

Introduction à la Bioinformatique Structurale

Stéphane Téletchéa

Introduction à la bioinformatique structurale, 2020, French (article)

I wrote an article in the French magazine GNU/Linux Magazine France about Structural Bioinformatics and alphaFold (2), you can find it here :

https://connect.ed-diamond.com/GNU-Linux-Magazine/glmf-234/alphafold-la-reponse-au-probleme-le-plus-complexe-de-l-univers

First lecture, introductory concepts

This document presents rapidly some important milestones in structural biology, and the latest developments in structural bioinformatics. It should probably be split into multiple files to focus on more specific chapters and sections.

Second lecture, addition of definitions and model validation

Introduction à la chémoinformatique : les fichiers pour les petites molécules 3D

S. Téletchéa — 2023-10-11T12:36:45Z

Sommaire

Format de fichier 3D des petites molécules et source

Les ligands ou constituants biologiques sont disponibles dans différentes bases de données, trois formats sont le plus souvent utilisés, en fonction de l'utilisation prévue du ligand :

le format SDF, attention ce format permet de représenter les molécules en 2D, il faut être vigilant à télécharger la molécule au format « 3D ».
le format MOL2
le format PDB

Il existe de nombreux autres formats pour représenter les petites molécules, ils sont décrits sur la page wikipedia en détail (https://en.wikipedia.org/wiki/Chemical_file_format), le détail de l'organisation de ces fichiers et les principes sous-jascents sont présentés dans uen page dédiée (https://en.wikipedia.org/wiki/Chemical_table_file).

Il est possible de décrire sur une ligne (1D) une formule chimique en suivant les descriptions du format SMILES, présentés sur le site de l'entreprise DayLight (https://daylight.com/) ou encore sur wikipedia dans la page décrivant SMILES (https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system).

Bases de données comprenant les molécules au format 3D

Quand il s'agit de petites molécules (qui seront des ligands des protéines), il est possible d'obtenir directement leurs coordonnées au format SDF 3D en allant sur :

PubChem (https://pubchem.ncbi.nlm.nih.gov/)
ChEMBL (https://www.ebi.ac.uk/chembl/)
BindingDB (https://www.bindingdb.org/bind/index.jsp)

Découverte du Deep Learning

S. Téletchéa — 2023-10-02T20:45:35Z

Sommaire

Cette page recense des ressources liées au domaine de l'apprentissage profond, il s'agit d'un article en évolution constante.

Qu'est-ce qu'un transformer ?

https://ledatascientist.com/a-la-decouverte-du-transformer/

https://www.openstudio.fr/2022/02/08/fonctionnement-des-transformers-et-leurs-applications/

https://www.journaldunet.fr/web-tech/guide-de-l-intelligence-artificielle/1508983-transformer-deep-learning/

BERT

https://lesdieuxducode.com/blog/2019/4/bert—le-transformer-model-qui-sentraine-et-qui-represente

GPT (3, 4, 5, ...

XmGrace day-to-day usage

S. Téletchéa — 2023-08-17T20:04:32Z

Before finding the wonderful XmGrace software, i'd loose time to do calculations, regressions, etc.

With this software, i've been able to do in a more robust manner and more rapidly everything i could do before and much more.

Here are some examples of what i'm using.

Some basics commands i use with XmGrace are detailed below.

Renormalizing a plot (mostly angles between -180 and +180, you want it between 0 and 360 )

Load your file into xmgrace
Go to Data->Transformations->Evaluate expressions
Select G0.S0
Fill in the box with :

y = y<=0 ? y + 360 : y

It is a basic if then else : y equals the value resulting of the test y<=0. If the test is true then y = y+ 360 otherwise take the y value

Subpopulation (for instance for an angle, where are the points above a certain value)

Load your file into xmgrace
Go to Data->Transformations->Sample points
Select the desired set (presumably S0)
Change sample type for 'Expression'
Fill in the form 'Logical expression' with your needs, for instance y=>50 will select the population where all points are equal or above 50.

Correlation between two states (for instance a sugar conformation and a dihedral angle)

Load file1 into xmgrace (it will appear as set 0)
Load file2 into xmgrace (it will appear as set 1)
Go to Data->Transformations->Evaluate expressions
Select g0.s1
Fill in the box with :
- copy s1 to s2
- s2.x=s0.y
Accept

Go back to the graph, hide s0 and s1, click on As (autoscale), you have your correlation :-) you can now fill in legends, etc.

Getting informations about points (mean, std, max, min, ...)

Load your file into xmgrace
Go to Edit->Data sets
Pick your set, the values will be displayed in the box below (rapid, isn't it ?)

Sending data through a pipe

echo -e "1 2\n2 4\n3 6" |xmgrace -pipe

Sending data through a fifo

Create the fifo

mkfifo fifo.pipe
xmgrace -npipe fifo.pipe

Send the commands through the fifo

echo "read \"data.out\"" > fifo.pipe
echo autoscale > fifo.pipe
echo redraw > fifo.pipe

Other sites with tips

http://ringo.ams.sunysb.edu/index.php/Xmgrace

Django setup with rdkit for chemoinformatics studies

S. Téletchéa — 2023-08-17T18:18:19Z

Although Rdkit and Django installation and deployment are well documented independently, it may become rapidly difficult to a newcomer to get a simple rdkit + django implementation working using a real apache backend. This article will detail how they can be implemented and used for a small demonstration application.

Django setup

We will first create our django sample application using virtualenv and pip.

 virtualenv venv source venv/bin/activate pip install django==3.2.20

Now that the minimum requirements are met, it is time to start a new project called chemoinformaticsDemo.

 django-admin startproject chemoinformaticsDemo

This will install django files and a subdirectory called again chemoinformaticsDemo where the projects settings will have to be updated. For now we can keep it as is.

At this point we only need some dirs that will be filled in later.

 cd chemoinformaticsDemo mkdir static mkdir chemoinformaticsDemo/templates

There is now the default infrastructure for the django project (without rdkit calls, see below). In order to get a proper django setup, we need to initalize the database for django models, mostly for authentication management at this step.

This will install django files and a subdirectory called again chemoinformaticsDemo where the projects settings will have to be updated. For now we can keep it as is.

At this point we only need some dirs that will be filled in later.

 cd chemoinformaticsDemo mkdir static mkdir chemoinformaticsDemo/templates

 python manage.py makemigrations python manage.py migrate

It you are really impatient, you can already start your application in the developper mode using:

 python manage.py runserver

To see the result you can fire up your browser and point to the location

 http://localhost:8000

To get something more specific, you can add a template in chemoinformaticsDemo/templates, for instance called base.html.

 chemoinformaticsDemo/templates/base.html      This is the starting page of the project.  {% block content %}{% endblock content %}

This page will be displayed via the urls mapping in django, so you have to specify a simple urls.py and views.py, as exemplified after.

 chemoinformaticsDemo/urls.py from django.conf.urls import patterns, include, url from django.conf import settings from django.contrib import admin admin.autodiscover() urlpatterns = ( url(r'^$','chemoinformaticsDemo.views.home', name='home'), url(r'^admin/', include(admin.site.urls)), )

The corresponding views.py will be called from this url redirection.

  chemoinformaticsDemo/views.py from django.shortcuts import render from django.conf import settings def home(request): return render(request, 'home.html')

If you refresh the previously opened http page, you should now get a small message welcoming you:

  This is the starting page of the project.

It is now time to add some content to the project, and especially to link rdkit with django.

RdKit installation (http://www.rdkit.org)

This installation was performed on Ubuntu 14.04.4 LTS 64bits.

First download the latest rdkit tarball. ( https://sourceforge.net/projects/rdkit/files/latest/download )
Decompress the archive, enter the rdkit directory and create a build directory, then use default options, except for the rdkit installation location:

  cd /opt tar -zxvf RDKit_2016_03_1.tgz cd rdkit-Release_2016_03_1 mkdir build cd build sudo cmake .. sudo make install

You will need sudo / root rights to write to the /opt directory.

It is important to have rdkit paths available system-wide so Apache will also be able to find it properly. The easiest way is to indicate to the system where it should search for rdkit libraries. This is done by adding a file in the linker directory, in /etc/ld.so.conf.d/ (https://howtolamp.com/articles/adding-shared-libraries-to-system-library-path/). We can create a simple file called rdkit.conf, and update the dynamic loader cache to have rdkit included properly. In short:

  sudo echo "/opt/rdkit-Release_2016_03_1/lib" > /etc/ld.so.conf.d/rdkit.conf sudo ldconfig

If you want to be sure the library search now contains the RdKit path, just grep for it.

  grep -i rdkit /etc/ld.so.cache Binary file /etc/ld.so.cache matches

You also need that rdkit is available for python programs out of you django environment.

  Python 2.7.6 (default, Jun 22 2015, 17:58:13) [GCC 4.8.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.append('/opt/RDkit_2016_03_1') >>> from rdkit import Chem >>> quit()

Please note that the /lib directory is not present in the sys.path.append command because python bindings are present at the RDkit root.

Testing rdkit inside django

Now that everything is in place, we can test a simple but functionnal application. First we create a dedicated application called rdkitDemo (and not simply rdkit otherwise there will be namespace collisions).

  python manage.py startapp rdkitDemo mkdir rdkitDemo/templates

You need to edit the chemoinformaticsDemo/settings.py to add to "INSTALLED_APPS" rdkitDemo (using any text editor).
Now django has to take into account this new application, so migrate existing tables.

  python manage.py makemigrations python manage.py migrate

Up-to-now since no modifications were made to the models (and therefore to the tables) there should be no error messages and no migrations detected.
To enrich you django project, we will add new urls to take into account rdkitDemo and add a sample html file for showing a simple demonstration of rkdit.

  update to chemoinformaticsDemo/urls.py from django.conf.urls import patterns, include, url from django.conf import settings from django.contrib import admin admin.autodiscover() urlpatterns = ( url(r'^$','essai.views.home', name='home'), url(r'^admin/', include(admin.site.urls)), {{url(r'^rdkit/', include('rdkitDemo.urls')),}} )

The corresponding entry in the new application involves its own urls.py file.

  rdkitDemo/urls.py from django.conf.urls import patterns, include, url from django.contrib import admin urlpatterns = patterns('', url(r'^demo', 'rdkitDemo.views.simple_example', name='rdkit_simple_example'), )

We can now set up a small demonstration of what can be accomplished with rdkit, for instance computing the 2D coordinates of beta galactose from its SMILES description in pubchem, and optimize its geometry in 3D (https://pubchem.ncbi.nlm.nih.gov/compound/beta-D-galactose). The generated molecule will be transformed into a 2D plot stored on the disk.

To store the PNG file, add a subdirectory to the static directory seen above.

  mkdir static/demo chmod 777 static/demo

Important Note: the chmod will be used later, this is not mandatory for now and should also NOT be done on a production server...

Now that everything is in place, we can add the necessary files in rdkitDemo.

  rdkitDemo/views.py from django.shortcuts import render from django.conf import settings from rdkit import Chem from rdkit.Chem import AllChem from rdkit import DataStructs from rdkit.Chem.Fingerprints import FingerprintMols from rdkit.Chem import Draw from PIL import Image # Create your views here. def simple_example(request): smiles_data='C([C@@H]1[C@@H]([C@@H]([C@H]([C@@H](O1)O)O)O)O)O' m = Chem.MolFromSmiles(smiles_data) # Code SMILES issu de pubchem # data=Chem.MolToMolBlock(m) # Unused, not pretty to display (yet) # 3D conversion and optimization m2=Chem.AddHs(m) AllChem.EmbedMolecule(m2) AllChem.MMFFOptimizeMolecule(m2) # more complex, better? # AllChem.UFFOptimizeMolecule(m) # faster, less stronger :-) Draw.MolToFile(m,settings.BASE_DIR+'/static/demo/test.png') toto=FingerprintMols.FingerprintMol(m) # not used return render(request,'demo.html', {'data':smiles_data})

To display the result of the view, a new template is created, based on the base.html file already available.

  rdkitDemo/templates/demo.html {% extends "base.html" %} {% load static %} {% block title %}Simple rdkit Demo{% endblock title %} {% block content %} Welcome to this demo project for the molecule described by {{ data }}.
   Back 
 {% endblock content %}

If everything worked perfectly until here, you can start again your django project in developper mode, pay attention to update your manage.py file to extend the system path for rdkit. Pay also attention to spaces above if you copy/paste the code since python uses spaces (or abs) to indent the code and determine logical blocks.

  manage.py #!/usr/bin/env python import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "essai.settings") sys.path.append('/opt/RDkit_2016_03_1') from django.core.management import execute_from_command_line execute_from_command_line(sys.argv)

You should now get a working rdkit + django installation in the developper mode for django.

  (venv)python manage.py runserver

Reminder: we are still in the virtualenvironment created at the beginning. If you get errors about PIL not found, just add it using pip, and do the same for any missing dependencies.

  pip install Pillow

Only one step is needed to migrate this small application to a real server available for the community.

Migration to apache

If everything is is place, you can now configure apache to use your virtual environment and rkdit. Assuming the virtual environment was stored in /home/stephane/example, one needs to write the following apache configuration file.

  /etc/apache2/sites-available/rdkitDemo.conf  ServerName localhost ServerAlias localhost # Very important, see https://code.google.com/archive/p/modwsgi/wikis/ApplicationIssues.wiki#Python_Simplified_GIL_State_API WSGIApplicationGroup %{GLOBAL} # https://docs.djangoproject.com/en/dev/howto/deployment/wsgi/modwsgi/ WSGIDaemonProcess essaiRdkit python-path=/home/stephane/example/chemoinformaticsDemo:/opt/RDkit_2016_03_1/:/home/stephane/example/chemoinformaticsDemo/django1.8/lib/python2.7/site-packages display-name=essaiRdkit WSGIProcessGroup essaiRdkit WSGIScriptAlias /essai '/home/stephane/example/chemoinformaticsDemo/chemoinformaticsDemo//wsgi.py'  WSGIProcessGroup essaiRdkit  Options +ExecCGI -MultiViews +FollowSymLinks AllowOverride None Require all granted   Alias /static /home/stephane/example/chemoinformaticsDemo/static/  WSGIProcessGroup essaiRdkit Options -Indexes +FollowSymLinks Require all granted  # Pour séparer les bons logs de l'ivraie ErrorLog ${APACHE_LOG_DIR}/djangoprojects-error.log CustomLog ${APACHE_LOG_DIR}/djangoprojects-access.log combined

Remember that we opened the door for apache writing with the chmod 777 to the demo subdir before, THIS HAS TO BE CHANGED using a proper location for www-data user access...

Everything is now in place, activate the new virtual apache environment and reload apache configuration.

  udo a2ensite rdkitDemo sudo service apache2 reload

You should now have a great django web site to play with, just integrate your rdkit applications!
To ensure everything is up and running, open your brower to the location

  http://localhost/essai/

In case you will be in trouble, check apache logs in /var/log/apache2/djangoprojects-error.log, they are isolated to better identify mistakes and / or copy/pasting errors.
Enjoy.

DockNmine, a Web Portal to Assemble and Analyse Virtual and Experimental Interaction Data

S. Téletchéa — 2023-08-17T16:19:55Z

My latest article is published online, its objectives are to assemble virtual and experimental data on public and private ligands, in order to provide a broader overview of the performance of virtual screening studies.

You can find the complete article online, do not hesitate to contact me for further explanations, demands, comments, etc.

You can also browse it directly at the webserver address http://www.ufip.univ-nantes.fr/tools/docknmine.

Enjoy!

Molecular Modelling and GNU/Linux

Récupérer les données d'une page internet avec Python

Sommaire

Python, requests et BeautifulSoup

Accéder aux informations biologiques

Organisation d'une page internet (web)

Cas pratique : lister toutes les maladies génétiques à gène identifié

Version 1 : téléchargement de la page avec requests

Version 2 : analyser le code HTML avec BeautifulSoup

Version 3 : exporter le résultat dans un fichier Microsoft Excel

Dépendances et utilisation du programme V3

Pour aller plus loin

Python : bonnes pratiques pour mettre en place un programme

Sommaire

Version 1 du programme, un "script"

Version 2 : programme, le rendre exécutable

Version 2 du programme, du script au programme

Version 3 : découper les fonctionnalités du programme

Documenter son programme

Version 4 : continuer à développer son programme

En conclusion

Introduction à l'informatique pour les étudiants en biologie

Sommaire

Document de cours

Documents de TD

Ajouter des polices Windows sous Ubuntu

Introduction to Structural bioinformatics

Table of contents

Previous introductions

Introduction to Structural bioinformatics, 2018, English (video)

Introduction à la bioinformatique structurale, 2020, French (video)

Introduction à la bioinformatique structurale, 2020, French (article)

First lecture, introductory concepts

Second lecture, addition of definitions and model validation

Introduction à la chémoinformatique : les fichiers pour les petites molécules 3D

Sommaire

Format de fichier 3D des petites molécules et source

Bases de données comprenant les molécules au format 3D

Découverte du Deep Learning

Sommaire

Qu'est-ce qu'un transformer ?

BERT

GPT (3, 4, 5, ...

XmGrace day-to-day usage

Table of contents

Renormalizing a plot (mostly angles between -180 and +180, you want it between 0 and 360 )

Subpopulation (for instance for an angle, where are the points above a certain value)

Correlation between two states (for instance a sugar conformation and a dihedral angle)

Getting informations about points (mean, std, max, min, ...)

Sending data through a pipe

Sending data through a fifo

Other sites with tips

Django setup with rdkit for chemoinformatics studies

Table of contents

Django setup

RdKit installation (http://www.rdkit.org)

Testing rdkit inside django

Migration to apache

DockNmine, a Web Portal to Assemble and Analyse Virtual and Experimental Interaction Data