Bash supprimer des balises

Le Goss · Le 30/06/2012, à 11:18

Bonjour à tous,

J'ai des fichiers xml, html... dont je voudrais virer, à l'aide d'un script Bash, les balises, sachant qu'entre chacune d'elles, il y a un contenu différent; et récupérer le résultat (sans les balises) dans un fichier txt.

Les contenus de mes balises sont de 2 types.

I. Des chaines de caractères à récupérer telles quelles. Par exemple, à partir de l'expression :

Dans le fichier initial
<balise1>chainedecaractères</balise1>, bla, <balise1>autrechaine</balise1> bla bla, <balise1>sériedechiffres</balise1>

Je voudrais ne garder que

Dans le fichier txt
chainedecaractères, bla, autrechaine bla bla, sériedechiffres

II. Des chaines de caractères à transformer par substitution. Par exemple, à partir de l'expression :

Dans le fichier initial
Hier, il faisait <balise2>-5</balise2>. Aujourd'hui il fait <balise2>35</balise2>.

Dans le fichier txt
Hier, il faisait froid. Aujourd'hui il fait chaud .

J'ai beau chercher sur la toile des exemples avec la commance sed, mais je tourne en rond.
Quelqu'un a-t-il une suggestion ?
Merci pour vodre aide,
Cordialement

AnsuzPeorth · Le 30/06/2012, à 12:13

Bjr,
Ca tombe bien, je voulais faire un peu de bash ...

Donc, pour supprimer les balises:

sed -e :a -e 's/<[^>]*>//g;/</N;//ba' fichier_source > fichier_sortie

Pour remplacer les températures:

result=$(while read line
 do
    if (($line * 2)) 2>/dev/null; then
      (($line > 0)) && echo chaud || echo froid
    else
      echo $line
    fi
 done< <(sed -r 's/([^<]*)<[^>]*>([^<]*)<\/[^>]*>/\1\n\2\n/g' fichier_source))
echo ${result} > fichier_sortie
exit

Ce n'est pas parfait, on peut surement faire différent ou mieux, mais bon, ca fait un peu pret le taf

Le Goss · Le 30/06/2012, à 12:28

Ok pour supprimer toutes les balises.
Mais pour la 2ème partie, je capte pas grand chose au code en particulier les lignes

if (($line * 2)) 2>/dev/null; then
      (($line > 0)) ...

Tu peux m'expliquer?

AnsuzPeorth · Le 30/06/2012, à 12:31

re,
je remplace les balises par des saut de ligne (en gros). Ensuite je test chaque ligne, si on peut multiplier par 2 cette ligne, c'est que c'est un chiffre, donc si ce chiffre superieur à 0, il fait chaud, sinon il fait froid ...

Le Goss · Le 30/06/2012, à 12:41

C'est bien ce que j'intuitais,
Les températures étaient un mauvais exemple. Je vais donc préciser...
Pour cette partie, le but est de substituter une chaine de caractères par une autre tout en enlevant les balises.
je cherche un résultat du style:

Soit une chaine de caractère "machaine".
Si machaine = "plaf", alors <balise>machaine</balise> devient "quelquechose"
Si machaine = "plof", alors <balise>machaine</balise> devient "autrechose"
Si machaine = "plouf", alors <balise>machaine</balise> devient "encoreautrechose"... etc.

Dernière modification par Le Goss (Le 30/06/2012, à 12:42)

AnsuzPeorth · Le 30/06/2012, à 12:57

re

Case() {
    case $@ in
      -5)
         echo froid;;
      35)
         echo chaud;;
      *) 
         echo "$@" ;;
    esac
}

result=$(while read line
 do
    Case $line
 done< <(sed -r 's/([^<]*)<[^>]*>([^<]*)<\/[^>]*>/\1\n\2\n/g' fichier_source))

echo ${result} > fichier_sorite

exit

Le Goss · Le 30/06/2012, à 15:52

Bon. La console chauffe, et Tux doit certainement se demander à quoi je joue. Bref, j'y arrive pas...
J'ai plusieurs type de balises et je ne parviens pas à les traiter les unes après les autres.
Je crois que c'est du à la ligne

echo ${result} >

Admettons que je fasse d'abord une copie du code xml dans mon fichier txt. Que donnerait ton cadre au-dessus, et faisant des substitutions successives, dans la mesure ou j'ai plusieurs 2 de balises (voir plus haut) ?

nesthib · Le 30/06/2012, à 19:11

Si tu veux coder un parser HTML pour le fun c'est un exercice intéressant mais si tu veux un outil utilisable dans une situation réelle :

curl http://forum.ubuntu-fr.org/viewtopic.php?id=968791 | html2text

