Fusion de fichiers XML - utilisation des handlers (XML::Twig) ?

Version imprimable

09/06/2010, 09h50
japanatome

Fusion de fichiers XML - utilisation des handlers (XML::Twig) ?

(Edit : Je me suis trompé, ce sujet serait mieux dans /Modules plutôt qu'ici. Si quelqu'un pouvait déplacer ce sujet... Merci d'avance !)

Bonjour,

récemment j'ai créé un topic qui traitait de la transformation des balises XML, et j'ai été bien aidé, alors je me permet un autre sujet.

Je vais essayer d'être clair immédiatement cette fois-ci :mouarf:

Sujet :
Fusionner des fichiers XML possédant la même structure
(racine : volume
fils : entry (+ sous éléments))

Problématique :
Les fichiers xml sont ici très gros (entre 10 et 100 mo, entre 15 000 et 100 000 éléments <entry>).
Il s'agit donc d'utiliser les handlers de XML::Twig (ou de proposer un autre module plus efficace dans ce cas-ci).
On pourrait par exemple avancer entrée par entrée comme suit :

1) si entry-fichier1 = entry-fichier2
on insère certains fils de entry-fichier2 dans entry-fichier1

2) si entry-fichier1 est inférieur (lexicographiquement) à entry-fichier2
on passe à l'entry suivant du fichier1, on ne change pas entry-fichier2 (et on ne fait rien d'autre).

3) si entry-fichier1 est supérieur (lexicographiquement) à entry-fichier1 (ce qui arrivera rarement), on ajoute entry-fichier2 en entier avant entry-fichier1, et on passe à l'entry suivant pour les deux fichiers.

Sujet proche sur le forum :
Une fusion de fichiers XML mais "à la Dom" (on charge tout en mémoire). Ici on voudrait une fusion "à la Sax" (avec donc les handlers).
J'ai une version sans handler (issu du sujet en référence au-dessus), mais qui ne fonctionne pas (ou alors il faudrait que je laisse tourner ma machine toute une nuit...je n'ai pas essayé).

Je cherche juste à avoir des pistes, pas forcément un code (ou alors juste un bout :mrgreen:), parce que ça m'a l'air costaud à faire quand même.

Le plus difficile pour moi est le point 2) et 3), plus particulièrement d'avancer entrée par entrée dans deux fichiers à la fois.

J'espère avoir été clair, comme je suis dans le flou, il se peut que mes explications s'en ressentent.

(Pour indication :
La transformation que j'ai adaptée du code de Djibrill, en DOM, prend entre 40min et 3heures pour mes sources. en SAX, avec un handler qui porte sur entry, je ne dépasse pas 2minutes.
D'où mon envie de faire pareil ici !)

Si vous avez vu des sujets similaires, un bouquin qui en parle, ou même que vous avez bossé sur quelque chose de proche, n'hésitez pas ! Même une idée tout simple peut m'aider.
Sur le site officiel de Xml::Twig ou sur CPAN je n'ai trouvé aucune indication pour une telle application.

Si jamais ce sujet me permet de réaliser quelque chose qui fonctionne, je mettrai le code, je pense que ça peut servir. Je commence de mon côté à tester comment faire.
09/06/2010, 10h05
Philou67430

As-tu regardé du coté du module XML::Merge ?
09/06/2010, 10h28
japanatome

Oui, c'est un module intéressant, mais soit j'ai loupé mon test, soit il est également très long (au bout de 4h j'ai arrêté l'exécution).

Je vais quand même tester à nouveau, on ne sait jamais. Parce qu'il n'y a pas de grosses difficultés dans les éléments à copier, enfin je ne pense pas.

Je vais lancer quelques tests sur des fichiers plus petits de même structure puis sur les plus gros, et je vous donne la réponse (qui sera justifiée cette fois-ci).
09/06/2010, 11h59
japanatome
Les tests sont finis !!

En effet XML::Merge fonctionne très bien pour des fichiers pas trop gros, dès que je suis passé sur les gros fichiers :

Out of memory !!

Par contre, peut être que tu confirmeras Philou, mais ce serait une bonne solution d'utiliser Xml::Twig et Xml::Merge non ?

Le problème des handlers persiste, mais peut être que j'avancerai mieux en utilisant les deux. Je vais tâtonner.

Je met le petit bout de code relatif à Xml::Merge :
Code:

1 2 3 4 5 6 7 8 use Xml::Merge; my $merge_obj = XML::Merge->new( 'filename' => $FichierOne, ); $merge_obj->merge('filename' => $FichierTwo); $merge_obj->write($FichierResultat);
P.S. : il est incomplet, n'oubliez pas de définir vos variables !
09/06/2010, 12h14
Philou67430

Effectivement, XML::Merge intègre un parser DOM-like, et non pas SAX-like. De fait, il charge tout l'arbre des nœuds pour chaque fichier XML.

Il te reste donc l'implémentation que tu as proposé à l'aide de XML::Twig. Mais je ne maitrise pas ce module.
09/06/2010, 13h02
djibril

Citation:

Envoyé par japanatome

(Pour indication :
La transformation que j'ai adaptée du code de Djibrill, en DOM, prend entre 40min et 3heures pour mes sources. en SAX, avec un handler qui porte sur entry, je ne dépasse pas 2minutes.
D'où mon envie de faire pareil ici !)

Quand tu dis en sax, ça veut dire en utlisant XML::Twig avec les twig_handler, c'est bien ça ? Car le code que je t'ai filé fais effectivement du DOM mais si tu l'as adapté, c'est sûr qu'il sera plus rapide. De 3h à 2min, ça change tout :mouarf:. D'ailleurs, pourrais tu nous le montrer ?

Pour ta nouvelle problématique, rien ne vaut plus qu'un exemple concret. Montre nous 2 petits fichiers XML à fusionner et le fichier résultat XML que tu souhaiterais obtenir. C'est le moyen le plus simple pour que tout le monde se fasse une idée précise de ton souci et se plonge dans le code pour t'aider.
09/06/2010, 13h26
japanatome

Euh oui Djibril, je n'emploie pas forcément un vocabulaire strict (je fais du "Perl intuitif" :aie:), mais ta méthode chargeait tout en mémoire (pour moi c'est du DOM) et quand on utilise les handler de twig, on passe en SAX. Quand j'ai vu que pour une des sources (96 000 éléments <entry>), prenait près de 3heures, je suis passé par un handler pour purger la mémoire.

J'indiquerai ce nouveau code sans problème, dans le sujet précédent sur la transformation, que je met en lien ici pour ceux qui sont intéressés et qui ne l'ont pas vu :

Utilisation des tables de hachage, transformation XML avec Twig

Et pour ce sujet-ci je vais vous préparer les p'tits codes.
Si j'ai un début de quelque chose, je le mettrai aussi.

Je ferai tout ça d'ici ce soir.

Merci d'avance pour vos réponses !
09/06/2010, 13h32
djibril

Citation:

Envoyé par japanatome

Euh oui Djibril, je n'emploie pas forcément un vocabulaire strict (je fais du "Perl intuitif" :aie:), mais ta méthode chargeait tout en mémoire (pour moi c'est du DOM) et quand on utilise les handler de twig, on passe en SAX. Quand j'ai vu que pour une des sources (96 000 éléments <entry>), prenait près de 3heures, je suis passé par un handler pour purger la mémoire.

J'indiquerai ce nouveau code sans problème, dans le sujet précédent sur la transformation, que je met en lien ici pour ceux qui sont intéressés et qui ne l'ont pas vu :

Utilisation des tables de hachage, transformation XML avec Twig

Et pour ce sujet-ci je vais vous préparer les p'tits codes.
Si j'ai un début de quelque chose, je le mettrai aussi.

Je ferai tout ça d'ici ce soir.

Merci d'avance pour vos réponses !

C'était juste pour confirmer qu'on parle bien de la même chose. Effectivement la méthode handler de twig permet de ne mettre en mémoire que des portions de XML. J'en parle d'ailleurs dans cette article.

Nous attendons donc tes fichiers et codes.

Ne t'inquiètes pas Djibril, tes articles, ou indications, ou même critiques de livres, on été lus :mouarf:

Mais ça veut pas dire que je les utilise correctement après. Malheureusement, c'est en forgeant qu'on devient forgeron, et apparemment je n'ai pas encore assez forgé :aie:.

