Cómo generar CDATA usando ElementTree

Question

Descubrí que cElementTree es aproximadamente 30 veces más rápido que xml.dom.minidom y estoy reescribiendo mi código de codificación/descodificación XML. Sin embargo, necesito generar XML que contenga secciones CDATA y no parece haber una manera de hacerlo con ElementTree.

¿Se puede hacer?

Answer 1

Después de un poco de trabajo, encontré la respuesta yo mismo. Al observar el código fuente de ElementTree.py, descubrí que había un manejo especial de los comentarios XML y las instrucciones de preprocesamiento. Lo que hacen es crear una función de fábrica para el tipo de elemento especial que utiliza un valor de etiqueta especial (sin cadena) para diferenciarlo de los elementos regulares.

def Comment(text=None): 
    element = Element(Comment) 
    element.text = text 
    return element 

Luego, en la función de elementtree _write que realmente genera el XML, hay un manejo de los comentarios caso especial:

if tag is Comment: 
    file.write("<!-- %s -->" % _escape_cdata(node.text, encoding)) 

Con el fin de apoyar las secciones CDATA, puedo crear una función de fábrica llamada CDATA, extendió la clase ElementTree y cambió la función _write para manejar los elementos CDATA.

Esto aún no ayuda si quiere analizar un XML con secciones CDATA y luego volverlo a generar con las secciones CDATA, pero al menos le permite crear XMLs con secciones CDATA programáticamente, que es lo que necesitaba para hacer.

La implementación parece funcionar tanto con ElementTree como con cElementTree.

import elementtree.ElementTree as etree 
#~ import cElementTree as etree 

def CDATA(text=None): 
    element = etree.Element(CDATA) 
    element.text = text 
    return element 

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

if __name__ == "__main__": 
    import sys 

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

    e = etree.Element("data") 
    cdata = CDATA(text) 
    e.append(cdata) 
    et = ElementTreeCDATA(e) 
    et.write(sys.stdout, "utf-8") 

Answer 2

No es posible AFAIK ... lo cual es una lástima. Básicamente, los módulos ElementTree suponen que el lector es 100% compatible con XML, por lo que no debería importar si generan una sección como CDATA o algún otro formato que genere el texto equivalente.

Consulte this thread en la lista de correo de Python para obtener más información. Básicamente, recomiendan algún tipo de biblioteca XML basada en DOM.

Answer 3

lxml tiene soporte para CDATA y API como elementtree.

Answer 4

En realidad este código tiene un error, ya que no se captura ]]> que aparece en los datos que se está insertando como CDATA

según Is there a way to escape a CDATA end token in xml?

usted debe dividirlo en dos de CDATA en ese caso, la división el ]]> entre los dos.

básicamente data = data.replace("]]>", "]]]]><![CDATA[>")
(no necesariamente correcta, verifique)

Answer 5

El DOM tiene (al menos en el nivel 2) una interfaz DATASection, y un documento de operación :: createCDATASection. Son interfaces de extensión , solo se admiten si una implementación admite la función "xml".

de xml.dom importación minidom

my_xmldoc = minidom.analizar (xmlfile)

my_xmldoc.createCDATASection (datos)

ahora u tener nodo cadata agregarlo donde quieres ....

Answer 6

Aquí es una variante de la solución de gooli que funciona para Python 3.2:

import xml.etree.ElementTree as etree 

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

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 


if __name__ == "__main__": 
    import sys 

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

    e = etree.Element("data") 
    cdata = CDATA(text) 
    e.append(cdata) 
    et = etree.ElementTree(e) 
    et.write(sys.stdout.buffer.raw, "utf-8") 

Answer 7

Aquí está mi versión que se basa en las respuestas de gooli y amaury anteriores. Funciona tanto para ElementTree 1.2.6 como 1.3.0, que usan métodos muy diferentes para hacer esto.

Tenga en cuenta que Gooli no funciona con 1.3.0, que parece ser el estándar actual en Python 2.7.x.

También tenga en cuenta que esta versión no utiliza el método CDATA() que Gooli usó.

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) 

Answer 8

llegué aquí buscando una manera de "analizar un XML con secciones CDATA y luego la salida de nuevo con las secciones CDATA".

Pude hacer esto (tal vez lxml se ha actualizado desde esta publicación?) Con lo siguiente: (es un poco difícil, lo siento ;-). Alguien más puede tener una mejor manera de encontrar las secciones de CDATA programáticamente, pero yo era demasiado vago.

parser = etree.XMLParser(encoding='utf-8') # my original xml was utf-8 and that was a lot of the problem 
tree = etree.parse(ppath, parser) 

for cdat in tree.findall('./ProjectXMPMetadata'): # the tag where my CDATA lives 
    cdat.text = etree.CDATA(cdat.text) 

# other stuff here 

tree.write(opath, encoding="UTF-8",) 

Answer 9

La solución aceptada no puede trabajar con Python 2.7. Sin embargo, hay otro paquete llamado lxml que (aunque un poco más lento) compartió una sintaxis en gran parte idéntica con el xml.etree.ElementTree. lxml es capaz de escribir y analizar CDATA. Documentación here

Answer 10

Esto terminó trabajando para mí en Python 2.7. Similar a la respuesta de Amaury.

import xml.etree.ElementTree as ET 

ET._original_serialize_xml = ET._serialize_xml 


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

Answer 11

he descubierto un truco para conseguir CDATA para trabajar utilizando comentarios:

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

Answer 12

No sé si las versiones anteriores del código propuesto funcionaron muy bien y si el módulo elementtree se ha actualizado, pero me he enfrentado a problemas con el uso de este truco:

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 

El problema con este enfoque es que después de pasar esta excepción, serializador es tratar de nuevo como etiqueta de la normalidad después s. Obtenía algo así como:

<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> 

Y, por supuesto, sabemos que solo causará muchos errores. ¿Por qué estaba pasando eso?

La respuesta está en este pequeño individuo:

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

No queremos a examinar el código una vez más a través de la función serializar original si hemos atrapado nuestra CDATA y superado con éxito a través de. Por lo tanto, en el bloque "if" tenemos que devolver la función de serialización original solo cuando CDATA no estaba allí. Nos faltaba "else" antes de devolver la función original.

Además, en mi versión del módulo ElementTree, serializar la función estaba pidiendo desesperadamente el argumento "short_empty_element". Así que la versión más reciente que recomendaría es similar al siguiente (también con "cola"):

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 salida me dio fue:

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

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


yay! 

les deseo el mismo resultado!