Cette page tente de donner des exemples de traitement de fichiers XML à l'aide de python et des modules ad-hoc.

Généralités

Courte présentation de XML. Ils existents deux API qui correspondent à deux façons de traiter des documents : DOM et SAX

L'API DOM

Qu'est ce que c'est ?

DOM signifie "Document Object Model". C'est une API qui associe à un fichier XML un arbre (ou un bosquet) dans lequel nous allons pouvoir naviguer pour accéder à différentes informations. Les avantages de cette API sont :

• Pratique lorsque l'on souhaite accéder plusieurs fois à des informations (pas en un seul passage)
• Possibilité de manipuler/modifier l'arbre (modification du document XML)

Les inconvénients :

• Peu adaptée pour de gros documents : l'arbre géneré en mémoire à partir du fichier XML est, au minimum 16 fois plus gros que ce fichier ;
• L'API DOM officielle est moyennement digeste et très peu pythonesque.

Exemples de codes

Créer un document XML

   1 from xml.dom.minidom import Document
   2 
   3 doc = Document()
   4 
   5 racine = doc.createElement("element_racine")
   6 doc.appendChild(racine)
   7 
   8 element = doc.createElement("sous_element")
   9 element.setAttribute("un_attribut", "la valeur")
  10 racine.appendChild(element)
  11 
  12 texte = doc.createTextNode('Coucou :-)')
  13 element.appendChild(texte)
  14 
  15 print doc.toprettyxml()

Ce qui nous donne le résultat suivant :

<?xml version="1.0" ?>
<element_racine>
        <sous_element un_attribut="la valeur">
                Coucou :-)
        </sous_element>
</element_racine>

Extraire des données d'un élément XML

   1 from xml.dom import minidom
   2 dom = minidom.parse('out.xml')
   3 
   4 section = dom.getElementsByTagName('section')
   5 print section[0].toxml()

Lire un flux RSS 2.0 et en extraire les titres

   1 import urllib, sys, xml.dom.minidom
   2 adress = 'http://www.sebsauvage.net/rss/updates.xml'
   3 document = xml.dom.minidom.parse(urllib.urlopen(adress))
   4 for item in document.getElementsByTagName('item'):
   5     titre = item.getElementsByTagName('title')[0].firstChild.data
   6     print "Titre:", titre.encode('latin-1','replace')

L'API SAX

Qu'est ce que c'est ?

L'API SAX est née fin 1998 sur la liste xml-dev face à la multitude de parseurs présents à l'époque. SAX signifie "Simple API for XML" et n'est pas normalisée par le W3C contrairement à DOM. Cette API (SAX2 en fait) est inclue dans python depuis la version 2. Les avantages de l'API SAX sont :

