Discussion :

[italiasky]

Bonjour,

Je ne cherche pas à extraire la totalité d'un fichier XML.
C'est-à-dire que mon but est juste de pouvoir avoir une idée des balises présentes et avoir un exemple pour chaque balise.

Par exemple, si le fichier XML est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
<racine>
     <info>Liste de bouteilles</a>
     <bouteille>
          <type>eau</type>
          <marque>vittel</marque>
     </bouteille>
     <bouteille>
          <type>alcool</type>
          <marque>martini</marque>
     </bouteille>
     <bouteille>
          <type>eau</type>
          <marque>evian</marque>
     </bouteille>
</racine>

Au final, je cherche juste à pouvoir afficher la structure globale du fichier (les balises présentes) et un exemple pour chaque balise tout en gardant les niveaux d'imbrication :
racine
info (ex: liste de bouteilles)
bouteille
type (ex: eau)
marque (ex: vittel)

Mais voilà ça s'arrêterait là pour cet exemple, je n'ai pas besoin de plus de détail. Juste d'avoir un aperçu de ce qui se trouve dans le fichier XML.
C'est à dire finalement avoir la liste des balises avec un exemple de donnée pour que ce soit plus parlant pour comprendre la balise.

Je pourrais très bien utiliser n'importe quelle technique qui me retournerait le fichier XML en entier, etc mais par soucis de performance, je me dis que d'extraire tout le fichier XML dans ce cas la ne vaut pas le coup, n'est-ce pas ? Donc j'élimine de ce fait les solutions liées à DOM (xml.dom)

J'ai essayé ElementTree mais la totalité du fichier XML est aussi créé donc c'est pareil je dirai.

Du coup, peut être que SAX serait le mieux placer.. ?

Quelle technique me conseillez-vous parmi les différentes possibilités de manipulation de fichier XML fournies par python : http://wiki.python.org/moin/PythonXml

Voilà, j'aimerais juste vos conseils, savoir ce que vous feriez si vous aviez ce besoin sans utiliser une méthode "bourrin" qui en ferait beaucoup trop comparé au résultat recherché.

Merci
Michael

[plxpy]

Quelques réflexions :

1 - Certes, un module/package façon SAX te permet de ne pas tout décoder dans le détail ou même de sortir (break) du "parsing" si tu as trouvé ce que tu cherches, sans aller jusqu'au bout ou en sautant un élément déjà recontré. Façon DOM, tu charges et décodes tout ton fichier, dans tous les cas. C'est lorsque tu exploites l'arborescence que tu conserves tel ou tel élément pertinent.

2 - L'aperçu du fichier XML que tu veux n'est pas si évident que ça à obtenir, sauf si tu ne traites que des fichiers simples : là, il me semble que tu veux jouer sur le fait que, quand un élément de la racine a déjà été rencontré (ici <bouteille>), ce n'est pas la peine de traiter les suivants. Ca exclut donc ce genre de fichier (le tien à peine modifié), où apparait un élément optionnel (ici <volume>) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<racine>
     <info>Liste de bouteilles</a>
     <bouteille>
          <type>eau</type>
          <marque>vittel</marque>
     </bouteille>
     <bouteille>
          <type>alcool</type>
          <marque>martini</marque>
          <volume>0.75</volume>
     </bouteille>
     <bouteille>
          <type>eau</type>
          <marque>evian</marque>
     </bouteille>
</racine>

Et d'ailleurs, quel type de résumé souhaiterais-tu obtenir dans ce cas ?


Il me semble que si tu ne veux t'attaquer qu'à des fichiers XML simples, où chaque élément de premier niveau (juste en dessous de la racine) a toujours la même arborescence de sous-éléments, tu peux t'orienter vers une méthode "à la SAX" (ElementTree.iterparse peut faire l'affaire).

Si les fichiers ont une arborescence plus touffue mais surtout variable :

• avec une méthode SAX, tu vas devoir, quand même, balayer tout le fichier : tu ne décoderas pas tout (texte, attributs) mais au moins le chemin - succession des tags rencontrés - jusqu'à l'élément courant et tu devras savoir si tu as déjà rencontré ce chemin ou pas, pour l'afficher dans le résumé ou pas
• avec une méthode DOM, tu charges et décodes effectivement tout, mais j'ai l'impression que la "navigation" dans l'arborescence est quand même plus facile et conduit à un code moins "usine à gaz"

Bref, dans ce cas, les méthodes SAX ne me paraissent pas si intéressantes que ça (mais je peux me tromper).

[italiasky]