pour plus d'infos :

man html2text

Sinon selon ton projet tu peux utiliser par exemple python qui possède de nombreuses bibliothèques dédiées à cela.

AnsuzPeorth · Le 01/07/2012, à 13:24

Ecoute la parole du juste nesthib !

J'ajouterai que pour travailler sur xml, en bash, il y a xpath, vu que tu compte faire de grosses modifs, fait le avec xpath, ensuite html2text et ca roule ... Sinon, ben faut parser a la main, mais là, faut le faire toi même, je pourrais pas t'aider, car trop de variables pour faire du généralisme :d

Le Goss · Le 01/07/2012, à 20:28

J'ai essayé html2text. C'est nickel. Trop. Ça me vire toutes les balises... y compris certaines que je dois impérativement conserver afin de les traiter. D'où le script Bash. C'est vrai que je pourrais faire ça en sens inverse : traiter les balises qui doivent l'être en Bash et virer les autres avec html2text.
Quant à xpath, j'ai trouvé trop peu de doc pour pouvoir vraiment m'en servir.
C'est quoi un "parser" ? je suis tombé sur ce mot plusieurs fois ces derniers jours sans savoir en quoi ça consiste.

Merci à vous deux ! de nouvelles portes s'ouvrent...
Pourvu que je ne les prenne pas en pleine poire !

nesthib · Le 01/07/2012, à 21:50

Un parser (anglais) est un analyseur syntaxique. Il va déterminer les différents composants d'un langage et être capable de les classifier, les hiérarchiser ou d'en extraire des propriétés. Par exemple pour le XML, un analyseur syntaxique approprié peut reconnaître :

<élément attribut="valeur">texte/</élément>

Si tu dois simplement effectuer une tâche très simple et déterministe tu peux te tourner, comme tu le faisais, vers des outils de traitement de texte non spécialisés comme sed ou awk. Si tu dois analyser un document balisé de façon plus précise, que tu dois effectuer un traitement plus complexe ou que les documents que tu veux analyser on une qualité variable (ex. erreurs de syntaxe, variabilité…) tu devrais expliquer ce que tu cherches à faire que l'on puisse te conseiller.

Personnellement j'aime bien python et le module BeautifulSoup qui est très bon dans l'analyse syntaxique XML/HTML

Le Goss · Le 01/07/2012, à 22:40

Bon. Je crache le morceau : "au clair de la lune" ici en xml. Fragment pour exemple

<?xml version="1.0"?>
<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 1.1 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">
<score-partwise>
    <work> <work-title>/home/legoss/Bureau/mid/auclair.xml</work-title></work> 
    <identification> 
        <rights>Copyright (c) xxxx Copyright Holder</rights>
        <encoding>
            <software>Rosegarden v11.06</software>
        </encoding>
    </identification> 
    <part-list>
        <score-part id="B">
            <part-name>Imported MIDI</part-name>
        </score-part>
    </part-list>
    <part id="B">
        <measure number="1">
            <attributes>
                <divisions>960</divisions>
                <key>
                <fifths>2</fifths>
                <mode>major</mode>
                </key>
                <time>
                <beats>4</beats>
                <beat-type>4</beat-type>
                </time>
                <clef>
                <sign>G</sign>
                <line>2</line>
                </clef>
            </attributes>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="2">
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="3">
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="4">
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="5">
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="6">
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
            <note>
                <pitch>
                    <step>G</step>
                    <octave>4</octave>
                </pitch>
                <duration>1920</duration>
                <voice>1</voice>
                <type>half</type>
            </note>
        </measure>

        <measure number="7">
            <note>
                <pitch>
                    <step>C</step>
                    <octave>4</octave>
                </pitch>
                <duration>3840</duration>
                <voice>1</voice>
                <type>whole</type>
            </note>
        </measure>

        <measure number="8">
            <note>
                <pitch>
                    <step>C</step>
                    <octave>4</octave>
                </pitch>
                <duration>3840</duration>
                <voice>1</voice>
                <type>whole</type>
            </note>
        </measure>
    </part>
</score-partwise>

Il s'agit pour moi de transformer ce code xml en code lilypond (gravure de partitions musicales)
Si je le faisait à la main, ça donnerait quelquechose comme ça :

\key d \major \time 4/4
  d4 d4 d4 e4 fis2 e2 d4 fis4 e4 e4 d1

Je suis arrivé au forceps à pondre un script en Bash qui donne ce qui suit. Les puristes vont certainement crier au scandale...

#!/bin/bash