Mais j'en apprend tous les jours. Dernièrement c'est la gestion des arguments par Getopt::Long. Après il y a eu aussi la barre de progression (j'aime bien la partie code source).
J'ai eu une période Interface TK aussi (mais là à part faire du copier/coller.... mais j'y reviendrai !)

Enfin bref, mon truc du moment, c'est le Xml, et après avoir transformé, j'aimerais fusionner.

Voici donc les codes :

Fichier1.xml :

Code:

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
32
33
<?xml version="1.0" encoding="UTF-8"?>
 
<volume name="Morphalou" source-langage="fra" creation-date="Tue Jun  8 14:43:16 2010">
   <entry id="a">
      <head>
         <headword>a</headword>
         <pronunciation></pronunciation>
         <pos>s.</pos>
      </head>
   </entry>
   <entry id="a b c">
      <head>
         <headword>a b c</headword>
         <pronunciation></pronunciation>
         <pos>s.</pos>
      </head>
   </entry>
   <entry id="a-humain">
      <head>
         <headword>a-humain</headword>
         <pronunciation></pronunciation>
         <pos>adj.</pos>
      </head>
   </entry>
 
   <entry id="abaisser">
      <head>
         <headword>abaisser</headword>
         <pronunciation></pronunciation>
         <pos>v.</pos>
      </head>
   </entry>
</volume>

Fichier2.xml :

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
<?xml version="1.0" encoding="UTF-8"?>
<volume>
  <entry id="a">
    <head>
      <headword>a</headword>
      <pronunciation></pronunciation>
      <pos></pos>
    </head>
    <sense id="s1">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>mẫu tự đầu tiên và nguyên âm đầu tiên trong bảng chữ cái</translation>
      </translations>
      <examples>
        <example>a majuscule (A)</example>
        <example>a minuscule (a)</example>
      </examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>danh từ giống đực ( không đổi)</m:else>
      </else2>
    </sense>
    <sense id="s2">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>nốt nhạc la (thuật ngữ (âm nhạc) thuộc Anglo-Saxon và Đức)</translation>
        <translation>a (sào)</translation>
        <translation>ampe</translation>
        <translation>angström</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>viết tắt và ký hiệu của:</m:else>
      </else2>
    </sense>
    <sense id="s3">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>thành phần lấy từ tiếng Latinh, để chỉ hướng, đích đến, hoặc từ trạng thái này sang trạng thái khác Amener,  alunir,  adoucir</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>tiếp đầu ngữ</m:else>
      </else2>
    </sense>
  </entry>
  <entry id="abaca">
    <head>
      <headword>abaca</headword>
      <pronunciation></pronunciation>
      <pos></pos>
    </head>
    <sense id="s1">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>một loại chuối ở Philipine, vỏ dùng để dệt.</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>danh từ giống đực</m:else>
      </else2>
    </sense>
  </entry>
  <entry id="abacule">
    <head>
      <headword>abacule</headword>
      <pronunciation></pronunciation>
      <pos></pos>
    </head>
    <sense id="s1">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>hình khối nhỏ tạo nên thành phần của một hình khảm.</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>danh từ giống đực</m:else>
      </else2>
    </sense>
  </entry>
</volume>

Je donne les objectifs suivants (ils ont un peu changé) :

1) si entry-fichier1 = entry-fichier2 (je travaille au niveau des id, mais le headword marche aussi)
=> on insère les éléments <sense> de fichier2, on passe aux entry suivants pour les deux fichiers.

2) si entry-fichier1 est lexicographiquement (selon l'ordre alphabétique) inférieur (avant) entry-fichier2, alors
=> on passe à entry-fichier1 suivant, on n'ajoute rien.

3) si entry-fichier1 est lexicographiquement supérieur (après) entry-fichier2, alors
=> on passe à entry-fichier2 suivant, on n'ajoute rien.

Le cas 3) ne se présente pas dans l'exemple, pour ma part je ne le traite pas pour le moment, je me focalise sur les deux premiers cas. J'ajouterai le 3ème ensuite.

Résultat :

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
<?xml version="1.0" encoding="UTF-8"?>
 
<volume name="Morphalou" source-langage="fra" creation-date="Tue Jun  8 14:43:16 2010">
   <entry id="a">
      <head>
         <headword>a</headword>
         <pronunciation></pronunciation>
         <pos>s.</pos>
      </head>
      <sense id="s1">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>mẫu tự đầu tiên và nguyên âm đầu tiên trong bảng chữ cái</translation>
      </translations>
      <examples>
        <example>a majuscule (A)</example>
        <example>a minuscule (a)</example>
      </examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>danh từ giống đực ( không đổi)</m:else>
      </else2>
    </sense>
    <sense id="s2">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>nốt nhạc la (thuật ngữ (âm nhạc) thuộc Anglo-Saxon và Đức)</translation>
        <translation>a (sào)</translation>
        <translation>ampe</translation>
        <translation>angström</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>viết tắt và ký hiệu của:</m:else>
      </else2>
    </sense>
    <sense id="s3">
      <definition>
        <label></label>
        <formula></formula>
      </definition>
      <gloss></gloss>
      <translations>
        <translation>thành phần lấy từ tiếng Latinh, để chỉ hướng, đích đến, hoặc từ trạng thái này sang trạng thái khác Amener,  alunir,  adoucir</translation>
      </translations>
      <examples></examples>
      <idioms></idioms>
      <else1></else1>
      <else2>
        <m:else>tiếp đầu ngữ</m:else>
      </else2>
    </sense>
    </entry>
   <entry id="a b c">
      <head>
         <headword>a b c</headword>
         <pronunciation></pronunciation>
         <pos>s.</pos>
      </head>
   </entry>
   <entry id="a-humain">
      <head>
         <headword>a-humain</headword>
         <pronunciation></pronunciation>
         <pos>adj.</pos>
      </head>
   </entry>
 
   <entry id="abaisser">
      <head>
         <headword>abaisser</headword>
         <pronunciation></pronunciation>
         <pos>v.</pos>
      </head>
   </entry>
</volume>

J'essaie pour l'instant de faire quelque chose en associant Xml::Twig et Xml::Merge.

12/06/2010, 14h51
japanatome

Proposition personnelle.

:cry::cry::cry::cry::cry:

J'ai laissé tombé Xml::Merge pour le moment.

Je tente cette idée :

(1) je modifie le caractère de fin de ligne avec $/ (j'indique la balise fermante de l'élément 'entry').

(2) avec un while tant que j'ai des lignes dans le fichier 1 OU dans le fichier 2,
je compare les entrées et je procède selon les indications que j'avais données dans mes messages précédents.

Quand on écrit quelque chose comme ça :

Code:

$line = <IN> ;

Seule la première ligne est chargée, ou alors il parcours tout le fichier ? Parce que si il fait tout le fichier, puis il me donne la première ligne, c'est comme si je faisais du DOM, et donc je ne réduit pas l'utilisation de la mémoire...
12/06/2010, 16h42
japanatome

J'ai une question un peu bête, peut être que les experts du forum pourront me répondre.

Dans ce que je suis en train de faire (désolé de ne pas encore le montrer, mais le code ne donne pas de résultats :aie:), je lis donc ligne par ligne mon fichier source (enfin j'essaie XD).
Bon ensuite j'essaie d'introduire le parsing de l'entrée que je garde. C'est là que je coince, le parsing est fait, mais je récupère un XML::Twig=HASH qui se transforme en un magnifique 0 (je suppose pour false), juste après que je sorte de ma subroutine.

Bon ce problème n'est pas ma question. Ce que je me demandais, c'est vu que je récupère mon élément entry correctement avec $line = <IN>, pourquoi ne pas tout faire avec des expressions régulières ?

Parce que là je commence à vraiment ne plus avoir d'idée.
13/06/2010, 18h54
Philou67430

Citation:

Envoyé par japanatome

Quand on écrit quelque chose comme ça :

Code:

$line = <IN> ;

Seule la première ligne est chargée, ou alors il parcours tout le fichier ? Parce que si il fait tout le fichier, puis il me donne la première ligne, c'est comme si je faisais du DOM, et donc je ne réduit pas l'utilisation de la mémoire...

Seule la ligne "courante" est lue, jusqu'au prochain délimiteur de ligne défini dans $/

Citation:

Envoyé par japanatome

Bon ensuite j'essaie d'introduire le parsing de l'entrée que je garde. C'est là que je coince, le parsing est fait, mais je récupère un XML::Twig=HASH qui se transforme en un magnifique 0 (je suppose pour false), juste après que je sorte de ma subroutine.

Montre le code de ta subroutine (fonction) et comment tu l'appelles.

Citation:

Ce que je me demandais, c'est vu que je récupère mon élément entry correctement avec $line = <IN>, pourquoi ne pas tout faire avec des expressions régulières ?

Je doute que tu puisses récupérer le contenu de tes entry ainsi... ta ligne contiendra plus que le contenu de l'entry... il faudra nettoyer.
13/06/2010, 23h54
japanatome

Je te réponds Philou sur la récupération de mes entrées.

Il y a deux manières d'avoir une entrée nickel chrome selon moi, et si jamais c'est incorrect, fais le moi savoir, mon erreur vient peut être de ça.

1) une entrée par ligne (début : <entry>.... jusque fin </entry>). Quand on ne choisit pas l'indentation dans Twig, c'est quelque chose que l'on peut avoir. Il y a juste la première entrée qui a besoin de nettoyage (puisque devant il y a l'en-tête xml), que je saute tranquillement en enlevant l'en-tête.

