Petit effet problème de formalisme XML

**dedalios** · 21/08/2022, 14h46

bonjour

voici mon code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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
# coding: utf-8
 
 
import random
from dataclasses import dataclass
from bs4 import BeautifulSoup
from datetime import datetime, timedelta ,date
import time
#from lxml import *
 
from lxml import etree
 
 
@dataclass 
class Ametropie:   
    oeil :str = None
    sphere : float = 0.0
    cylindre :float = 0.0
    axeDuCylindre :int = 0
    addition : float = 0.0
    photochromie :int =0
 
    def xml(self):
        resultat = f"<ametropie>\r"
        resultat += f"<oeil>{self.oeil}</oeil>\r"
        resultat += f"<sphere>{self.sphere}</sphere>\r"
        resultat += f"<cylindre>{self.cylindre}</cylindre>\r"
        resultat += f"<axeDuCylindre>{self.axeDuCylindre}</axeDuCylindre>\r"
        resultat += f"<addition>{self.addition}</addition>\r"
        resultat += f"<photochromie>{self.photochromie}</photochromie>\r"
        resultat += f"</ametropie>"
 
        print(resultat)
        print("-----------------------------------")
 
 
        soup = BeautifulSoup(resultat ,'xml')  # Mise en forme
        resultatsoup= soup.prettify()
        return resultatsoup
 
    def xml_2(self):
 
        ametropie = etree.Element("ametropie")
 
        oeil = etree.SubElement(ametropie, "oeil")
        oeil.text = f'{self.oeil}'
        sphere = etree.SubElement(ametropie, "sphere")
        sphere.text =f'{self.sphere}'
 
        cylindre = etree.SubElement(ametropie, "cylindre")
        cylindre.text = f'{self.cylindre}' 
 
        axeDuCylindre = etree.SubElement(ametropie, "axeDuCylindre")
        axeDuCylindre.text = f'{self.axeDuCylindre}' 
 
        addition = etree.SubElement(ametropie, "addition")
        addition.text = f'{self.addition}'
 
 
        photochromie = etree.SubElement(ametropie, "photochromie")
        photochromie.text = f'{self.photochromie}' 
 
 
        return etree.tostring(ametropie, pretty_print=True)
 
 
 
    def aleaoire(self):
        self.axeDuCylindre = random.randint(0, 150)
        self.sphere =  random.randrange(-100,100,4)/16
        self.cylindre =  random.randrange(-100,100,4)/16
        self.addition =  random.randrange(0,16,4)/16
        self.photochromie = random.randint(0, 1)
 
 
if __name__ == '__main__':
 
 
    ametropie_OD =Ametropie()
    ametropie_OD.oeil ="3D"
    ametropie_OD.aleaoire()
    xml_am = ametropie_OD.xml()
    print(xml_am)
    print("------------------------")
    xml_am = ametropie_OD.xml_2()
    print(xml_am)

ce qui me gène dans le résultat c'est l'affichgae que donne la class xml_2(self)
la commande de formalisation de la classe tostring extraite de "from lxml import etree " -->

Code :

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

  etree.tostring(ametropie, pretty_print=True)

me retourne ceci

Code :

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

 b'<ametropie>\n  <oeil>3D</oeil>\n  <sphere>2.5</sphere>\n  <cylindre>-4.5</cylindre>\n  <axeDuCylindre>136</axeDuCylindre>\n  <addition>0.75</addition>\n  <photochromie>1</photochromie>\n</ametropie>\n'

les métablises de formalisation des tabulations ne semblent pas pris en compte et de plus on voit apparaitre un caractère "b" devant la chaine.....

si j'ajoute une commande format-string

Code :

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

   print(f'{xml_am}')

cela ne change sur l'interprétation de /t

et si je reprendre les données du print afficher dans la console

Code :

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

    print(f"""b'<ametropie>\n  <oeil>3D</oeil>\n  <sphere>2.5</sphere>\n  <cylindre>-4.5</cylindre>\n  <axeDuCylindre>136</axeDuCylindre>\n  <addition>0.75</addition>\n  <photochromie>1</photochromie>\n</ametropie>\n'""")

Code :

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

1
2
3
4
5
6
7
8
9
b'<ametropie>
  <oeil>3D</oeil>
  <sphere>2.5</sphere>
  <cylindre>-4.5</cylindre>
  <axeDuCylindre>136</axeDuCylindre>
  <addition>0.75</addition>
  <photochromie>1</photochromie>
</ametropie>
'

le formalisme est plus propre mais ce caratère b est toujours

qu'en a beautifulsoop 4 c'est un peut mieux mais bon.....

Code XML :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="utf-8"?>
<ametropie>
 <oeil>
  3D
 </oeil>
 <sphere>
  -1.0
 </sphere>
 <cylindre>
  -2.0
 </cylindre>
 <axeDuCylindre>
  33
 </axeDuCylindre>
 <addition>
  0.5
 </addition>
 <photochromie>
  1
 </photochromie>