key='\\key'
major='\\major'
time='\\time'
clef='\\clef'

    sed -i '{:a;$!N;s_\n_ _;ta}' monfichier.txt #Ecrire un fichier sur une ligne 
    sed -i "s/<divisions>[0-9][0-9][0-9][0-9]<\/divisions>//g" monfichier.txt
    sed -i "s/<divisions>[0-9][0-9][0-9]<\/divisions>//g" monfichier.txt
    sed -i "s/<duration>[0-9][0-9][0-9][0-9]<\/duration>//g" monfichier.txt
    sed -i "s/<duration>[0-9][0-9][0-9]<\/duration>//g" monfichier.txt

    sed -i "s/<voice>1<\/voice>//g" monfichier.txt

    sed -i "s/<key>/$key /g" monfichier.txt

    sed -i "s/<fifths>-7<\/fifths>/ces /g" monfichier.txt
    sed -i "s/<fifths>-6<\/fifths>/ges /g" monfichier.txt
    sed -i "s/<fifths>-5<\/fifths>/des /g" monfichier.txt
    sed -i "s/<fifths>-4<\/fifths>/aes /g" monfichier.txt
    sed -i "s/<fifths>-3<\/fifths>/ees /g" monfichier.txt
    sed -i "s/<fifths>-2<\/fifths>/bes /g" monfichier.txt
    sed -i "s/<fifths>-1<\/fifths>/f /g" monfichier.txt
    sed -i "s/<fifths>0<\/fifths>/c /g" monfichier.txt
    sed -i "s/<fifths>1<\/fifths>/g /g" monfichier.txt
    sed -i "s/<fifths>2<\/fifths>/d /g" monfichier.txt
    sed -i "s/<fifths>3<\/fifths>/a /g" monfichier.txt
    sed -i "s/<fifths>4<\/fifths>/e /g" monfichier.txt
    sed -i "s/<fifths>5<\/fifths>/b /g" monfichier.txt
    sed -i "s/<fifths>6<\/fifths>/fis /g" monfichier.txt
    sed -i "s/<fifths>7<\/fifths>/major /g" monfichier.txt

    sed -i "s/<mode>major<\/mode>/$major /g" monfichier.txt
    sed -i "s/<mode>minor<\/mode>/$major /g" monfichier.txt
    sed -i "s/<\/key>//g" monfichier.txt

    sed -i "s/<time>/$time /g" monfichier.txt

    sed -i "s/<beats>1<\/beats>/1\//g" monfichier.txt
    sed -i "s/<beats>2<\/beats>/2\//g" monfichier.txt
    sed -i "s/<beats>3<\/beats>/3\//g" monfichier.txt
    sed -i "s/<beats>4<\/beats>/4\//g" monfichier.txt
    sed -i "s/<beats>5<\/beats>/5\//g" monfichier.txt
    sed -i "s/<beats>6<\/beats>/6\//g" monfichier.txt
    sed -i "s/<beats>7<\/beats>/7\//g" monfichier.txt
    sed -i "s/<beats>8<\/beats>/8\//g" monfichier.txt
    sed -i "s/<beats>9<\/beats>/9\//g" monfichier.txt
    sed -i "s/<beats>12<\/beats>/12\//g" monfichier.txt

    sed -i "s/<beat-type>2<\/beat-type>/2 /g" monfichier.txt
    sed -i "s/<beat-type>4<\/beat-type>/4 /g" monfichier.txt
    sed -i "s/<beat-type>8<\/beat-type>/8 /g" monfichier.txt

    sed -i "s/<\/time>//g" monfichier.txt
    sed -i "s/<clef>//g" monfichier.txt
    sed -i "s/<sign>G<\/sign><line>2<\/line>/$clef \"G_8\"\n/g" monfichier.txt
    sed -i "s/<sign>C<\/sign><line>3<\/line>/$clef alto\n/g" monfichier.txt
    sed -i "s/<sign>C<\/sign><line>4<\/line>/$clef tenor\n/g" monfichier.txt
    sed -i "s/<sign>F<\/sign><line>4<\/line>/$clef bass\n/g" monfichier.txt
    sed -i "s/<sign>G<\/sign><line>1<\/line>/$clef french\n/g" monfichier.txt
    sed -i "s/<sign>C<\/sign><line>1<\/line>/$clef soprano\n/g" monfichier.txt
    sed -i "s/<sign>C<\/sign><line>2<\/line>/$clef mezzosoprano\n/g" monfichier.txt
    sed -i "s/<sign>C<\/sign><line>5<\/line>/$clef baritone\n/g" monfichier.txt
    sed -i "s/<sign>F<\/sign><line>3<\/line>/$clef varbaritone\n/g" monfichier.txt
    sed -i "s/<sign>F<\/sign><line>5<\/line>/$clef subbass\n/g" monfichier.txt

    sed -i "s/<\/clef>//g" monfichier.txt

    sed -i "s/<step>A<\/step>/a/g" monfichier.txt
    sed -i "s/<step>B<\/step>/b/g" monfichier.txt
    sed -i "s/<step>C<\/step>/c/g" monfichier.txt
    sed -i "s/<step>D<\/step>/d/g" monfichier.txt
    sed -i "s/<step>E<\/step>/e/g" monfichier.txt
    sed -i "s/<step>F<\/step>/f/g" monfichier.txt
    sed -i "s/<step>G<\/step>/g/g" monfichier.txt
    sed -i "s/<accidental>natural<\/accidental>//g" monfichier.txt

    sed -i "s/<tied type=\"start\"\/>/ ~/g" monfichier.txt
    sed -i "s/<tie type=\"start\"\/>//g" monfichier.txt
    sed -i "s/<tie type=\"stop\"\/>//g" monfichier.txt
    sed -i "s/<tied type=\"stop\"\/>//g" monfichier.txt
    sed -i "s/<notations>//g" monfichier.txt
    sed -i "s/<\/notations>//g" monfichier.txt


    sed -i "s/<alter>1<\/alter>/is/g" monfichier.txt
    sed -i "s/<alter>-1<\/alter>/es/g" monfichier.txt

    sed -i "s/<octave>1<\/octave>/,,,/g" monfichier.txt
    sed -i "s/<octave>2<\/octave>/,,/g" monfichier.txt
    sed -i "s/<octave>3<\/octave>/,/g" monfichier.txt
    sed -i "s/<octave>4<\/octave>//g" monfichier.txt
    sed -i "s/<octave>5<\/octave>/'/g" monfichier.txt
    sed -i "s/<octave>6<\/octave>/''/g" monfichier.txt
    sed -i "s/<octave>7<\/octave>/'''/g" monfichier.txt
    sed -i "s/<octave>8<\/octave>/''''/g" monfichier.txt

    sed -i "s/<type>whole<\/type>/1/g" monfichier.txt
    sed -i "s/<type>half<\/type>/2/g" monfichier.txt
    sed -i "s/<type>quarter<\/type>/4/g" monfichier.txt
    sed -i "s/<type>eighth<\/type>/8/g" monfichier.txt
    sed -i "s/<type>16th<\/type>/16/g" monfichier.txt
    sed -i "s/<type>32nd<\/type>/32/g" monfichier.txt

    sed -i "s/<dot\/><dot\/>/.. /g" monfichier.txt
    sed -i "s/<dot\/>/. /g" monfichier.txt
    sed -i "s/<rest\/>/r/g" monfichier.txt

    sed -i "s/<\/note><note>/ /g" monfichier.txt
    sed -i "s/<\/note><\/measure>/ /g" monfichier.txt
    sed -i "s/<pitch>/ /g" monfichier.txt
    sed -i "s/<\/pitch>//g" monfichier.txt
    sed -i "s/<\/attributes><note>//g" monfichier.txt

    sed -i "s/<measure number=\"[1-9]\"><note>//g" monfichier.txt
    sed -i "s/<measure number=\"[1-9][0-9]\"><note>//g" monfichier.txt
    sed -i "s/<measure number=\"[1-9][0-9][0-9]\"><note>//g" monfichier.txt

    sed -i 's/\ \ */\ /g' monfichier.txt             #Remplacer 2 blancs (ou +) par 1 seul blanc