2) en redéfinissant $/ qui a par défaut le marqueur de fin de ligne.
je pose $/ = </entry>, et hop le tour est joué. Même si mon entrée est sur plusieurs lignes, aucun problème avec cette méthode.

J'ai essayé les deux, avec plus ou moins de résultat. Plus j'avançais, moins ce que j'obtenais était bon :aie:.

Je commence à baisser les bras. En fait le problème à résoudre, c'est cette méthode du parcours ligne par ligne (avec nettoyage comme le signale Philou, je pars du principe qu'il a raison :mouarf:).
Le souci est que je fais un while <IN1> et en même temps un while <IN2>, et ça génère n'importe quoi.

Ma question est donc : perl ne peut pas suivre la lecture ligne à ligne de deux fichiers simultanément ? Si il en est capable, comment faire ?

Cette question est une petite mise en bouche pour le lundi matin. Mais dans tous les cas, demain j'indique mon code, qui ne fonctionne pas, mais qui pourra peut être faire avancer ce sujet. J'aimerai vraiment trouver la solution, ça m'éviterait de diviser en plusieurs fichiers xml mes sources, pour les fusionner à la DOM 500 fois.... Un bon SAX à plein régime, y a que ça de vrai.

En tout cas merci de répondre, c'est sympa, j'y gagne en rigueur. à demain pour mon code.
14/06/2010, 09h20
Philou67430

OK... je vais être plus précis dans mes explications : utiliser $/ pour délimiter des éléments XML n'est pas une méthode correcte dans un cas général. Il est possible que le cas particulier où (quasiment) seuls des éléments <entry> sont présent, le nettoyage soit facile. Mais la méthode n'est pas applicable de manière générale.

Sinon, perl sais parfaitement lire plusieurs fichiers en même temps. J'avais aussi développé un mergeur il y a fort longtemps déjà (dont je n'ai pas les sources ici), qui traitait des fichiers de traces de protocoles de commutation avec des timestamps à synchroniser. J'utilisais un algorithme similaire. Je pense que ton défaut se situe dans ta fonction de merge. J'attends donc que tu la postes pour t'en dire plus.
As-tu essayé de débugger avec perl -d ?

Euh Philou, quand je te lis, je me dis que j'ai encore énormément à apprendre en perl.... parce que j'ai jamais débuggé, et j'ai l'impression de faire des programmes "bordel", en oubliant de vérifier des points importants... ça viendra avec le temps ! :mouarf:

Je donne donc le code que j'ai, dernière version :cry:. Qui ne marche pas, j'ai l'en-tête (avec Xml::Writer) qui s'inscrit bien dans le fichier de sortie. Par contre la fermeture (encore avec Xml::Writer) n'a pas fonctionné, je trouve ça très bizarre, puisque ça ne dépend pas de la boucle while..... C'est peut être un indice !

J'ai laissé les commentaires, le choix des options, et le mode "verbeux", qui affiche des messages dans STDERR. ça me permet de voir si ça avance. Pour les subroutines, elles sont à la fin. Je les ai séparées :

1) d'abord celle sur source1.xml
2) puis celle sur source2.xml
3) la fusion
4) et enfin celles pour l'aide et les informations.

En commande on peut mettre ça :

perl Fusion.pl -v -from source1.xml -and source2.xml -to out.xml

(le -v : active le mode verbeux).

Les autres options n'ont pas d'intérêts pour le test (la langue, le pretty_print, ...)

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
#!/usr/bin/perl
 
# =======================================================================================================================================
###--- METADIRECTIVES ---###
 
use strict;
use warnings;
use utf8;
use IO::File; 
use Getopt::Long; # pour gérer les arguments.
 
use XML::Twig; # (non inclus dans le core de Perl), pour le parsing de la source.
use XML::Writer; # (non inclus dans le core de Perl), pour le fichier de sortie.
 
 
# =======================================================================================================================================
###--- PROLOGUE ---###
 
my $ref_root = 'volume'; # la racine (par exemple : <volume> ou <dictionary>).
my $ref_entry = 'entry'; # l'élément dans la source qui correspond avec <m:entry> dans MAM.
my $ref_headword = 'headword';
my $ref_sense = 'sense'; # idem pour l'élément <sense> dans MAM.
 
# ------------------------------------------------------------------------
##-- Gestion des options --##
 
my ($date, $FichierOne, $FichierTwo, $FichierResultat, $erreur, $encoding) = ();
my ($verbeux, $help, $pretty_print, $langue) = ();
GetOptions( 
  'date|time|t=s'        	    => \$date, # flag de type -date ou --date, ou -time ou --time, ou -t ou --t (=s : string)
  'source|base|in|one|from|i=s' => \$FichierOne, 
  'add|and|two|j=s'        		=> \$FichierTwo,
  'sortie|out|to|o=s'           => \$FichierResultat, 
  'erreur|error|e=s'     	  	=> \$erreur, 
  'encodage|encoding|enc|f=s' 	=> \$encoding, 
  'help|h'                	  	=> \$help, 
  'verbeux|v'             	  	=> \$verbeux, 
  'print|pretty|p=s'       	  	=> \$pretty_print, 
  'langue|lang|l=s'				=> \$langue,
  );
 
if (!( defined $date ))
	{
	$date = localtime;
	};
if (!( defined $FichierOne ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierTwo ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierResultat ))
	{
	$FichierResultat = "toto.xml" ;
	};
if (!( defined $erreur ))
	{
	$erreur = "|ERROR| : problem opening file :";
	};
if (!( defined $encoding ))
	{
	$encoding = "UTF-8"; 
	};
if (!( defined $pretty_print ))
	{
	$pretty_print = "none"; 
	};
if (!( defined $langue ))
	{
	$langue = "XX"; 
	};
if ( defined $help )
	{
	&help;
	};
 
# ------------------------------------------------------------------------
# Autres variables :
 
my $stop_one = 0; # variable pour simuler la fin des entrées.
my $stop_two = 0;
my $count_one = 0;
my $count_two = 0;
 
# ------------------------------------------------------------------------
# Input/ Output
 
open (FILEONE, "<:encoding($encoding)", $FichierOne) or die ("$erreur $!\n");
open (FILETWO, "<:encoding($encoding)", $FichierTwo) or die ("$erreur $!\n");
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('a'); 
	};
# message dans le STDERR (voir subroutine 'info') indiquant le démarrage du programme.
 
# ------------------------------------------------------------------------
##-- Début de l'écriture --##
 
my $output = new IO::File(">$FichierResultat");
my $writer = new XML::Writer(
  OUTPUT      => $output,
  DATA_INDENT => 3,         # indentation, 3 espaces
  DATA_MODE   => 1,         # changement ligne.
  ENCODING    => $encoding,
);
$writer->xmlDecl($encoding);
 
$writer->startTag
	(
  "m:volume",
  'name'              => "NAME",
  'source-language'   => $langue,
  'creation-date'     => $date,
	);
 
# =======================================================================================================================================
###--- PREPARATION ---###
 
my $twig_one = XML::Twig->new
(
output_encoding => $encoding, # on reste en utf8
pretty_print    => $pretty_print, # par défaut le style est 'none'
twig_roots      => {'entry' => 1}, 
Twig_handlers   => {'entry' => \&twig_base,}, 
); 
 
# ------------------------------------------------------------------------
 
my $twig_two= XML::Twig->new
(
output_encoding => $encoding, 
pretty_print    => $pretty_print,
twig_roots      => {'entry' => 1},
Twig_handlers   => {'entry' => \&twig_ajout,}, 
); 
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('b'); 
	};
 