• adaptée pour de gros documents (l'API SAX lit le document au fur et à mesure) ;
• adaptée pour un traitement en un seul passage ;
• évenementielle : chaque fois que le parser rencontre quelquechose (tag ouvrant, tag fermant...), il appelle un handler. C'est du "event-based parsing".

Comment écrire un programme python utilisant SAX ?

Il faut suivre les étapes suivantes :

• Ecrire une classe "handler de document" qui va contenir les différentes méthodes à appeler pour chaque évenement (début du doc, début d'un élement, fin...) rencontré lors du parsing ;
• Ecrire un handler des exceptions (erreurs) ;
• Ecrire, peut-être, un handler de DTD ;
• Choisir un parser et lancer le parsing

   1 from xml.sax import ContentHandler, make_parser
   2 class MonHandler(ContentHandler):
   3      "Document Handler personnel"
   4      def __init__(self):
   5      "initialisation"
   6           pass
   7      def startDocument(self):
   8      "fonction appelée lorsque le parser rencontre le premier élement"
   9           pass
  10      def startElement(self, name, attrs):
  11      "fonction appelée lorsque le parser rencontre une balise ouvrante"
  12           pass
  13      def endElement(self, name):
  14      "fonction appelée lorsque le parser rencontre une balise fermante"
  15           pass
  16      def characters(self, chrs, offset, length):
  17      "fonction appelée lorsque le parser rencontre des données dans un élement"
  18           pass
  19      def endDocument(self):
  20      "fonction appelée lorsque le parser rencontre le dernier élement"
  21           pass
  22 
  23 doc = MonHandler()
  24 saxparser = make_parser()
  25 saxparser.setContentHandler(doc)
  26 
  27 datasource = open("out.xml","r")
  28 saxparser.parse(datasource)    

Il est courant d'utiliser des variables d'instances (liste ou dict) chargées de collecter des données spécifiques. Si le traitement nécessite de conserver une trace des balises déjà rencontrées, il suffit d'utliser une liste comme pile: on empile les balise dans startElement(), on les dépile dans endElement().

Exemples de codes

Créer un document XML

La bibliothèque standard de Python propose un handler SAX standard pour écrire dans un descripteur de fichier : xml.sax.saxutils.XMLGenerator. On peut l'instancier en lui passant un objet de fichier ouvert. Par défaut, il écrit sur la sortie standard.

   1 from xml.sax.saxutils import XMLGenerator
   2 from xml.sax.xmlreader import AttributesImpl
   3 
   4 hd = XMLGenerator() # Création du handler
   5 
   6 hd.startDocument()
   7 attr = AttributesImpl({ "attribut1": "valeur", "attribut2": "0" })
   8 hd.startElement("élément_racine", attr)
   9 
  10 hd.startElement("toto", AttributesImpl({"foo": "bar", "titi": "tata"}))
  11 # Les caractères génants seront échapés comme il faut
  12 hd.characters("<plop> & <!--")
  13 hd.endElement("toto")
  14 
  15 # Utilisation des espaces de nommages
  16 uri = "http://www.quelquepart.org/namespace/"
  17 hd.startPrefixMapping("monNS", uri)
  18 hd.startElementNS(
  19         (uri, "foo"),
  20         "foo",
  21         AttributesImpl({ (uri, "att1"): "false", (uri, "att2"): "coucou" })
  22         )
  23 hd.characters("Bla bla bli bla...")
  24 hd.endElementNS((uri, "foo"), "mon_ns")
  25 
  26 hd.endElement("élément_racine")
  27 hd.endDocument()

Cette méthode est intéressante pour générer de gros fichiers pour lesquels DOM serait trop gourmand en mémoire.

Transformer un fichier *.xml en *.sql

Le fichier *.xml ressemble à

<?xml version="1.0" encoding="ISO-8859-1"?>
<document>
<introduction>Texte intro</introduction>
<section id="1" name="section 1" description="Texte introductif à la section 1">
<sousSection id="1" rubrik="1" thema="subsection 1.1">
<texte>Texte de la soussection 1.1</texte>
</sousSection>
<sousSection id="2" rubrik="1" thema="subsection 1.2">
<texte>Texte de la soussection 1.2</texte>
</sousSection>
</section>
<section id="2" name="section 2" description="Texte introductif à la section 2">
<sousSection id="1" rubrik="2" thema="soussection 2.1">
<texte>Texte de la soussection 2.1</texte>
</sousSection>
</section>
</document>

L'utilisation de l'API SAX va le convertir en fichier de requêtes SQL. Voici le code python :

Format OpenDocument

Ne voulant pas lancer openoffice systématiquement, ni être dépendant d'une plateforme, j'ai essayé ooopy http://ooopy.sourceforge.net/ mais le projet ne semble pas évoluer et ça ne fonctionne pas bien avec odt, ça fonctionne plutôt avec sxw (ancien format openoffice). Par contre le principe reste intéressant, il dézippe le document et l'ouvre avec elementtree. J'ai donc utilisé cette technique.

Comme me l'a suggéré florent manens, j'utilise la notion de "variables" d'openoffice plutôt que des balise textes $$xxxx, ça évite les problèmes au cas où la balise texte serait dissociée en interne. (genre $$xx<b>xx</b>).

   1 from zipfile import ZipFile, ZIP_DEFLATED
   2 from cStringIO import StringIO
   3 from cElementTree import ElementTree, fromstring
   4 
   5 def replace(infile, outfile, replace):
   6     inzip = ZipFile(infile, 'r', ZIP_DEFLATED)
   7     outzip = ZipFile(outfile, 'w', ZIP_DEFLATED)
   8     content = ElementTree(fromstring(inzip.read('content.xml')))
   9 
  10     for p in content.findall(".//{urn:oasis:names:tc:opendocument:xmlns:text:1.0}variable-set"):
  11         name = p.get("{urn:oasis:names:tc:opendocument:xmlns:text:1.0}name")
  12         if name in replace:
  13             p.text = replace[name]
  14 
  15     for f in inzip.infolist():
  16         if f.filename == 'content.xml':
  17             s = StringIO()
  18             content.write(s)
  19             outzip.writestr('content.xml', s.getvalue())
  20         else:
  21             outzip.writestr(f, inzip.read(f.filename))
  22     inzip.close()
  23     outzip.close()

-- William Dodé

Liens utiles

Les liens ci-dessous étaient valides le 18 avril 2005 :

• [fr] http://pyxml.sourceforge.net/topics/howto/xml-howto.html : Python & XML HOWTO

• [en] http://www.devchannel.org/webserviceschannel/04/05/25/1414203.shtml : SAX processing in Python

• ...

Page en cours de construction... Vos contributions sont les bienvenues ! Rémi Boulle.