ça fait 99% du boulot. Et il y a toujours une bricole ou deux à corriger à la main. D'autant le le fichier xml peut contenir quelques erreurs (minimes cependant).
Je voudrais quand-même faire un script Bash digne de ce nom. C'est pas ensore le cas. Je sais.
Si vous voyez une solution plus simple et plus rapide à mettre en œuvre, je suis preneur !

nesthib · Le 02/07/2012, à 00:00

SCANDAAAAAALE !

Effectivement… ça n'est ni joli, ni facile à lire ou à modifier, ni très efficace (te rends-tu compte combien de fois tu lis ton fichier ?)

Je ne suis pas sûr d'avoir compris comment tu passais du XML au « d4 d4 d4 e4 fis2 e2 d4 fis4 e4 e4 d1 » mais voici un exemple de ce que tu peux faire en python. Tu dois installer le paquet python-beautifulsoup

#!/usr/bin/env python

from BeautifulSoup import BeautifulSoup

f = file("/tmp/auclair.xml")

notes = {
"-7" : "ces",
"-6" : "ges",
"-5" : "des",
"-4" : "aes",
"-3" : "ees",
"-2" : "bes",
"-1" : "f",
"0"  : "c",
"1"  : "g",
"2"  : "d",
"3"  : "a",
"4"  : "e",
"5"  : "b",
"6"  : "fis",
"7"  : "major"
}