# ------------------------------------------------------------------------
 
my $entry_one = &one_suivant; # obtenir la première entrée de la source 1.
my $entry_two = &two_suivant; # obtenir la première entrée de la source 2.
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('c'); 
	};
 
# =======================================================================================================================================
###--- ALGORITHME DE LA FUSION ---###
 
# Après avoir récupéré la ou les entrées (sub one_suivant et two_suivant), on les compare.
# On écrit dans le fichier de sortie selon la comparaison.
while (($entry_one ne "0") || ($entry_two ne "0")) 
# Le traitement continuera tant qu'il y a des entrées dans l'une ou l'autre source.
	{
if ( defined $verbeux )	{print (STDERR "In progress\n");};
	if ($entry_one ne "0")
		{
		my $headword_one = $entry_one -> findnodes ("headword")->text;
if ( defined $verbeux )	{print (STDERR "$FichierOne : entrée [$headword_one]\n");};
		if ($entry_two ne "0")
			{
			my $headword_two = $entry_two -> findnodes ("headword")->text;
if ( defined $verbeux )	{print (STDERR "$FichierTwo : entrée [$headword_two]\n");};
			# On compare les deux headword 'lexicographiquement' :
			# 1) si l'entrée 1 est inférieure à l'entrée 2 :
# On écrit l'entrée 1 dans le fichier de sortie.
# On avance d'une entrée dans le fichier 1
			if ($headword_one lt $headword_two)
				{
				$entry_one->print_to_file ($FichierResultat);
				$entry_one = 0; # pour avoir l'entrée suivante dans le fichier 1.
				}
			# 2) si l'entrée 1 est supérieure à l'entrée 2 :
# On écrit l'entrée 2 dans le fichier de sortie.
# On avance d'une entrée dans le fichier 2.
			elsif ($headword_one gt $headword_two)
				{
				$entry_two->print_to_file ($FichierResultat);
				$entry_two = 0; # pour avoir l'entrée suivante dans le fichier 2.
				}
			# 3) le dernier cas : entrée 1 = entrée 2 :
# On ajoute les éléments de entrée 2 dans entrée 1, qu'on écrit dans le fichier de sortie.
# On avance d'une entrée dans le fichier 1 et dans le fichier 2.
			else
				{
				&fusion ($entry_one, $entry_two);
				$entry_one->print_to_file($FichierResultat);
				$entry_one = 0;
				$entry_two = 0;
				}
			}
		else # si on a pas d'entrée 2 : ajout terminé, on écrit les entrées 1
			{
			$entry_one->print_to_file($FichierResultat);
			$entry_one = 0;
			}
		}
	elsif ($entry_two) # si pas d'entrée 1 mais entrée 2, on ajoute entrée 2.
		{
		$entry_two->print_to_file($FichierResultat);
		$entry_two = 0;
		}
	# le traitement est terminé, pour récupérer la ou les entrées suivantes, on relance les subroutines.
	$entry_one = &one_suivant; 
	$entry_two = &two_suivant; 
	};
 
# ------------------------------------------------------------------------	
# Fin de l'écriture :
 
$writer->endTag("m:volume");
$output->close();
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('d'); 
	};
 
# =======================================================================================================================================
###--- SUBROUTINES ---###
 
sub one_suivant
{
my $base_xml_header;
if ((!$entry_one) && (!$stop_one))
	{
	$/ = "</entry>";
	my $entry = <FILEONE>;
	if ($entry =~ /<entry>/)
		{
		if (my $match = $entry =~ /^.*<entry/sm)
			{
			$entry =~ s/^(.*)<entry>/<entry>/sm;
			}
			$count_one++;
			$entry_one = $twig_one->parse($entry);
			$twig_one->purge;
		}
	else 
		{
		$stop_one = 1;
		$entry_one = 0;
		}
	}	
return $entry_one;
}
 
sub twig_base 
{
my ($temp, $entry_one) = @_ ;
$twig_one->purge;
return ($entry_one);
}
 
# ------------------------------------------------------------------------
 
sub two_suivant 
	{
	my $add_xml_header;
	if ((!$entry_two) && (!$stop_two)) 
		{
		$/ = "</entry>";
		my $entry=<FILETWO>;
		if ($entry =~ /<entry>/) 
			{
			if (my $match = $entry =~  /^.*<entry/sm) 
				{
				$entry =~ s/^(.*)<entry>/<entry>/sm;
				}
			$entry_two = $twig_two->parse($entry);
			$twig_two->purge;
			}
		else 
			{
			$stop_two = 1;
			$entry_two = 0;
			}
		}	
return $entry_two;
	}
 
sub twig_ajout
{
my ($temp, $entry_two) = @_ ;
$twig_one->purge;
return ($entry_two);
}
# ------------------------------------------------------------------------
 
sub fusion
{
my $entry_one = shift @_;
my $entry_two = shift @_;
 
foreach my $sense_two ($entry_two->findnodes('sense'))
	{
	$sense_two->copy;
	$sense_two->paste('after'=>$entry_one->last_child('sense'));
	}
return ($entry_one);
}
 
# ------------------------------------------------------------------------
 
sub info
{
my $info = shift @_;
if ($info =~ 'a')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "\t~~~~ $0 : START ~~~~\n");
	print (STDERR "================================================================================\n");
	}
elsif ($info=~ 'b')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "en-tete du fichier de sortie effective\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info=~ 'c')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "lancement du processus de fusion\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info =~ 'd')
	{
	print (STDERR "~~~~ $0 : END ~~~~\n");
	print (STDERR "================================================================================\n");
	my $time = times ;
	my $FichierLog = 'LOG.txt';
	open(my $FiLo, ">>:encoding($encoding)", $FichierLog) or die ("$erreur $!\n");
	print {$FiLo}
	"==================================================\n",
	"RAPPORT : ~~~~ $0 ~~~~\n",
	"--------------------------------------------------\n",
	"Fichier source : $FichierOne\n",
	"--------------------------------------------------\n",
	"Fichier final : $FichierResultat\n",
	"--------------------------------------------------\n",
	"Date du traitement : ", $date, "\n",
	"--------------------------------------------------\n",
	"Lapsed time : ", $time, " s\n",
	"==================================================\n";
	}
}
 
 
sub help 
{
print (STDERR "================================================================================\n");  
print (STDERR "HELP\n");
print (STDERR "================================================================================\n");
print (STDERR "usage : $0 -i <sourcefile.xml> -o <outfile.xml>\n\n") ;
print (STDERR "options : -h affichage de l'aide\n") ;
print (STDERR "          -e le message d'erreur (ouverture de fichiers)\n") ;
print (STDERR "          -f le format d'encodage\n");
print (STDERR "          -v mode verbeux (STDERR et LOG)\n");
print (STDERR "          -t pour la gestion de la date (initialement : localtime)\n");
print (STDERR "================================================================================\n");
}
 
 
# =======================================================================================================================================
1 ;

Je sens que mon idée n'est pas mauvaise, il me manque un Philou pour me barrer de rouge les erreurs et que ça tourne enfin :ccool:

14/06/2010, 13h31
Philou67430

Programme un peu long... réponse un peu temporisée :)
14/06/2010, 13h53
japanatome

ah autant pour moi, je n'avais pas compris.

J'utilise quand même $/, regarde du côté des subroutines, one_suivant et two_suivant. Je n'utilise twig qu'à la fin des sub.

Mais si vraiment l'utilisation du twig t'embête, je dois avoir garder la version sans, je peux la mettre si tu veux. Par contre elle est moins fiable que celle-ci je pense.
14/06/2010, 17h02
japanatome

Je n'ai plus le fichier que tu voulais voir.

Mais à ce propos j'ai une question, Philou. Si je me lance dans un version sans Xml::Twig, à grand renforts d'expressions régulières (puisque la fusion en elle-même n'est pas si compliquée), tu accepterais de corriger une telle version ?

évidemment avec un maximum de travail pour te proposer quelque chose de cohérent, mais je suis pas certain d'y parvenir, les expressions régulières ne me donnent jamais ce que je veux :aie:

Il y a un premier bug dans l'utilisation de la regexp /^.*<entry>/ (les éléments contenant des paramètres id, le tag n'est pas fermé immédiatement après entry).