</ametropie>

alors si vous avez une idee elle sera bienvenue , merci

**wiztricks** · 21/08/2022, 15h05

Envoyé par dedalios

les métablises de formalisation des tabulations ne semblent pas pris en compte et de plus on voit apparaitre un caractère "b" devant la chaine.....

Le 'b' signale qu'il s'agit de bytes. Ce qui est normal pour une structure de données XML (sérialisée).

- W

Invité · 21/08/2022, 16h53

Salut !

Est-ce que ceci répond à ton problème ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> toto = b'<ametropie>\n  <oeil>3D</oeil>\n  <sphere>2.5</sphere>\n  <cylindre>-4.5</cylindre>\n  <axeDuCylindre>136</axeDuCylindre>\n  <addition>0.75</addition>\n  <photochromie>1</photochromie>\n</ametropie>\n'
 
>>> print(toto.decode('ascii'))
<ametropie>
  <oeil>3D</oeil>
  <sphere>2.5</sphere>
  <cylindre>-4.5</cylindre>
  <axeDuCylindre>136</axeDuCylindre>
  <addition>0.75</addition>
  <photochromie>1</photochromie>
</ametropie>

PS : encode et decode prennent également un argument errors

Code :

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

1
2
>>> 'Français, ℱ'.encode(encoding='ascii', errors='xmlcharrefreplace')
b'Français, ℱ'  #Le résultat visuel est différent sur une console, ici le site transforme le résultat... Essaye de ton côté !

Code :

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

1
2
3
4
>>> utf8_data = 'Français, ℱ'.encode(encoding='utf8')
 
>>> utf8_data.decode('ascii', errors='surrogateescape')
'Fran\udcc3\udca7ais, \udce2\udc84\udcb1'

**dedalios** · 22/08/2022, 12h38

il semble que l'appel a "decode" ne plait pas à python

Code :

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

1
2
3
4
5
6
7
 
if __name__ == '__main__':
 
 
    xml_am = ametropie_OD.xml_2()
    reponse =xml_am.decode('ascii')
    print(f'{reponse}')

réponse de python3

reponse =xml_am.decode('ascii')
AttributeError: 'str' object has no attribute 'decode'. Did you mean: 'encode'?

qu'as encode ....

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if __name__ == '__main__':
 
 
    ametropie_OD =Ametropie()
    ametropie_OD.oeil ="3D"
    ametropie_OD.aleaoire()
    #xml_am = ametropie_OD.xml()
    #print(xml_am)
    #print("------------------------")
 
        xml_am = ametropie_OD.xml_2()
    reponse =xml_am.encode(encoding='ascii', errors='xmlcharrefreplace')
    print(f'{reponse}')

il ajoute encore le metacaractairebinary ......
b"b'<ametropie>\\n <oeil>3D</oeil>\\n <sphere>-0.75</sphere>\\n <cylindre>-5.5</cylindre>\\n <axeDuCylindre>84</axeDuCylindre>\\n <addition>0.75</addition>\\n <photochromie>0</photochromie>\\n</ametropie>\\n'"

**wiztricks** · 22/08/2022, 13h08

Envoyé par dedalios

il semble que l'appel a "decode" ne plait pas à python

Le message d'erreur dit que "decode" (i.e. convertir bytes en str-ing) ne s'applique pas à des str-ing (déjà décodé) - mais on peut leur appliquer encode pour les transformer en bytes -.

La conversion bytes en string (et réciproquement) sont des bases, si vous appliquez bêtement ce qu'on vous raconte sans trop chercher à comprendre pourquoi, à quoi, comment,... ça ne marchera pas.

- W

**jurassic pork** · 22/08/2022, 16h44

hello,
tu peux aussi utiliser le module prettierfier qui permet de formatter du xml :

This module parses HTML/XML as a raw string to more intelligently format tags.

Code :

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

1
2
3
4
5
import prettierfier
# ......
 
#return etree.tostring(ametropie, pretty_print=True)
 return prettierfier.prettify_xml(etree.tostring(ametropie))

Code xml :

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

1
2
3
4
5
6
7
8
<ametropie>
  <oeil>3D</oeil>
  <sphere>2.25</sphere>
  <cylindre>-4.25</cylindre>
  <axeDuCylindre>114</axeDuCylindre>
  <addition>0.5</addition>
  <photochromie>1</photochromie>
</ametropie>

Ami calmant, J.P

**wiztricks** · 22/08/2022, 17h55

Envoyé par jurassic pork

tu peux aussi utiliser le module prettierfier qui permet de formatter du xml

Le PO utilise lxml.

Ce qui est plutôt correct côté pretty_print.

Mais il ne montre pas ce qui a été modifié dans la méthode Ametropie.xml_2 pour qu'elle retourne un type str à la place du type bytes qui était retourné (dans son premier post).

- W

**jurassic pork** · 22/08/2022, 18h49