En effet ce n'est pas si simple car quand tu dis :
"quand un élément de la racine a déjà été rencontré (ici <bouteille>), ce n'est pas la peine de traiter les suivants. "
Ca dépend en fait de ce qu'on entend par "traiter" car pour reprendre l'exemple que tu as mis :
Voici ce que j'aimerais comme résumer après avoir analysé le fichier XML
racine
> info (ex: liste de bouteilles)
> bouteille
>> type (ex: eau)
>> marque (ex: vittel)
>> volume (ex:0.75)

Donc je cherche vraiment à lister toutes les balises.
Je veux connaitre toutes les balises possibles dans une balise de type "bouteille" par exemple. Du coup, lorsqu'on a traité le premier élément "bouteille", on devra quand même parcourir les autres éléments "bouteilles" jusqu'à la fin.

En résumé :
Si c'est un élément qui a des descendants, on descendra toujours voir ses enfants.
Si c'est un élément sans descendants : si c'est la première fois que ce type d'élément est découvert, on le sauvegarde avec sa valeur. Autrement on l'ignore et on continue.

Donc je dirai que je dois quand même parcourir tout le fichier et ne jamais sauter d'éléments si je veux être sur d'avoir un listing de toutes les balises présentes.
Je dois par contre stocker qu'une seule donnée par type de balise et il n'est donc pas nécessaire de décoder et charger en mémoire toutes les valeurs.

En fait, les fichiers XML devraient être assez simple mais par défaut je ne suis pas censé savoir à quoi ils ressemblereront.
J'aimerais justement pouvoir analyser n'importe quel fichier XML rapidement et afficher la structure globale pour savoir toutes les balises présentes, en gardant la cohérence au niveau des imbrications.

Je vais peut être m'orienter vers ElementTree.iterparse alors.
Et stocker dans une liste les éléments ?
Du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
["racine", 
             ("info", "liste de bouteilles"), 
             ["bouteille", ("type", "eau"), ("marque","vittel"), ("volume",0.75)] 
]

Ou ça fait usine à gaz et j'aurais du mal a parcourir ça par la suite....

Par contre, pour garder l'information de l'arborescence, je me demande si ca ne va pas etre compliqué parce que chaque élément renvoyé par iterparse ne contient pas cette info je crois...

Bref, je me demande si finalement manipuler un etree ne serait pas plus simple, tant pis si j'ai des valeurs qui ne servent à rien dans la mémoire.

Vous en dites quoi ?

Merci
Michael

[plxpy]

Comme je m'en doutais, il va donc falloir tout regarder et ne faire aucune impasse. L'apport d'une méthode SAX par rapport à une méthode DOM est uniquement le fait qu'on ne charge pas tout le fichier d'un coup.

J'ai un peu joué avec iterparse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
>>> from pprint import pprint as pp
>>> from xml.etree.ElementTree import iterparse
>>>
>>> def do_it(current,iterateur):
	sequence = [(current.tag,current.text.strip())]
	for event, elem in iterateur:
		if event == 'end' and elem.tag == current.tag:
			return sequence
		elif event == 'start':
			sequence.append((elem.tag,elem.text.strip()))
>>>
>>> iterateur = iterparse('bouteilles.xml',('start','end'))
>>> racine = False
>>>
>>> for event,elem in iterateur:
	if racine == False:
		racine = True
	elif event == 'start':
		sequence = do_it(elem,iterateur)
		print "nouvelle sequence :",
		pp(sequence)
 
 
nouvelle sequence :[('info', 'Liste de bouteilles')]
 nouvelle sequence :[('bouteille', ''), ('type', 'eau'), ('marque', 'vittel')]
 nouvelle sequence :[('bouteille', ''),
 ('type', 'alcool'),
 ('marque', 'martini'),
 ('volume', '0.75')]
 nouvelle sequence :[('bouteille', ''), ('type', 'eau'), ('marque', 'evian')]
>>>

Après, faut gérer les séquences trouvées, "fusionner" les séquences semblables, y mettre (peut-être) de la récursivité, ...

[pacificator]

Bonjour,

il n'y a pas de DTD fournie avec le xml?

[plxpy]

il n'y a pas de DTD fournie avec le xml?

C'est vrai qu'avec une DTD, ou mieux (?) un schéma XML, on serait guidé pour aller piocher les exemples de valeurs, sans y aller "à tâtons", avec l'obligation de tout parcourir.

Mais beaucoup de fichiers XML sont uniquement bien formés (un minimum !), sans indication particulière concernant leur structure.

Sans autre information, ce que cherche à écrire italiasky est un "schéma XML du pauvre". C'est juste une expression et pas du tout péjoratif : la fusion des différentes branches semblables n'est pas évidente du tout quand on veut être exhaustif (et les attributs n'ont pas été évoqués !)

Mais c'est vrai que c'est une bonne idée de se servir d'une DTD/d'un schéma.