Ensuite, tu as défini beaucoup (trop) de variables globales, et des fonctions spécifiques pour chaque fichier, ce qui n'est pas très judicieux. J'ai donc commencé à remanier un peu ton script, en :
- factorisant suivant one_suivant() et two_suivant() en next_entry (désolé, je suis passé à l'anglais en même temps, j'ai pas fait attention).
- supprimé les variables $stop qui me semblent redondantes
- remplacé la condition de lecture dans next_entry par une condition de lecture dans le fichier, et externalisé vers l'appelant la condition d'avancement dans le fichier : c'est en effet plus logique de conserver cette condition dans l'algorithme de fusion que de le descendre dans la fonction de lecture et d'extraction
- remplacé la condition d'avancement dans un fichier : à la place de l'usage de la valeur logique 0 (qui signifiait à la fois fin de fichier pour la fonction one/two_suivant, et pas d'avancement dans l'algorithme de fusion) j'ai utilisé la valeur "undef" lorsqu'il faut avancer dans le fichier (il faut définir à nouveau la valeur courante).

Le script devrait sans doute être encore simplifié, mais cette version devrait mieux répondre à ta problématique. Cependant, une fois la correction du bug identifié au début, le script "plante" lors de la recherche du noeud headword (en fait, la recherche échoue, donc l'appel à la méthode text échoue sur un objet non défini).
Ne sachant pas utilisé XML::Twig, je ne sais trop quoi conclure. Pourtant, la chaine fournie au parser semble correcte.

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
#!/usr/bin/perl
 
# =======================================================================================================================================
###--- METADIRECTIVES ---###
 
use strict;
use warnings;
use utf8;
use IO::File; 
use Getopt::Long; # pour gérer les arguments.
 
use XML::Twig; # (non inclus dans le core de Perl), pour le parsing de la source.
use XML::Writer; # (non inclus dans le core de Perl), pour le fichier de sortie.
 
 
# =======================================================================================================================================
###--- PROLOGUE ---###
 
my $ref_root = 'volume'; # la racine (par exemple : <volume> ou <dictionary>).
my $ref_entry = 'entry'; # l'élément dans la source qui correspond avec <m:entry> dans MAM.
my $ref_headword = 'headword';
my $ref_sense = 'sense'; # idem pour l'élément <sense> dans MAM.
 
# ------------------------------------------------------------------------
##-- Gestion des options --##
 
my ($date, $FichierOne, $FichierTwo, $FichierResultat, $erreur, $encoding) = ();
my ($verbeux, $help, $pretty_print, $langue) = ();
GetOptions( 
  'date|time|t=s'        	    => \$date, # flag de type -date ou --date, ou -time ou --time, ou -t ou --t (=s : string)
  'source|base|in|one|from|i=s' => \$FichierOne, 
  'add|and|two|j=s'        		=> \$FichierTwo,
  'sortie|out|to|o=s'           => \$FichierResultat, 
  'erreur|error|e=s'     	  	=> \$erreur, 
  'encodage|encoding|enc|f=s' 	=> \$encoding, 
  'help|h'                	  	=> \$help, 
  'verbeux|v'             	  	=> \$verbeux, 
  'print|pretty|p=s'       	  	=> \$pretty_print, 
  'langue|lang|l=s'				=> \$langue,
  );
 
if (!( defined $date ))
	{
	$date = localtime;
	};
if (!( defined $FichierOne ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierTwo ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierResultat ))
	{
	$FichierResultat = "toto.xml" ;
	};
if (!( defined $erreur ))
	{
	$erreur = "|ERROR| : problem opening file :";
	};
if (!( defined $encoding ))
	{
	$encoding = "UTF-8"; 
	};
if (!( defined $pretty_print ))
	{
	$pretty_print = "none"; 
	};
if (!( defined $langue ))
	{
	$langue = "XX"; 
	};
if ( defined $help )
	{
	&help;
	};
 
# ------------------------------------------------------------------------
# Autres variables :
 
my $count_one = 0;
my $count_two = 0;
 
# ------------------------------------------------------------------------
# Input/ Output
 
open (FILEONE, "<:encoding($encoding)", $FichierOne) or die ("$erreur $!\n");
open (FILETWO, "<:encoding($encoding)", $FichierTwo) or die ("$erreur $!\n");
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('a'); 
	};
# message dans le STDERR (voir subroutine 'info') indiquant le démarrage du programme.
 
# ------------------------------------------------------------------------
##-- Début de l'écriture --##
 
my $output = new IO::File(">$FichierResultat");
my $writer = new XML::Writer(
  OUTPUT      => $output,
  DATA_INDENT => 3,         # indentation, 3 espaces
  DATA_MODE   => 1,         # changement ligne.
  ENCODING    => $encoding,
);
$writer->xmlDecl($encoding);
 
$writer->startTag
	(
  "m:volume",
  'name'              => "NAME",
  'source-language'   => $langue,
  'creation-date'     => $date,
	);
 
# =======================================================================================================================================
###--- PREPARATION ---###
 
my $twig_one = XML::Twig
->new
(
output_encoding => $encoding, # on reste en utf8
pretty_print    => $pretty_print, # par défaut le style est 'none'
twig_roots      => {'entry' => 1}, 
Twig_handlers   => {'entry' => \&twig_base,}, 
); 
 
# ------------------------------------------------------------------------
 
my $twig_two= XML::Twig->new
(
output_encoding => $encoding, 
pretty_print    => $pretty_print,
twig_roots      => {'entry' => 1},
Twig_handlers   => {'entry' => \&twig_ajout,}, 
); 
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('b'); 
	};
 
# ------------------------------------------------------------------------
 
my $entry_one = next_entry($twig_one, *FILEONE); # obtenir la première entrée de la source 1.
my $entry_two = next_entry($twig_two, *FILETWO); # obtenir la première entrée de la source 2.
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('c'); 
	};
 
# =======================================================================================================================================
###--- ALGORITHME DE LA FUSION ---###
 
# Après avoir récupéré la ou les entrées (sub next_entry), on les compare.
# On écrit dans le fichier de sortie selon la comparaison.
while (($entry_one ne "0") || ($entry_two ne "0"))
  # Le traitement continuera tant qu'il y a des entrées dans l'une ou l'autre source.
  {
    if ( defined $verbeux )	{print (STDERR "In progress\n");};
    if ($entry_one ne "0")
      {
        my $headword_one = $entry_one -> findnodes ("headword")->text;
        if ( defined $verbeux )	{print (STDERR "$FichierOne : entrée [$headword_one]\n");};
        if ($entry_two ne "0")
          {
            my $headword_two = $entry_two -> findnodes ("headword")->text;
            if ( defined $verbeux )	{print (STDERR "$FichierTwo : entrée [$headword_two]\n");};
            # On compare les deux headword 'lexicographiquement' :
            # 1) si l'entrée 1 est inférieure à l'entrée 2 :
            # On écrit l'entrée 1 dans le fichier de sortie.
            # On avance d'une entrée dans le fichier 1
            if ($headword_one le $headword_two)
              {
                $entry_one->print_to_file($FichierResultat);
                undef $entry_one; # pour avoir l'entrée suivante dans le fichier 1.
              }
            # 2) si l'entrée 1 est supérieure à l'entrée 2 :
            # On écrit l'entrée 2 dans le fichier de sortie.
            # On avance d'une entrée dans le fichier 2.
            elsif ($headword_one gt $headword_two)
              {
                $entry_two->print_to_file ($FichierResultat);
                undef $entry_two; # pour avoir l'entrée suivante dans le fichier 2.
              }
            # 3) le dernier cas : entrée 1 = entrée 2 :
            # On ajoute les éléments de entrée 2 dans entrée 1, qu'on écrit dans le fichier de sortie.
            # On avance d'une entrée dans le fichier 1 et dans le fichier 2.
            else
              {
                fusion ($entry_one, $entry_two);
                $entry_one->print_to_file($FichierResultat);
                undef $entry_one;
                undef $entry_two;
              }
          }
        else # si on a pas d'entrée 2 : ajout terminé, on écrit les entrées 1
          {
            $entry_one->print_to_file($FichierResultat);
            undef $entry_one;
          }
      }
    elsif ($entry_two) # si pas d'entrée 1 mais entrée 2, on ajoute entrée 2.
      {
        $entry_two->print_to_file($FichierResultat);
        undef $entry_two;
      }
    # le traitement est terminé, pour récupérer la ou les entrées suivantes, on relance les subroutines.
    $entry_one = next_entry($twig_one, *FILEONE) if !defined $entry_one;
    $entry_two = next_entry($twig_two, *FILETWO) if !defined $entry_two;
  };
 
