Comment sortie CDATA à l'aide de ElementTree

lxml a un support pour CDATA et de l'API comme ElementTree.

Solution:

import xml.etree.ElementTree as ElementTree

def CDATA(text=None):
    element = ElementTree.Element('![CDATA[')
    element.text = text
    return element

ElementTree._original_serialize_xml = ElementTree._serialize_xml
def _serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs):
    if elem.tag == '![CDATA[':
        write("\n<{}{}]]>\n".format(elem.tag, elem.text))
        if elem.tail:
            write(_escape_cdata(elem.tail))
    else:
        return ElementTree._original_serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs)

ElementTree._serialize_xml = ElementTree._serialize['xml'] = _serialize_xml

if __name__ == "__main__":
    import sys

text = """
<?xml version='1.0' encoding='utf-8'?>
<text>
This is just some sample text.
</text>
"""

e = ElementTree.Element("data")
cdata = CDATA(text)
root.append(cdata)

De fond:

Je ne sais pas si les versions précédentes du projet de code a très bien fonctionné et si ElementTree module a été mis à jour mais j'ai été confronté à des problèmes avec l'utilisation de cette astuce:

etree._original_serialize_xml = etree._serialize_xml
def _serialize_xml(write, elem, qnames, namespaces):
    if elem.tag == '![CDATA[':
        write("\n<%s%s]]>\n" % (
                elem.tag, elem.text))
        return
    return etree._original_serialize_xml(
        write, elem, qnames, namespaces)
etree._serialize_xml = etree._serialize['xml'] = _serialize_xml

Le problème avec cette approche est que, après le passage de cette exception, sérialiseur est de nouveau traiter comme une balise par la suite. J'ai été faire quelque chose comme:

<textContent>
<![CDATA[this was the code I wanted to put inside of CDATA]]>
<![CDATA[>this was the code I wanted to put inside of CDATA</![CDATA[>
</textContent>

Et bien sûr, nous savons qui va provoquer de nombreuses erreurs.
Le pourquoi de ce qui se passe si?

La réponse est dans ce petit gars:

return etree._original_serialize_xml(write, elem, qnames, namespaces)

Nous ne voulons pas examiner le code, une fois encore, à travers serialise fonction si nous avons pris au piège de notre CDATA et de passer avec succès à travers.
Par conséquent, dans le bloc "if", nous devons retourner original de la fonction serialize uniquement lorsque CDATA n'était pas là. Il nous manquait "d'autre", avant de revenir fonction d'origine.

D'ailleurs, dans ma version ElementTree module, fonction serialize était désespérément en demandant "short_empty_element" argument. Donc la version la plus récente, je recommanderais ressemble à ceci(également avec la "queue"):

from xml.etree import ElementTree
from xml import etree

#in order to test it you have to create testing.xml file in the folder with the script
xmlParsedWithET = ElementTree.parse("testing.xml")
root = xmlParsedWithET.getroot()

def CDATA(text=None):
    element = ElementTree.Element('![CDATA[')
    element.text = text
    return element

ElementTree._original_serialize_xml = ElementTree._serialize_xml

def _serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs):

    if elem.tag == '![CDATA[':
        write("\n<{}{}]]>\n".format(elem.tag, elem.text))
        if elem.tail:
            write(_escape_cdata(elem.tail))
    else:
        return ElementTree._original_serialize_xml(write, elem, qnames, namespaces,short_empty_elements, **kwargs)

ElementTree._serialize_xml = ElementTree._serialize['xml'] = _serialize_xml


text = """
<?xml version='1.0' encoding='utf-8'?>
<text>
This is just some sample text.
</text>
"""
e = ElementTree.Element("data")
cdata = CDATA(text)
root.append(cdata)

#tests
print(root)
print(root.getchildren()[0])
print(root.getchildren()[0].text + "\n\nyay!")

La sortie que j'ai eu était:

<Element 'Database' at 0x10062e228>
<Element '![CDATA[' at 0x1021cc9a8>

<?xml version='1.0' encoding='utf-8'?>
<text>
This is just some sample text.
</text>


yay!

Je vous souhaite le même résultat!

Il n'est pas possible autant que je sache... ce qui est dommage. Fondamentalement, ElementTree modules de supposer que le lecteur est 100% compatible XML, donc il ne devrait pas s'ils ont sortie une section CDATA ou d'un autre format que génère l'équivalent de texte.

Voir ce fil sur le Python liste de diffusion pour plus d'info. Fondamentalement, ils recommandent une sorte de DOM XML basé sur la bibliothèque la place.

J'ai découvert un hack pour obtenir CDATA de travail à l'aide de commentaires:

node.append(etree.Comment(' --><![CDATA[' + data.replace(']]>', ']]]]><![CDATA[>') + ']]><!-- '))

La solution retenue ne peut pas travailler avec Python 2.7. Cependant, il y a un autre paquet appelé lxml qui (bien que légèrement plus lent), a partagé une grande partie identique syntaxe avec le xml.etree.ElementTree. lxml est capable d'écrire et d'analyser CDATA. Documentation ici

Voici ma version qui est basé sur les deux gooli et amaury réponses ci-dessus. Il fonctionne pour les ElementTree 1.2.6 et 1.3.0, qui utilisent des méthodes très différentes de le faire.

Noter que gooli de ne pas travailler avec 1.3.0, ce qui semble être la norme actuelle de Python 2.7.x.

Noter également que cette version n'utilise pas la CDATA() la méthode gooli utilisé.

import xml.etree.cElementTree as ET

class ElementTreeCDATA(ET.ElementTree):
    """Subclass of ElementTree which handles CDATA blocks reasonably"""

    def _write(self, file, node, encoding, namespaces):
        """This method is for ElementTree <= 1.2.6"""

        if node.tag == '![CDATA[':
            text = node.text.encode(encoding)
            file.write("\n<![CDATA[%s]]>\n" % text)
        else:
            ET.ElementTree._write(self, file, node, encoding, namespaces)

    def _serialize_xml(write, elem, qnames, namespaces):
        """This method is for ElementTree >= 1.3.0"""

        if elem.tag == '![CDATA[':
            write("\n<![CDATA[%s]]>\n" % elem.text)
        else:
            ET._serialize_xml(write, elem, qnames, namespaces)

pour python3 et ElementTree vous pouvez utiliser suivant la réception

import xml.etree.ElementTree as ET

ET._original_serialize_xml = ET._serialize_xml


def serialize_xml_with_CDATA(write, elem, qnames, namespaces, short_empty_elements, **kwargs):
    if elem.tag == 'CDATA':
        write("<![CDATA[{}]]>".format(elem.text))
        return
    return ET._original_serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs)


ET._serialize_xml = ET._serialize['xml'] = serialize_xml_with_CDATA


def CDATA(text):
   element =  ET.Element("CDATA")
   element.text = text
   return element


my_xml = ET.Element("my_name")
my_xml.append(CDATA("<p>some text</p>")

tree = ElementTree(my_xml)

si vous avez besoin d'un document xml comme str, vous pouvez utiliser

ET.tostring(tree)

ou suivant hack (qui a presque le même que le code à l'intérieur de tostring())

fake_file = BytesIO()
tree.write(fake_file, encoding="utf-8", xml_declaration=True)
result_xml_text = str(fake_file.getvalue(), encoding="utf-8")

et obtenez le résultat

<?xml version='1.0' encoding='utf-8'?>
<my_name>
  <![CDATA[<p>some text</p>]]>
</my_name>