Envoyé par wiztricks

Le PO utilise lxml.
Ce qui est plutôt correct côté pretty_print.
Mais il ne montre pas ce qui a été modifié dans la méthode Ametropie.xml_2 pour qu'elle retourne un type str à la place du type bytes qui était retourné (dans son premier post).

A essayer alors :

Code :

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

return etree.tostring(ametropie, pretty_print=True,  encoding = str)

**dedalios** · 22/08/2022, 19h28

Effectivement sans le forçage de l'encodage etree.tostring retourne par defaut un type BYTES.
l'ajout de la commande encoding = str régle le soucis.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
 
    def xml_2(self):
 
        ametropie = etree.Element("ametropie")
 
        oeil = etree.SubElement(ametropie, "oeil")
        oeil.text = f'{self.oeil}'
        sphere = etree.SubElement(ametropie, "sphere")
        sphere.text =f'{self.sphere}'
 
        cylindre = etree.SubElement(ametropie, "cylindre")
        cylindre.text = f'{self.cylindre}' 
 
        axeDuCylindre = etree.SubElement(ametropie, "axeDuCylindre")
        axeDuCylindre.text = f'{self.axeDuCylindre}' 
 
        addition = etree.SubElement(ametropie, "addition")
        addition.text = f'{self.addition}'
 
 
        photochromie = etree.SubElement(ametropie, "photochromie")
        photochromie.text = f'{self.photochromie}' 
 
 
        result = etree.tostring(ametropie,   pretty_print=True ,encoding='utf-8')  
        print(result)       
 
        result = etree.tostring(ametropie, pretty_print=True ,  encoding = str)  
        return  result

Invité · 22/08/2022, 21h14

Une question : faut pas mettre 'ascii' comme encodage pour du binaire XML ?

**wiztricks** · 22/08/2022, 21h48

Envoyé par LeNarvalo

Une question : faut pas mettre 'ascii' comme encodage pour du binaire XML ?

Un fichier XML est un fichier texte (pas binaire).... Et son encoding est celui qu'on veut (modulo de le préciser dans l'en-tête).

- W

Invité · 22/08/2022, 22h17

Envoyé par wiztricks

Un fichier XML est un fichier texte (pas binaire).... Et son encoding est celui qu'on veut (modulo de le préciser dans l'en-tête).

Euh bytes je voulais dire

, désolé je me mélange les pinceaux (je m'amusais avec [bin(x) for x in b'Test'] pour comprendre un peu mieux ce qu'était un byte). Tu disais plus haut : Le 'b' signale qu'il s'agit de bytes. Ce qui est normal pour une structure de données XML (sérialisée).
Mais ce format, par définition, ce n'est pas du texte du coup ?

Par contre oui effectivement, je suis c*n, ça peut prendre n'importe quel encodage... C'est pas comme si j'avais utilisé des fichiers XML dans ma jeunesse ! Alzheimer

**wiztricks** · 22/08/2022, 23h20

Envoyé par LeNarvalo

Tu disais plus haut : Le 'b' signale qu'il s'agit de bytes. Ce qui est normal pour une structure de données XML (sérialisée).
Mais ce format, par définition, ce n'est pas du texte du coup ?

Tous les fichiers contiennent des bytes... puisqu'on ne sait pas y stocker autre chose. Un fichier texte sera aussi stocké sous la forme de bytes, fabriqués avec l'encoding qui va bien.

Il y a donc une différence entre le texte Unicode qui est associé à une variable Python et ce même texte ("binaire") stocké dans le fichier. On passe d'une représentation à l'autre via encode et decode (qui seront fait par Python lorsqu'on ouvre le fichier en mode texte).

Ce qui fait qu'un fichier peut être ouvert en mode texte, c'est qu'il contient des caractères imprimables et des fins de lignes. Un fichier XML est, de ce point de vue, un fichier texte.

- W

**dedalios** · 30/08/2022, 19h45

Je cherche à ajouter une balise SAOP au XML

Le but avoir ceci

Code XML :

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

1
2
3
4
5
6
7
""" 
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <soapenv:Body>
-------------------------------XML genere--------------
    </soapenv:Body>
</soapenv:Envelope>
"""

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# coding: utf-8  
 
from lxml import etree
 
 
if __name__ == '__main__':
 
    root = etree.Element("soapenv")
 
 
 
    Envelope = etree.SubElement(root,"Envelope")
    Envelope.text = '''xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'''
    Body =  etree.SubElement(Envelope,"Body")
    code = etree.SubElement(Body,"codexml")
    code.text= 'Mon XML'
    result = etree.tostring(root, pretty_print=True ,  encoding = str)
    print(result)

voici le résultat

Code XML :

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

1
2
3
<soapenv>
  <Envelope>xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"&gt;<Body><codexml>ooooo</codexml></Body></Envelope>
</soapenv>

Petit effet problème de formalisme XML

Python

Discussions similaires

Partager

Partager