# ------------------------------------------------------------------------
# Fin de l'écriture :
 
$writer->endTag("m:volume");
$output->close();
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
  {
    &info('d');
  };
 
# =======================================================================================================================================
###--- SUBROUTINES ---###
sub next_entry {
  my ($twig, $file) = @_;
 
  my $entry;
  $/ = "</entry>";
  my $xml = <$file>;
  if ($xml && $xml =~ /<entry/) {
    if (my $match = $xml =~ /^.*<entry/sm) {
      $xml =~ s/^(.*)<entry/<entry/sm;
    }
    $count_one++; # Inutile et inutilisé (et effet de bord)
    $entry = $twig->parse($xml);
    $twig->purge;
  }
  else {
    $entry = 0;
  }
 
  return $entry;
}
 
sub twig_base 
{
my ($temp, $entry_one) = @_ ;
$twig_one->purge;
return ($entry_one);
}
 
# ------------------------------------------------------------------------
 
 
sub twig_ajout
{
my ($temp, $entry_two) = @_ ;
$twig_one->purge;
return ($entry_two);
}
# ------------------------------------------------------------------------
 
sub fusion
{
my $entry_one = shift @_;
my $entry_two = shift @_;
 
foreach my $sense_two ($entry_two->findnodes('sense'))
	{
	$sense_two->copy;
	$sense_two->paste('after'=>$entry_one->last_child('sense'));
	}
return ($entry_one);
}
 
# ------------------------------------------------------------------------
 
sub info
{
my $info = shift @_;
if ($info =~ 'a')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "\t~~~~ $0 : START ~~~~\n");
	print (STDERR "================================================================================\n");
	}
elsif ($info=~ 'b')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "en-tete du fichier de sortie effective\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info=~ 'c')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "lancement du processus de fusion\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info =~ 'd')
	{
	print (STDERR "~~~~ $0 : END ~~~~\n");
	print (STDERR "================================================================================\n");
	my $time = times ;
	my $FichierLog = 'LOG.txt';
	open(my $FiLo, ">>:encoding($encoding)", $FichierLog) or die ("$erreur $!\n");
	print {$FiLo}
	"==================================================\n",
	"RAPPORT : ~~~~ $0 ~~~~\n",
	"--------------------------------------------------\n",
	"Fichier source : $FichierOne\n",
	"--------------------------------------------------\n",
	"Fichier final : $FichierResultat\n",
	"--------------------------------------------------\n",
	"Date du traitement : ", $date, "\n",
	"--------------------------------------------------\n",
	"Lapsed time : ", $time, " s\n",
	"==================================================\n";
	}
}
 
 
sub help 
{
print (STDERR "================================================================================\n");  
print (STDERR "HELP\n");
print (STDERR "================================================================================\n");
print (STDERR "usage : $0 -i <sourcefile.xml> -o <outfile.xml>\n\n") ;
print (STDERR "options : -h affichage de l'aide\n") ;
print (STDERR "          -e le message d'erreur (ouverture de fichiers)\n") ;
print (STDERR "          -f le format d'encodage\n");
print (STDERR "          -v mode verbeux (STDERR et LOG)\n");
print (STDERR "          -t pour la gestion de la date (initialement : localtime)\n");
print (STDERR "================================================================================\n");
}
 
 
# =======================================================================================================================================
1 ;

Bien entendu, tu peux poser toutes les questions que tu souhaites sur les modifications que j'ai opérées.

14/06/2010, 19h15
japanatome

Merci beaucoup Philou !!

Même si ça ne résout pas tout, c'est sympa de passer du temps dessus. J'ai compris tes explications (c'est plutôt bien non ?:mrgreen:), je vais regarder ça.

Le passage en anglais ne me gène pas, j'ai même tendance à "forcer" le français juste pour pas mettre de l'anglais :mouarf:.

Je vais voir pourquoi ça plante avec twig, j'ai peut être des erreurs à ce niveau-là aussi.

Si je trouve j'indique le code. Sinon peut être Djibril par exemple aura un avis.

En tout cas tu n'as pas dit que mon code était bidon, donc j'avais quand même une bonne piste... enfin je crois... un p'tit peu.... :oops:
14/06/2010, 21h28
japanatome

Bon j'ai regardé, c'est nickel Philou merci pour les mise à jour que t'as faites. C'est beaucoup plus clair comme ça.

Par contre j'ai beau changer 'findnodes' en 'children', ou alors utiliser 'field', ou même d'autres solutions.... rien ne solutionne mon problème avec Twig.

Je pense que c'est mon parsing qui est mauvais, donc il ne peut pas reprendre le texte sous 'headword'. J'vais revoir ça.

Sinon philou, tu penses que passer par les Regexp. c'est possible pour la fusion ?
15/06/2010, 08h25
Philou67430

Je pense, en fait, qu'il faut conserver l'usage d'un parser, et qu'il ne devrait pas être nécessaire de découper le fichier d'entrée pour le fournir au parser, car c'est justement son boulot de séparer les éléments sémantique du fichier XML.
Je devrais avoir un peu plus de temps aujourd'hui pour me pencher sur le module XML::TWIG
15/06/2010, 10h28
djibril

Je n'ai vraiment pas eu le temps de me pencher sur ton souci, mais je fais confiance à philou :ccool: (à qui je recommande de découvrir ce module qui est très performant).
15/06/2010, 10h47
japanatome

Malheureusement, je n'utilise Twig que depuis peu, et j'ai un peu de mal avec les explications en anglais. Je fais donc beaucoup de choses selon les exemples que je trouve (ou selon les articles de Developpez.com). Et je n'ai pas trouvé d'exemples de fusion en utilisant non pas un système DOM mais un système SAX (pour les gros fichiers).

Twig est décrit comme pouvant fusionner (merging) les fichiers Xml, sans restriction. Je suppose dans ce cas que les handlers fonctionnent.

J'avais essayé au début sans passé par un pré-découpage. On pointe sur 'entry' le twig-handler (ça tu l'as dans mon code si tu veux philou). Quand on parse les fichiers, on entre dans la subroutine qui doit effectuer un traitement particulier, puis retourner l'entrée.

Ceci marche sans aucun problème avec un seul fichier, mais gérer deux fichiers en même temps... c'est ça le problème. Comment parser simultanément deux fichiers, en sachant que l'avancement du parsing dépend de la comparaison entre les deux ?

N'avoir qu'une entrée pour le parsing permet d'avancer entrée par entrée, c'est un peu le mode "rustine" d'une utilisation réelle des handlers.

Ce qu'il faudrait :
1) je ne parse que la première entrée des deux fichiers, je renvoie les valeurs.
2) je compare
3) selon la comparaison, j'avance ou pas dans les fichiers vers l'entrée suivante.

Ce principe, en DOM, aucun problème. En SAX, je n'arrive pas à le concevoir. ça voudrait dire que le parsing est partiel et en attente d'un nouveau lancement..... Il faudrait indicer le handler en fait, par exemple un $i qui prend 0 au départ, puis pour avancer on l'incrémente. Si on avance pas on sera toujours à 0. Mais je ne sais même pas si on peut faire ça, une sorte de :
Twig_handlers => 'entry'[$i] => \&twig_entry

J'ai jamais vu un tel exemple. Et je ne sais même pas si ça pourrait marcher. Peut être que ça t'aidera.