soup = BeautifulSoup(f)
a    = soup.find('attributes')

print('\key %s \%s \\time %s/%s' % (notes[a.key.fifths.text], a.mode.text, a.beats.text, a.find('beat-type').text))

s=[]
for n in soup.findAll('note'):
    s.append("%s%s" % (n.pitch.step.text.lower(), n.pitch.octave.text))
print(" ".join(s))

Bien entendu ça n'est qu'un exemple et toutes les fonctionnalités ne sont pas présentes, mais je suppose que c'est une bonne base pour comprendre l'analyse syntaxique et améliorer ton parser.

Le Goss · Le 02/07/2012, à 07:30

Désolé pour mon code si peu élégant... et merci pour ton exemple, même sis tout comme dans ton cas, je n'y ai pas tout compris. Question de synthaxe je supppose.
Je m'étais déjà rencardé sur le langage Python il y a une paire d'années et je n'y avais rien compris. Peut-être parce que je n'en connaissais pas les finalités. Présenté comme tu le fais, ça ne me paraît pas plus compliqué que le Bash.
Sans abuser, est-ce que aurais des liens des tutos Python qui expliquent à quoi ça sert et comment on s'en sert ?

nesthib · Le 02/07/2012, à 07:38

bah… je te charriais car tu me tendais le bâton

Pour python je te recommande de lire cet article : https://kanorblog.wordpress.com/2010/06 … re-python/

Sinon n'hésite pas à essayer et demander si tu as besoin d'aide

Le Goss · Le 02/07/2012, à 18:00

Merci pour l'info !
Va y avoir plusieurs heures de lecture en perspective.
M'enfin, si quelqu'un peut faire avancer le Schmilblick en Bash, je suis preneur !

credenhill · Le 03/07/2012, à 08:51

hello
pour n'exécuter qu'une seule fois sed, on peut faire:

cat <<EOF | sed -f - -i monfichier
{:a;$!N;s_\n_ _;ta}
s/<divisions>[0-9][0-9][0-9][0-9]<\/divisions>//g 
s/<divisions>[0-9][0-9][0-9]<\/divisions>//g
s/<duration>[0-9][0-9][0-9][0-9]<\/duration>//g
s/<duration>[0-9][0-9][0-9]<\/duration>//g
...la suite...
EOF

Bousky · Le 03/07/2012, à 09:24

credenhill a écrit :

cat <<EOF | sed -f - ...

Là c'est un vrai scandale… Ici cat ne fait rien d'autre que d'envoyer son entrée standard vers sa sortie standard…

sed -f - ... <<EOF
...
EOF

ou

sed ... -e "
..."

Certains préfèrent écrire la dernière solution ainsi (ça ne fait que rajouter des chaines vides autour des commandes sed, mais c'est plus lisible) :

sed ... -e """
...
"""

Dernière modification par Bousky (Le 03/07/2012, à 09:26)

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 30/06/2012, à 11:18

Bash supprimer des balises

#2 Le 30/06/2012, à 12:13

Re : Bash supprimer des balises

#3 Le 30/06/2012, à 12:28

Re : Bash supprimer des balises

#4 Le 30/06/2012, à 12:31

Re : Bash supprimer des balises

#5 Le 30/06/2012, à 12:41

Re : Bash supprimer des balises

#6 Le 30/06/2012, à 12:57

Re : Bash supprimer des balises

#7 Le 30/06/2012, à 15:52

Re : Bash supprimer des balises

#8 Le 30/06/2012, à 19:11

Re : Bash supprimer des balises

#9 Le 01/07/2012, à 13:24

Re : Bash supprimer des balises

#10 Le 01/07/2012, à 20:28

Re : Bash supprimer des balises

#11 Le 01/07/2012, à 21:50

Re : Bash supprimer des balises

#12 Le 01/07/2012, à 22:40

Re : Bash supprimer des balises

#13 Le 02/07/2012, à 00:00

Re : Bash supprimer des balises

#14 Le 02/07/2012, à 07:30

Re : Bash supprimer des balises

#15 Le 02/07/2012, à 07:38

Re : Bash supprimer des balises

#16 Le 02/07/2012, à 18:00

Re : Bash supprimer des balises

#17 Le 03/07/2012, à 08:51

Re : Bash supprimer des balises

#18 Le 03/07/2012, à 09:24

Re : Bash supprimer des balises

Pied de page des forums