Programmation du mode XSLT de Python

Lebrun Jonathan

Voyons comment fonctionne XSLT avec Python. ♪

- Titre : Programmation du mode XSLT de Python

- Auteur : Lebrun Jonathan

- Parution : 24 avril 2013

- Mise à jour : 24 avril 2013

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2013 Lebrun Jonathan. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Le fichier python

- III. Conclusion

I - Introduction

Le but de ce tutoriel est de créer un fichier HTML sur base des fichiers XML et XSL qu'on lui donne. Il existe beaucoup de Processeur XML dans différents langages. En Java, on retrouve Xalan-J et Xalan-C++ existe pour le C++. Mais le langage Python est très simple à apprendre et très puissant. Il est orienté objet et nous allons voir qu'en quelques lignes il est possible de réaliser notre exercice. Nous allons découvrir tout cela à notre aise et point par point.

Vous devez impérativement avoir des notions de Python et il est préférable que vous connaissiez le XML et le XSL de manière à mieux comprendre cet exercice, mais ce n'est pas indispensable.

Vous devez également avoir l'environnement Python ainsi que 4suite qui contient la bibliothèque PyXml.

II - Le fichier python

from Ft.Lib.Uri import OsPathToUri
from Ft.Xml import InputSource
from Ft.Xml.Xslt import Processor
import os.path

"""
Classe permettant la conversion en HTML d'un fichier XML grâce à
son XSL
"""

class HtmlConverter:

def __init__(self, xml, xsl):
"""
Constructeur de HtmlConcerter.
Prend deux noms de fichiers. Le premier est le
fichier xml et le second est le fichier xsl
qui vont permettre la creation du fichier html.
"""
self.xmlFile = xml
self.xslFile = xsl

def toHtml(self, htmlFile):
"""
Ecrit dans un fichier HTML la transformation
du fichier XML.
Si True est retourné, c'est que tout c'est bien passé.
Si False est retourné, des erreurs se sont produites.
"""
if (os.path.exists(self.xslFile) == False):
print ('Le fichier XSL n\'existe pas')
return False
if (os.path.exists(self.xmlFile) == False):
print ('Le fichier XML n\'existe pas')
return False
styuri = OsPathToUri(self.xslFile)
srcuri = OsPathToUri(self.xmlFile)
STY = InputSource.DefaultFactory.fromUri(styuri)
SRC = InputSource.DefaultFactory.fromUri(srcuri)
proc = Processor.Processor()
proc.appendStylesheet(STY)
result = proc.run(SRC)
try:
fileResult = open(htmlFile,"w")
fileResult.write(result)
fileResult.close()
except IOError:
return False
return True

if __name__ == "__main__":
directory = "C:/Documents and Settings/jle/My Documents/SiteS/javascript/withxml/"
xml = directory + "tutorial-xml-xsl-javascript.xml"
xsl = directory + "tutorial-xml-xsl-javascript.xsl"
html = directory + "tutorial-xml-xsl-javascript.html"
htmlC = HtmlConverter(xml,xsl)
print htmlC.toHtml(html)

Ci-dessus, le fichier python complet que vous pouvez appeler HtmlConverter. Nous allons découvrir pas à pas les différentes fonctions qu'apporte ce script. Il sera possible par la suite d'ajouter de nouvelles méthodes permettant de traiter plusieurs fichiers XML avec un XSL, mais je vous laisse cela en exercice.

from Ft.Lib.Uri import OsPathToUri
from Ft.Xml import InputSource
from Ft.Xml.Xslt import Processor
import os.path

Les quatre premières lignes importent les différents modules et classes dont nous avons besoin. « OsPathToUri » permet de transformer un String en un chemin de fichier. « InputSource » nous servira à construire un fichier sur base des strings passés. Le « Processor » est la classe qui va procéder à la transformation du XML.

class HtmlConverter:

def __init__(self, xml, xsl):
self.xmlFile = xml
self.xslFile = xsl

On va ensuite créer une classe avec un constructeur qui va prendre en paramètres le nom du fichier XML et le nom du fichier XSL. Il doit s'agir du chemin complet pour ces fichiers.

def toHtml(self, htmlFile):
if (os.path.exists(self.xslFile) == False):
print ('Le fichier XSL n\'existe pas')
return False
if (os.path.exists(self.xmlFile) == False):
print ('Le fichier XML n\'existe pas')
return False
styuri = OsPathToUri(self.xslFile)
srcuri = OsPathToUri(self.xmlFile)
STY = InputSource.DefaultFactory.fromUri(styuri)
SRC = InputSource.DefaultFactory.fromUri(srcuri)
proc = Processor.Processor()
proc.appendStylesheet(STY)
result = proc.run(SRC)
try:
fileResult = open(htmlFile,"w")
fileResult.write(result)
fileResult.close()
except IOError:
return False
return True

Cette méthode, à laquelle on passe le nom du fichier HTML à créer, va réaliser la transformation du fichier XML. On commence par vérifier que les fichiers (XML et XSL) existent grâce à :

if (os.path.exists(self.xslFile) == False):
print ('Le fichier XSL n\'existe pas')
return False
if (os.path.exists(self.xmlFile) == False):
print ('Le fichier XML n\'existe pas')
return False

Ensuite, on crée les fichiers sur base de leur nom :

styuri = OsPathToUri(self.xslFile)
srcuri = OsPathToUri(self.xmlFile)
STY = InputSource.DefaultFactory.fromUri(styuri)
SRC = InputSource.DefaultFactory.fromUri(srcuri)

On crée le processeur XSLT, on lui passe le fichier XSL qui servira à la transformation et on récupère le résultat dans une variable « result ».

proc = Processor.Processor()
proc.appendStylesheet(STY)
result = proc.run(SRC)

Ce résultat est ensuite écrit dans le fichier HTML.

Le code suivant est juste le main qui va permettre de lancer la classe. Je crée ici les noms de fichiers, je crée la classe et j'appelle la méthode de transformation.

if __name__ == "__main__":
directory = "vers/mon/repertoire/"
xml = directory + "tutorial-xml-xsl-javascript.xml"
xsl = directory + "tutorial-xml-xsl-javascript.xsl"
html = directory + "tutorial-xml-xsl-javascript.html"
htmlC = HtmlConverter(xml,xsl)
print htmlC.toHtml(html)

III - Conclusion

Utiliser le mode XSLT de Python est assez simple à mettre en œuvre. Le résultat est plus que satisfaisant et la rapidité d'exécution est au rendez-vous. Python est un langage formidable auquel il faut s'attarder. Les sites web gagnent en maintenance et en temps de création grâce à XML-XSL et Python.

Vous pouvez récupérer le fichier python ainsi que les fichiers xml, xsl et javascript en faisant un clic droit et « Sauvegarder sous ».