J'ai compris le problème en testant et lisant la doc. Une fois l'un des parser appelé, il parcours le contenu de la chaine fournie en entrée à la recherche d'un document XML valide. Il ne retourne alors une erreur si la chaine fournie est incomplète, et un arbre s'il est complet.
Ainsi, en fournissant un fichier en entrée, il va le parcourir en totalité sans rendre la main à l'algorithme de fusion pour lire et comparer avec l'autre parser (hormis que lors de l'appel au handler).

Je comprends donc aussi le besoin que tu avais de fournir des fragments XML valides au parser pour qu'il retourne un arbre contenant un entry valide.

J'ai donc modifié et corrigés quelques bugs de la dernière version, et j'obtiens quelque chose qui me semble fonctionner.
Attention, j'ai modifié les tests de comparaison de ton script initial pour réduire le nombre de branches en utilisant un opérateur de comparaison qui intègre à la fois le fait qu'un entry soit trouvé, et l'ordre lexical des headword. Mais tu pourras revenir à ta version initiale sans problème.
Parmi les bugs corrigés :
- le chemin xpath pour accéder à headword depuis root est //headword
- le retour de findnodes est un tableau dont il faut prendre le premier élément pour obtenir le texte du headword
- le copy -> paste dans fusion ne fonctionne pas car la méthode copy ne détache pas l'élément de son arbre initial. Or, pour utiliser paste, il faut que l'élément ne soit pas attaché à un arbre. Il faut donc utiliser cut et paste (voir doc XML::Twig::Elt).

Le script:

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
#!/usr/bin/perl
 
# =======================================================================================================================================
###--- METADIRECTIVES ---###
 
use strict;
use warnings;
use utf8;
use IO::File; 
use Getopt::Long; # pour gérer les arguments.
 
use XML::Twig; # (non inclus dans le core de Perl), pour le parsing de la source.
use XML::Writer; # (non inclus dans le core de Perl), pour le fichier de sortie.
 
 
# =======================================================================================================================================
###--- PROLOGUE ---###
 
my $ref_root = 'volume'; # la racine (par exemple : <volume> ou <dictionary>).
my $ref_entry = 'entry'; # l'élément dans la source qui correspond avec <m:entry> dans MAM.
my $ref_headword = 'headword';
my $ref_sense = 'sense'; # idem pour l'élément <sense> dans MAM.
 
# ------------------------------------------------------------------------
##-- Gestion des options --##
 
my ($date, $FichierOne, $FichierTwo, $FichierResultat, $erreur, $encoding) = ();
my ($verbeux, $help, $pretty_print, $langue) = ();
GetOptions( 
  'date|time|t=s'        	    => \$date, # flag de type -date ou --date, ou -time ou --time, ou -t ou --t (=s : string)
  'source|base|in|one|from|i=s' => \$FichierOne, 
  'add|and|two|j=s'        		=> \$FichierTwo,
  'sortie|out|to|o=s'           => \$FichierResultat, 
  'erreur|error|e=s'     	  	=> \$erreur, 
  'encodage|encoding|enc|f=s' 	=> \$encoding, 
  'help|h'                	  	=> \$help, 
  'verbeux|v'             	  	=> \$verbeux, 
  'print|pretty|p=s'       	  	=> \$pretty_print, 
  'langue|lang|l=s'				=> \$langue,
  );
 
if (!( defined $date ))
	{
	$date = localtime;
	};
if (!( defined $FichierOne ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierTwo ))
	{
	&help ; # si le fichier source n'est pas spécifié, affichage de l'aide.
	};
if (!( defined $FichierResultat ))
	{
	$FichierResultat = "toto.xml" ;
	};
if (!( defined $erreur ))
	{
	$erreur = "|ERROR| : problem opening file :";
	};
if (!( defined $encoding ))
	{
	$encoding = "UTF-8"; 
	};
if (!( defined $pretty_print ))
	{
	$pretty_print = "none"; 
	};
if (!( defined $langue ))
	{
	$langue = "XX"; 
	};
if ( defined $help )
	{
	&help;
	};
 
# ------------------------------------------------------------------------
# Autres variables :
 
my $count_one = 0;
my $count_two = 0;
 
# ------------------------------------------------------------------------
# Input/ Output
 
open (FILEONE, "<:encoding($encoding)", $FichierOne) or die ("$erreur $!\n");
open (FILETWO, "<:encoding($encoding)", $FichierTwo) or die ("$erreur $!\n");
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('a'); 
	};
# message dans le STDERR (voir subroutine 'info') indiquant le démarrage du programme.
 
# ------------------------------------------------------------------------
##-- Début de l'écriture --##
 
my $output = new IO::File(">$FichierResultat");
my $writer = new XML::Writer(
  OUTPUT      => $output,
  DATA_INDENT => 3,         # indentation, 3 espaces
  DATA_MODE   => 1,         # changement ligne.
  ENCODING    => $encoding,
);
$writer->xmlDecl($encoding);
 
$writer->startTag
	(
  "m:volume",
  'name'              => "NAME",
  'source-language'   => $langue,
  'creation-date'     => $date,
	);
 
# =======================================================================================================================================
###--- PREPARATION ---###
 
my ($twig_one, $twig_two);
my ($entry_one, $entry_two);
$twig_one = XML::Twig->new
  (
   output_encoding => $encoding, # on reste en utf8
   pretty_print    => $pretty_print, # par défaut le style est 'none'
   twig_roots      => {'entry' => 1}, 
   Twig_handlers   => {'entry' => \&entry_one},
  );
 
sub entry_one {
  $entry_one = $_[1];
  return 1;
}
 
# ------------------------------------------------------------------------
$twig_two = XML::Twig->new
  (
   output_encoding => $encoding, 
   pretty_print    => $pretty_print,
   twig_roots      => {'entry' => 1},
   Twig_handlers   => {'entry' => \&entry_two},
  );
 
sub entry_two{
  $entry_two = $_[1];
  return 1;
}
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('b'); 
	};
 
# ------------------------------------------------------------------------
 
$entry_one = next_entry($twig_one, *FILEONE, \$entry_one); # obtenir la première entrée de la source 1.
$entry_two = next_entry($twig_two, *FILETWO, \$entry_two); # obtenir la première entrée de la source 2.
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
	{
	&info('c'); 
	};
 
# =======================================================================================================================================
###--- ALGORITHME DE LA FUSION ---###
 
# Après avoir récupéré la ou les entrées (sub next_entry), on les compare.
# On écrit dans le fichier de sortie selon la comparaison.
my ($headword_one, $headword_two);
# Le traitement continuera tant qu'il y a des entrées dans l'une ou l'autre source.
while ($entry_one || $entry_two)
  {
    if ( defined $verbeux )	{print (STDERR "In progress\n");};
 
    $headword_one = $entry_one ? [$entry_one->findnodes ("//headword")]->[0]->text : undef;
    $headword_two = $entry_two ? [$entry_two->findnodes ("//headword")]->[0]->text : undef;
    if ( defined $verbeux && $headword_one )	{print (STDERR "$FichierOne : entrée [$headword_one]\n");};
    if ( defined $verbeux && $headword_two )	{print (STDERR "$FichierTwo : entrée [$headword_two]\n");};
 
    # On compare la présence des headword, et s'ils sont présents tous les deux,
    # on compare les deux headword 'lexicographiquement'
    my $compare = (defined $headword_two) - (defined $headword_one) || $headword_one cmp $headword_two;
 
    # 1) si l'entrée 1 est inférieure à l'entrée 2 (ou s'il n'y a plus d'entrée 2):
    # On écrit l'entrée 1 dans le fichier de sortie.
    # On avance d'une entrée dans le fichier 1
    if ($compare < 0) {
      $entry_one->print($output, "indented");
      # pour avoir l'entrée suivante dans le fichier 1.
      $entry_one = next_entry($twig_one, *FILEONE, \$entry_one);
    }
    # 2) si l'entrée 1 est supérieure à l'entrée 2 (ou s'il n'y a plus d'entrée 1):
    # On écrit l'entrée 2 dans le fichier de sortie.
    # On avance d'une entrée dans le fichier 2.
    elsif ($compare > 0) {
      $entry_two->print($output, "indented");
      # pour avoir l'entrée suivante dans le fichier 2.
      $entry_two = next_entry($twig_two, *FILETWO, \$entry_two);
    }
    # 3) le dernier cas : entrée 1 = entrée 2 :
    # On ajoute les éléments de entrée 2 dans entrée 1, qu'on écrit dans le fichier de sortie.
    # On avance d'une entrée dans le fichier 1 et dans le fichier 2.
    else
      {
        fusion ($entry_one, $entry_two);
        $entry_one->print($output, "indented");
        $entry_one = next_entry($twig_one, *FILEONE, \$entry_one);
        $entry_two = next_entry($twig_two, *FILETWO, \$entry_two);
      }
  }
 
# ------------------------------------------------------------------------
# Fin de l'écriture :
 
$writer->endTag("m:volume");
$output->close();
 
# ------------------------------------------------------------------------
 
if ( defined $verbeux )
  {
    &info('d');
  };
 
# =======================================================================================================================================
###--- SUBROUTINES ---###
sub next_entry {
  my ($twig, $file, $entry) = @_;
 
  $$entry = undef;
  $/ = "</entry>";
  while (!$$entry && !eof $file) {
    my $xml = <$file>;
    $twig->safe_parse($xml);
  }
  $twig->purge;
 
  return $$entry;
}
 
# ------------------------------------------------------------------------
 
