parseurs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parseurs\n",
    "\n",
    "Dans ce notebook nous utiliserons le parseur [lxml](http://lxml.de/) qui est un binding de libxml2 et [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parser de l'html\n",
    "\n",
    "Beautiful Soup nous permet de parser simplement du contenu html. Même si le contenu est mal formé, le module bs reconstitue un arbre et offre des fonctions faciles à utiliser pour parcourir l'arbre ou y rechercher des éléments.  \n",
    "Beautiful Soup n'est pas un parseur, il utilise les parseurs et offre une API simplifiée à ses utilisateurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous travaillerons directement avec du contenu en ligne. Fini les exercices bidons, cette fois nous allons nous confronter à une question essentielle : combien d'accordages *open tuning* Neil Young utilise et comment sont-ils répartis dans son oeuvre ?  \n",
    "On trouve les infos sur les chansons de Neil Young et les accordages sur le fabuleux site [songx.se](http://songx.se/index.php)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec le module `urllib` nous allons pouvoir instancier un objet Beautiful Soup sans trop d'efforts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "url = \"http://songx.se/index.php\"\n",
    "html = urlopen(url)\n",
    "soup = BeautifulSoup(html.read(), 'lxml')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voilà nous avons maintenant un objet `soup` de classe Beautiful Soup.  \n",
    "La [doc](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) est très claire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# je cherche l'élement avec le tag 'title'\n",
    "print(soup.title)\n",
    "# le tag de l'élément\n",
    "print(soup.title.name)\n",
    "# le contenu textuel de l'élément\n",
    "print(soup.title.string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les informations qui nous intéressent sont contenues dans des éléments comme celui-ci :  \n",
    "    `<div class=\"songrow\"><a href=\"?song=505\">Clementine</a> <small>(cover)</small><div style=\"float:right;\">EADGBE</div></div>`  \n",
    "Où on trouve 1. le nom de la chanson ('Clementine') et l'accord utilisé ('EADGBE')  \n",
    "Pour trouver ces éléments dans l'arbre nous allons utiliser la méthode `find_all`. La méthode renvoie un iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in soup.find_all('div', attrs={'class':'songrow'})[:10]:\n",
    "    print(item.a.string, item.div.string)\n",
    "# on peut aussi utiliser la notation suivante\n",
    "#for item in soup.find_all('div', class_=\"songrow\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# notre structure de données résultat\n",
    "# un dictionnaire avec en clé l'accordage et en valeur la liste des chansons qui utilisent cet accordage\n",
    "tunings = dict()\n",
    "for item in soup.find_all('div', attrs={'class':'songrow'}):\n",
    "    song_title = item.a.string\n",
    "    tuning = item.div.string\n",
    "    if tuning in tunings:\n",
    "        tunings[tuning].append(song_title)\n",
    "    else:\n",
    "        tunings[tuning] = [song_title]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'Harvest Moon' utilise l'accordage DADGBE, y en a-t'il d'autres ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tunings['DADGBE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combien de chansons pour chaque accordage ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for tuning in sorted(tunings.keys(), key=lambda x: len(tunings[x]), reverse=True):\n",
    "    print(\"{}: {}\".format(tuning, len(tunings[tuning])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allez hop un histogramme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "values = [len(tunings[x]) for x in tunings]\n",
    "values\n",
    "plt.bar(range(0, len(values)), values)\n",
    "plt.xticks(range(0, len(values)), tunings.keys(), rotation=17)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parser de l'xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Nous allons travailler sur un fichier au format TEI extrait du corpus *Corpus 14*  \n",
    "PRAXILING - UMR 5267 (PRAXILING) (2014). Corpus 14 [Corpus]. ORTOLANG (Open Resources and TOols for LANGuage) - www.ortolang.fr, https://hdl.handle.net/11403/corpus14/v1.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le fichier se nomme ``josephine-1-150119.xml``. Il s'agit d'une lettre d'une femme de soldat à son époux.  \n",
    "Nous allons extraire du fichier TEI les informations suivantes :  \n",
    "- titre (``/TEI/teiHeader/fileDesc/titleStmt/title``)\n",
    "- source (``/TEI/teiHeader/fileDesc/sourceDesc/p``)\n",
    "- contenu de la lettre (``/TEI/text/body``)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Avec lxml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pourquoi `lxml` et pas `xml.etree.ElementTree` ? Parce que : [1](http://lxml.de/intro.html) et surtout [2](http://lxml.de/performance.html)  \n",
    "La bonne nouvelle c'est que votre code sera aussi compatible avec `xml.etree.ElementTree` ou `xml.etree.cElementTree` parce que xml utilise l'API ElementTree. Sauf pour la méthode `xpath` qui est propre à `libxml`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lxml import etree\n",
    "tree = etree.parse('josephine-1-150119.xml')\n",
    "root = tree.getroot()\n",
    "\n",
    "# Parcours des enfants de la racine (commentaires et éléments)\n",
    "for child in root:\n",
    "    print(child.tag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le fichier utilise l'espace de nom TEI : ``<TEI xmlns=\"http://www.tei-c.org/ns/1.0\">``, nous devrons l'indiquer dans nos instructions de recherche.  \n",
    "Voyons ça pour le titre (``/TEI/teiHeader/fileDesc/titleStmt/title``)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# la méthode find renvoie le premier élément qui correspond au chemin argument (ElementPath et non Xpath)\n",
    "title = root.find(\"./tei:teiHeader/tei:fileDesc/tei:titleStmt/tei:title\", namespaces={'tei':\"http://www.tei-c.org/ns/1.0\"})\n",
    "print(\"Tag : {}\".format(title.tag))\n",
    "print(\"Texte : {}\".format(title.text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Même traitement pour la source :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = root.find(\"./tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:p\", namespaces={'tei':\"http://www.tei-c.org/ns/1.0\"})\n",
    "print(\"Tag : {}\".format(source.tag))\n",
    "print(\"Texte : {}\".format(source.text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lxml a aussi une méthode ``xpath`` qui permet d'utiliser directement des expressions xpath (sans oublier les espace de noms pour notre fichier) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = root.xpath(\"/tei:TEI/tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:p\", namespaces={'tei':'http://www.tei-c.org/ns/1.0'})\n",
    "print(type(source)) #xpath retourne une liste\n",
    "print(source[0].text)\n",
    "#ou bien\n",
    "source = root.xpath(\"/tei:TEI/tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:p/text()\", namespaces={'tei':'http://www.tei-c.org/ns/1.0'})\n",
    "print(source[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour le contenu il faut ruser. La difficulté ici tient à l'utilisation d'élements `<lb/>` de type 'milestones' pour noter les retours à la ligne :  \n",
    "```xml\n",
    "<p>\n",
    "je reponse a ton aimableux lettres<lb/>\n",
    "que nous a fait plaisir en naprenas<lb/>\n",
    "que tu et enbonne santes car il<lb/>\n",
    "anais de maime pour nous<lb/>\n",
    "</p>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# la méthode findall renvoie une liste avec tous les éléments correspondant au chemin argument\n",
    "body = root.findall(\"./tei:text/tei:body/tei:p\", namespaces={'tei':\"http://www.tei-c.org/ns/1.0\"})\n",
    "for elem in body:\n",
    "    print(elem.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on ne récupère que les noeuds text précédant les éléments `<lb/>`  \n",
    "Une requête `xpath` va nous permettre de récupérer tous les noeuds text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "body = root.xpath(\"//tei:text/tei:body//text()\", namespaces={'tei':\"http://www.tei-c.org/ns/1.0\"})\n",
    "for text in body:\n",
    "    print(text, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## avec DOM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'API `ElementTree` est propre à Python, `DOM` est une API indépendante d'un langage de programmation. Il existe des implémentations `DOM` dans la plupart des langages de programmation modernes.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xml.dom import minidom\n",
    "dom = minidom.parse(\"josephine-1-150119.xml\")\n",
    "# l'objet Document\n",
    "dom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = dom.getElementsByTagNameNS(\"http://www.tei-c.org/ns/1.0\", 'title')[0] # un seul élément 'title' dans le document\n",
    "print(title) # title est un objet Element, pour accèder au contenu textuel il faut récupérer le noeud texte\n",
    "print(title.lastChild.nodeName)\n",
    "print(title.lastChild.nodeValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "idem pour la source, sauf qu'on ne peut pas se permettre de rechercher tous les éléments `p`.  \n",
    "Il faut trouver l'élément `p` fils de `sourceDesc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sourceDesc = dom.getElementsByTagNameNS(\"http://www.tei-c.org/ns/1.0\", 'sourceDesc')[0]\n",
    "for node in sourceDesc.childNodes:\n",
    "    if node.localName == \"p\":\n",
    "        print(node.lastChild.nodeValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Et maintenant le contenu et ses éléments milestones.  \n",
    "Pour garder la forme vous réécrirez les boucles `for` suivies de `if` en listes en intension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "body = dom.getElementsByTagNameNS(\"http://www.tei-c.org/ns/1.0\", 'body')[0]\n",
    "for node in body.childNodes:\n",
    "    if node.localName == \"p\" or \"opener\":\n",
    "        for in_node in node.childNodes:\n",
    "            if in_node.nodeName == \"#text\":\n",
    "                print(in_node.nodeValue, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}