sub fusion
{
my $entry_one = shift @_;
my $entry_two = shift @_;
 
foreach my $sense_two ($entry_two->findnodes('sense'))
  {
    $sense_two->cut;
    my $last_elt = $entry_one->last_child('sense');
    $last_elt = $entry_one->last_child('head') if !defined $last_elt;
 
    $sense_two->paste('after' => $last_elt);
  }
return ($entry_one);
}
 
# ------------------------------------------------------------------------
 
sub info
{
my $info = shift @_;
if ($info =~ 'a')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "\t~~~~ $0 : START ~~~~\n");
	print (STDERR "================================================================================\n");
	}
elsif ($info=~ 'b')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "en-tete du fichier de sortie effective\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info=~ 'c')
	{
	print (STDERR "================================================================================\n");
	print (STDERR "lancement du processus de fusion\n");
	print (STDERR "--------------------------------------------------------------------------------\n");
	}
elsif ($info =~ 'd')
	{
	print (STDERR "~~~~ $0 : END ~~~~\n");
	print (STDERR "================================================================================\n");
	my $time = times ;
	my $FichierLog = 'LOG.txt';
	open(my $FiLo, ">>:encoding($encoding)", $FichierLog) or die ("$erreur $!\n");
	print {$FiLo}
	"==================================================\n",
	"RAPPORT : ~~~~ $0 ~~~~\n",
	"--------------------------------------------------\n",
	"Fichier source : $FichierOne\n",
	"--------------------------------------------------\n",
	"Fichier final : $FichierResultat\n",
	"--------------------------------------------------\n",
	"Date du traitement : ", $date, "\n",
	"--------------------------------------------------\n",
	"Lapsed time : ", $time, " s\n",
	"==================================================\n";
	}
}
 
 
sub help 
{
print (STDERR "================================================================================\n");  
print (STDERR "HELP\n");
print (STDERR "================================================================================\n");
print (STDERR "usage : $0 -i <sourcefile.xml> -o <outfile.xml>\n\n") ;
print (STDERR "options : -h affichage de l'aide\n") ;
print (STDERR "          -e le message d'erreur (ouverture de fichiers)\n") ;
print (STDERR "          -f le format d'encodage\n");
print (STDERR "          -v mode verbeux (STDERR et LOG)\n");
print (STDERR "          -t pour la gestion de la date (initialement : localtime)\n");
print (STDERR "================================================================================\n");
}
 
 
# =======================================================================================================================================
1 ;

15/06/2010, 16h35
djibril

:ccool: Alors sympa ce module :mouarf: ?
15/06/2010, 16h42
Philou67430

Disons... pour la problématique de japanatome, il est clair que l'usage d'un parser XML par handler pose des problèmes.
Concernant l'usage de XML::Twig en lui-même, je sais pas trop, mais si je suis amené à parser du XML, je commencerai par utiliser ce module ;)
15/06/2010, 17h00
japanatome

Hé bé :cry: .... J'suis ému...

:ccool::ccool::ccool::ccool:

Merci Philou pour le temps que tu as passé et les explications. Non seulement tu me proposes un code qui marche, mais en plus tu me dis pourquoi il marchait pas.

Je vais regarder ça. En tout cas je peux déjà faire deux conclusions :

1) Tous les chemins mènent à Perl (interprétation de "There is more than one way to do it"), mais certains chemins ne sont pas évidents du tout, la preuve par les handlers et ma problématique.
Jusqu'à ce matin je basculais entre un fonctionnement en Regex avec mon fameux while <IN>, et le parseur. De ce mélange de deux méthodes il fallait choisir. Philou m'a bien aidé pour ce choix :mouarf:.

2) Il va vraiment falloir que je bosse mon anglais .... Parce que mine de rien, la doc' sur CPAN et sur le site de l'auteur de Twig est quand même bien développé (c'est d'ailleurs pour ça que j'ai choisi Twig).

Bon je vérifie tout ça, et je met [résolu] après.

Une dernière question, à Djibril et à Philou, mais peut être un peu trop personnel : Vous "faites" du Perl depuis longtemps ? Parce que la différence de comportement entre vous deux et moi (qui ai commencé il y a 3 mois) est flagrante.
15/06/2010, 17h27
Philou67430

La solution proposée ne me satisfait guère, car elle n'est pas transposable à d'autres problématiques de merge de fichier XML (à cause de la nécessité de fragmenter le fichier XML pour le parser fragment par fragment).
Je reste donc sur ma faim. Il me semble qu'il faudrait soit :
- trouver le parser vraiment adapté (qui accepte d'emblée des fragments de fichier XML)
- adapter le parser actuel pour qu'il accepte ce type de fragment

J'ai commencé perl avec la version 5.05, vers 1998, après avoir usé awk. Je l'ai intensivement utilisé professionnellement pendant 3 ans, de 2005 à 2008, et maintenant, surtout pour le plaisir.
15/06/2010, 18h10
japanatome

ça marche nickel ! Sur mes gros fichiers, je met moins de 10 minutes, ce qui est très bien ! :ccool:

Pour ton idée de généraliser, c'est peut-être possible en remplaçant le handler 'entry' par $tag, qui peut être utilisé après pour $/ :

$/ = "</$tag>";

Ensuite dans le while, on peut remplacer "//headword" par un $comp pour l'élément à comparer.

Et dans la sub fusion, 'sense' devient $merging_elt (l'élément à fusionner) et 'head' $merging_place (le lieu de la fusion si $merging_elt n'apparaît pas là ou aura lieu a fusion).

En faisant juste ça, on s'en sort bien non ?

[EDIT : ça ne répond pas à ta question, désolé pour avoir répondu à côté :aie:]

Pour ma part, je n'essaierai pas d'aller plus loin, puisque j'ai une version qui marche. Sauf si tu veux continuer, dans ce cas je peux essayer d'apporter mon aid.... mon soutien psychologique :mrgreen:
16/06/2010, 09h36
Philou67430

Citation:

Envoyé par japanatome

ça marche nickel ! Sur mes gros fichiers, je met moins de 10 minutes, ce qui est très bien ! :ccool:

Pour ton idée de généraliser, c'est peut-être possible en remplaçant le handler 'entry' par $tag, qui peut être utilisé après pour $/ :

$/ = "</$tag>";

Oui, tant que l'on n'a qu'un seul type de tag à récupérer...
Et cela ne règle nullement le problème de la présence de multiples tags différents dans le fichier source, même si l'on ne souhaite en traiter qu'un seul type.
Bref, cela reste une solution spécifique.

Citation:

[EDIT : ça ne répond pas à ta question, désolé pour avoir répondu à côté :aie:]

Tu es concentré sur ton problème, c'est donc normal.

Citation:

Pour ma part, je n'essaierai pas d'aller plus loin, puisque j'ai une version qui marche. Sauf si tu veux continuer, dans ce cas je peux essayer d'apporter mon aid.... mon soutien psychologique :mrgreen:

Question subsidiaire : les deux fichiers XML à merger sont-ils géant, ou seulement l'un des deux ?
16/06/2010, 11h17
japanatome

Les deux le sont. En fait, j'en ai plus que deux, mais en moyenne ils font 50 mo. Soit ils ont beaucoup d'entrées (jusqu'à 100 000), soit ils ont beaucoup d'informations (mais dépassent les 20 000 entrées quand même).
Sinon j'aurai fait un parsing complet sur le petit, et un handler sur le plus gros :mrgreen:
Je suis en train d'apporter des améliorations (sur la subroutine fusion, pour fusionner un peu plus).
Et je viens de me rendre compte d'un point très important :
'cmp' (ou autre fonction de comparaison sur les chaînes), utilise l'ordre ASCII ! Et moi je travaille avec des sources Unicode et ASCII, et donc l'ordre change.... Va falloir trier tout ça !

Sinon même en enchaînant les fusions, ça marche nickel, et la moyenne reste sur 10 minutes environ (pour obtenir un fichier entre 80 et 100mo au final).
21/06/2010, 16h52
Philou67430

Je suis sur une piste qui utilise les thread et des pipes.
23/06/2010, 16h32
japanatome

Si jamais tu trouves quelque chose, tu auras au moins une personne dans ton fan club :mouarf:

la continuité de cette problématique m'intéresse toujours !
23/06/2010, 16h36
Philou67430

Je bloque : j'arrive à créer correctement des pipes et des threads, mais il semblerait que XML::Parser::Expat n'accepte pas un file handle issu d'un pipe comme entrée à parser, car je n'arrive pas à l'alimenter comme je le souhaite.