# `xml.parsers.expat` — Análisis rápido XML usando Expat

Advertencia

El módulo `pyexpat` no es seguro contra datos construidos maliciosamente. Si necesita analizar datos que no son de confianza o no autenticados, consulte Vulnerabilidades XML.

El módulo `xml.parsers.expat` es una interfaz de Python para el analizador XML no validado de Expat. El módulo proporciona un único tipo de extensión, `xmlparser`, que representa el estado actual de un analizador XML. Después de que se haya creado un objeto `xmlparser`, se pueden establecer varios atributos del objeto en funciones de controlador. Cuando se envía un documento XML al analizador, se llaman a las funciones del controlador para los datos de caracteres y el marcado en el documento XML.

Este módulo utiliza el módulo `pyexpat` para proporcionar acceso al analizador Expat. El uso directo del módulo `pyexpat` está obsoleto.

Este módulo proporciona una excepción y un tipo de objeto:

exception `xml.parsers.expat.``ExpatError`

  La excepción que se lanza cuando Expat informa un error. Consulte la sección Excepciones de ExpatError para obtener más información sobre cómo interpretar los errores de Expat.

exception `xml.parsers.expat.``error`

  Alias para `ExpatError`.

`xml.parsers.expat.``XMLParserType`

  El tipo de los valores de retorno de la función `ParserCreate()`.

El modulo `xml.parsers.expat` contiene dos funciones:

`xml.parsers.expat.``ErrorString`(errno)

  Retorna una cadena explicativa para un número de error dado errno.

`xml.parsers.expat.``ParserCreate`(encoding=None, namespace_separator=None)

  Crea y retorna un nuevo objeto `xmlparser`. encoding, si se especifica, debe ser una cadena que nombre la codificación utilizada por los datos XML. Expat no admite tantas codificaciones como Python, y su repertorio de codificaciones no se puede ampliar; es compatible con UTF-8, UTF-16, ISO-8859-1 (Latin1) y ASCII. Si se proporciona encoding 1, anulará la codificación implícita o explícita del documento.

  Expat puede, opcionalmente, realizar el procesamiento del espacio de nombres XML por usted, habilitado al proporcionar un valor para namespace_separator. El valor debe ser una cadena de un carácter; a `ValueError` se lanzará si la cadena tiene una longitud ilegal (`None` se considera lo mismo que una omisión). Cuando el procesamiento de espacios de nombres está habilitado, se expandirán los nombres de tipos de elementos y los nombres de atributos que pertenecen a un espacio de nombres. El nombre del elemento pasado a los controladores de elementos `StartElementHandler` y `EndElementHandler` será la concatenación del URI del espacio de nombres, el carácter separador del espacio de nombres y la parte local del nombre. Si el separador del espacio de nombres es un byte cero (`chr(0)`), el URI del espacio de nombres y la parte local se concatenarán sin ningún separador.

  Por ejemplo, si namespace_separator se establece en un carácter de espacio (`' '`) y se analiza el siguiente documento:

      <?xml version="1.0"?>
      <root xmlns    = "http://default-namespace.org/"
            xmlns:py = "http://www.python.org/ns/">
        <py:elem1 />
        <elem2 xmlns="" />
      </root>

  `StartElementHandler` recibirá las siguientes cadenas para cada elemento:

      http://default-namespace.org/ root
      http://www.python.org/ns/ elem1
      elem2

  Debido a las limitaciones en la biblioteca `Expat` utilizada por `pyexpat`, la instancia `xmlparser` retorna solo se puede usar para analizar un solo documento XML. Llame a `ParserCreate` para cada documento para proporcionar instancias de analizador únicas.

Ver también

El Expat XML Parser

  Página de inicio del proyecto Expat.

## Objetos XMLParser

Los objetos `xmlparser` tienen los siguientes métodos:

`xmlparser.``Parse`(data[, isfinal])

  Analiza el contenido de la cadena data, llamando a las funciones del controlador apropiadas para procesar los datos analizados. isfinal debe ser verdadero en la última llamada a este método; permite el análisis de un solo archivo en fragmentos, no el envío de varios archivos. data puede ser la cadena vacía en cualquier momento.

`xmlparser.``ParseFile`(file)

  Analizar la lectura de datos XML del objeto file. file solo necesita proporcionar el método `read(nbytes)`, devolviendo la cadena vacía cuando no hay más datos.

`xmlparser.``SetBase`(base)

  Establece la base que se utilizará para resolver URIs relativos en identificadores de sistema en declaraciones. La resolución de los identificadores relativos se deja en manos de la aplicación: este valor se pasará como el argumento base a las funciones `ExternalEntityRefHandler()`, `NotationDeclHandler()`, y `UnparsedEntityDeclHandler()`.

`xmlparser.``GetBase`()

  Retorna una cadena que contiene la base establecida por una llamada anterior a `SetBase()`, o `None` si no se ha llamado a `SetBase()`.

`xmlparser.``GetInputContext`()

  Retorna los datos de entrada que generaron el evento actual como una cadena. Los datos están en la codificación de la entidad que contiene el texto. Cuando se llama mientras un controlador de eventos no está activo, el valor de retorno es `None`.

`xmlparser.``ExternalEntityParserCreate`(context[, encoding])

  Cree un analizador «child» que se pueda utilizar para analizar una entidad analizada externa a la que hace referencia el contenido analizado por el analizador principal. El parámetro context debe ser la cadena pasada a la función del controlador `ExternalEntityRefHandler()`, que se describe a continuación. El analizador secundario se crea con `order_attributes` y `specific_attributes` establecidos en los valores de este analizador.

`xmlparser.``SetParamEntityParsing`(flag)

  Controle el análisis de las entidades de parámetros (incluido el subconjunto DTD externo). Los posibles valores de flag son `XML_PARAM_ENTITY_PARSING_NEVER`, `XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE` y `XML_PARAM_ENTITY_PARSING_ALWAYS`. Retorna verdadero si el establecimiento de la bandera fue exitoso.

`xmlparser.``UseForeignDTD`([flag])

  Llamar a esto con un valor verdadero para flag (el predeterminado) hará que Expat llame a `ExternalEntityRefHandler` con `None` para todos los argumentos para permitir que se cargue una DTD alternativa. Si el documento no contiene una declaración de tipo de documento, se seguirá llamando a `ExternalEntityRefHandler`, pero no se llamará a `StartDoctypeDeclHandler` y `EndDoctypeDeclHandler`.

  Pasar un valor falso para flag cancelará una llamada anterior que pasó un valor verdadero, pero por lo demás no tiene ningún efecto.

  Este método sólo se puede llamar antes de que se llamen los métodos `Parse()` o `ParseFile()`; llamarlo después de que cualquiera de ellos haya sido llamado causa que `ExpatError` se lanza con el atributo `code` establecido en `errors.codes[errors.XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING]`.

`xmlparser.``SetReparseDeferralEnabled`(enabled)

  Advertencia

  Calling `SetReparseDeferralEnabled(False)` has security implications, as detailed below; please make sure to understand these consequences prior to using the `SetReparseDeferralEnabled` method.

  Expat 2.6.0 introduced a security mechanism called «reparse deferral» where instead of causing denial of service through quadratic runtime from reparsing large tokens, reparsing of unfinished tokens is now delayed by default until a sufficient amount of input is reached. Due to this delay, registered handlers may — depending of the sizing of input chunks pushed to Expat — no longer be called right after pushing new input to the parser. Where immediate feedback and taking over responsiblity of protecting against denial of service from large tokens are both wanted, calling `SetReparseDeferralEnabled(False)` disables reparse deferral for the current Expat parser instance, temporarily or altogether. Calling `SetReparseDeferralEnabled(True)` allows re-enabling reparse deferral.

  Note that `SetReparseDeferralEnabled()` has been backported to some prior releases of CPython as a security fix. Check for availability of `SetReparseDeferralEnabled()` using `hasattr()` if used in code running across a variety of Python versions.

  Nuevo en la versión 3.10.14.

`xmlparser.``GetReparseDeferralEnabled`()

  Returns whether reparse deferral is currently enabled for the given Expat parser instance.

  Nuevo en la versión 3.10.14.

`xmlparser` los objetos tienen los siguientes atributos:

`xmlparser.``buffer_size`

  El tamaño del búfer usado cuando `buffer_text` es verdadero. Se puede establecer un nuevo tamaño de búfer asignando un nuevo valor entero a este atributo. Cuando se cambia el tamaño, el búfer se vaciará.

`xmlparser.``buffer_text`

  Establecer esto en true hace que el objeto `xmlparser` almacene el contenido textual retornado por Expat para evitar múltiples llamadas a la devolución de llamada `CharacterDataHandler()` siempre que sea posible. Esto puede mejorar sustancialmente el rendimiento ya que Expat normalmente divide los datos de los caracteres en trozos al final de cada línea. Este atributo es falso por defecto y se puede cambiar en cualquier momento.

`xmlparser.``buffer_used`

  Si `buffer_text` está habilitado, el número de bytes almacenados en el búfer. Estos bytes representan texto codificado en UTF-8. Este atributo no tiene una interpretación significativa cuando `buffer_text` es falso.

`xmlparser.``ordered_attributes`

  Establecer este atributo en un número entero distinto de cero hace que los atributos se informen como una lista en lugar de un diccionario. Los atributos se presentan en el orden que se encuentran en el texto del documento. Para cada atributo, se presentan dos entradas de lista: el nombre del atributo y el valor del atributo. (Las versiones anteriores de este módulo también usaban este formato). De forma predeterminada, este atributo es falso; se puede cambiar en cualquier momento.

`xmlparser.``specified_attributes`

  Si se establece en un número entero distinto de cero, el analizador informará solo los atributos que se especificaron en la instancia del documento y no los que se derivaron de declaraciones de atributos. Las aplicaciones que establecen esto deben tener especial cuidado al utilizar la información adicional disponible en las declaraciones según sea necesario para cumplir con los estándares para el comportamiento de los procesadores XML. De forma predeterminada, este atributo es falso; se puede cambiar en cualquier momento.

Los siguientes atributos contienen valores relacionados con el error más reciente encontrado por un objeto `xmlparser`, y solo tendrán los valores correctos una vez que una llamada a `Parse()` o `ParseFile()` haya lanzado una excepción `xml.parsers.expat.ExpatError`.

`xmlparser.``ErrorByteIndex`

  Índice de bytes en el que se produjo un error.

`xmlparser.``ErrorCode`

  Código numérico que especifica el problema. Este valor puede pasarse a la función `ErrorString()`, o compararse con una de las constantes definidas en el objeto `errors`.

`xmlparser.``ErrorColumnNumber`

  Número de columna en la que se produjo un error.

`xmlparser.``ErrorLineNumber`

  Número de línea en la que ocurrió un error.

Los siguientes atributos contienen valores relacionados con la ubicación actual del análisis en un objeto `xmlparser`. Durante una devolución de llamada que informa un evento de análisis, indican la ubicación del primero de la secuencia de caracteres que generó el evento. Cuando se llama fuera de una devolución de llamada, la posición indicada estará justo después del último evento de análisis (independientemente de si hubo una devolución de llamada asociada).

`xmlparser.``CurrentByteIndex`

  Índice de bytes actual en la entrada del analizador.

`xmlparser.``CurrentColumnNumber`

  Número de columna actual en la entrada del analizador.

`xmlparser.``CurrentLineNumber`

  Número de línea actual en la entrada del analizador.

Aquí está la lista de controladores que se pueden configurar. Para configurar un controlador en un objeto `xmlparser` o, use `o.handlername = func`. handlername debe tomarse de la siguiente lista, y func debe ser un objeto invocable que acepte el número correcto de argumentos. Los argumentos son todos cadenas, a menos que se indique lo contrario.

`xmlparser.``XmlDeclHandler`(version, encoding, standalone)

  Se llama cuando se analiza la declaración XML. La declaración XML es la declaración (opcional) de la versión aplicable de la recomendación XML, la codificación del texto del documento y una declaración «independiente» opcional. version y encoding serán cadenas, y standalone será `1` si el documento se declara independiente, `0` si se declara no independiente o `-1` si se omitió la cláusula independiente. Esto solo está disponible con la versión Expat 1.95.0 o más reciente.

`xmlparser.``StartDoctypeDeclHandler`(doctypeName, systemId, publicId, has_internal_subset)

  Se llama cuando Expat comienza a analizar la declaración del tipo de documento (`<! DOCTYPE ...`). El doctypeName se proporciona exactamente como se presenta. Los parámetros systemId y publicId dan el sistema y los identificadores públicos si se especifican, o `None` si se omite. has_internal_subset será verdadero si el documento contiene un subconjunto de declaración de documento interno. Esto requiere Expat versión 1.2 o más reciente.

`xmlparser.``EndDoctypeDeclHandler`()

  Se llama cuando Expat termina de analizar la declaración del tipo de documento. Esto requiere Expat versión 1.2 o más reciente.

`xmlparser.``ElementDeclHandler`(name, model)

  Se llama una vez para cada declaración de tipo de elemento. name es el nombre del tipo de elemento y model es una representación del modelo de contenido.

`xmlparser.``AttlistDeclHandler`(elname, attname, type, default, required)

  Se llama para cada atributo declarado para un tipo de elemento. Si una declaración de lista de atributos declara tres atributos, este controlador se llama tres veces, una para cada atributo. elname es el nombre del elemento al que se aplica la declaración y attname es el nombre del atributo declarado. El tipo de atributo es una cadena pasada como type; los valores posibles son `'CDATA'`, `'ID'`, `'IDREF'`, … default da el valor predeterminado para el atributo utilizado cuando el atributo no está especificado por el instancia de documento, o `None` si no hay un valor predeterminado (valores `#IMPLIED`). Si se requiere que el atributo se proporcione en la instancia del documento, required será verdadero. Esto requiere la versión Expat 1.95.0 o más reciente.

`xmlparser.``StartElementHandler`(name, attributes)

  Llamado para el inicio de cada elemento. name es una cadena que contiene el nombre del elemento, y attributes son los atributos del elemento. Si `order_attributes` es verdadero, esta es una lista (ver `order_attributes` para una descripción completa). De lo contrario, es un diccionario que asigna nombres a valores.

`xmlparser.``EndElementHandler`(name)

  Llamado al final de cada elemento.

`xmlparser.``ProcessingInstructionHandler`(target, data)

  Llamado para cada instrucción de procesamiento.

`xmlparser.``CharacterDataHandler`(data)

  Llamado para datos de personajes. Esto se llamará para datos de caracteres normales, contenido marcado CDATA y espacios en blanco ignorables. Las aplicaciones que deben distinguir estos casos pueden usar las devoluciones de llamada `StartCdataSectionHandler`, `EndCdataSectionHandler`, y `ElementDeclHandler` para recopilar la información requerida.

`xmlparser.``UnparsedEntityDeclHandler`(entityName, base, systemId, publicId, notationName)

  Se llama para declaraciones de entidad sin analizar (NDATA). Esto solo está presente para la versión 1.2 de la biblioteca Expat; para versiones más recientes, use `EntityDeclHandler` en su lugar. (La función subyacente en la biblioteca Expat se ha declarado obsoleta).

`xmlparser.``EntityDeclHandler`(entityName, is_parameter_entity, value, base, systemId, publicId, notationName)

  Llamado para todas las declaraciones de entidad. Para parámetros y entidades internas, value será una cadena que proporciona el contenido declarado de la entidad; esto será `None` para entidades externas. El parámetro notationName será `None` para las entidades analizadas y el nombre de la notación para las entidades no analizadas. is_parameter_entity será verdadero si la entidad es una entidad de parámetro o falso para las entidades generales (la mayoría de las aplicaciones solo deben preocuparse por las entidades generales). Esto solo está disponible a partir de la versión 1.95.0 de la biblioteca Expat.

`xmlparser.``NotationDeclHandler`(notationName, base, systemId, publicId)

  Se llama para declaraciones de notación. notationName, base y systemId y publicId son cadenas si se dan. Si se omite el identificador público, publicId será `None`.

`xmlparser.``StartNamespaceDeclHandler`(prefix, uri)

  Se llama cuando un elemento contiene una declaración de espacio de nombres. Las declaraciones de espacio de nombres se procesan antes de que se llame a `StartElementHandler` para el elemento en el que se colocan las declaraciones.

`xmlparser.``EndNamespaceDeclHandler`(prefix)

  Se llama cuando se alcanza la etiqueta de cierre para un elemento que contiene una declaración de espacio de nombres. Esto se llama una vez para cada declaración de espacio de nombres en el elemento en el orden inverso al que se llamó `StartNamespaceDeclHandler` para indicar el inicio del alcance de cada declaración de espacio de nombres. Las llamadas a este controlador se realizan después del correspondiente `EndElementHandler` para el final del elemento.

`xmlparser.``CommentHandler`(data)

  Llamado para comentarios. data es el texto del comentario, excluyendo el `'<!-``-'` inicial y el final `'-``->'`.

`xmlparser.``StartCdataSectionHandler`()

  Llamado al comienzo de una sección CDATA. Esto y `EndCdataSectionHandler` son necesarios para poder identificar el inicio sintáctico y el final de las secciones CDATA.

`xmlparser.``EndCdataSectionHandler`()

  Llamado al final de una sección CDATA.

`xmlparser.``DefaultHandler`(data)

  Se invoca por cualquier carácter del documento XML para el que no se ha especificado ningún controlador aplicable. Esto significa caracteres que forman parte de una construcción que se podría informar, pero para los que no se ha proporcionado ningún controlador.

`xmlparser.``DefaultHandlerExpand`(data)

  Es lo mismo que `DefaultHandler()`, pero no inhibe la expansión de entidades internas. La referencia de la entidad no se pasará al controlador predeterminado.

`xmlparser.``NotStandaloneHandler`()

  Se llama si el documento XML no se ha declarado como un documento independiente. Esto sucede cuando hay un subconjunto externo o una referencia a una entidad de parámetro, pero la declaración XML no establece independiente en `yes` en una declaración XML. Si este controlador retorna `0`, el analizador lanzará un error `XML_ERROR_NOT_STANDALONE`. Si este controlador no está configurado, el analizador no lanza ninguna excepción para esta condición.

`xmlparser.``ExternalEntityRefHandler`(context, base, systemId, publicId)

  Llamado para referencias a entidades externas. base es la base actual, según lo establecido por una llamada anterior a `SetBase()`. Los identificadores público y del sistema, systemId y publicId, son cadenas si se dan; si no se proporciona el identificador público, publicId será `None`. El valor context es opaco y solo debe usarse como se describe a continuación.

  Para que se analicen las entidades externas, se debe implementar este controlador. Es responsable de crear el sub-analizador usando `ExternalEntityParserCreate(context)`, inicializándolo con las devoluciones de llamada apropiadas y analizando la entidad. Este controlador debería devolver un número entero; si retorna `0`, el analizador lanzará un error `XML_ERROR_EXTERNAL_ENTITY_HANDLING`; de lo contrario, el análisis continuará.

  Si no se proporciona este controlador, las entidades externas se informan mediante la devolución de llamada `DefaultHandler`, si se proporciona.

## Excepciones de ExpatError

Las excepciones `ExpatError` tienen una serie de atributos interesantes:

`ExpatError.``code`

  Número de error interno del expatriado para el error específico. El diccionario `errors.messages` asigna estos números de error a los mensajes de error de Expat. Por ejemplo:

      from xml.parsers.expat import ParserCreate, ExpatError, errors

      p = ParserCreate()
      try:
          p.Parse(some_xml_document)
      except ExpatError as err:
          print("Error:", errors.messages[err.code])

  El módulo `errors` también proporciona constantes de mensajes de error y un diccionario `codes` mapeando estos mensajes a los códigos de error, ver más abajo.

`ExpatError.``lineno`

  Número de línea en la que se detectó el error. La primera línea está numerada como `1`.

`ExpatError.``offset`

  Carácter desplazado en la línea donde ocurrió el error. La primera columna está numerada como `0`.

## Ejemplo

El siguiente programa define tres controladores que simplemente imprimen sus argumentos.

    import xml.parsers.expat

    # 3 handler functions
    def start_element(name, attrs):
        print('Start element:', name, attrs)
    def end_element(name):
        print('End element:', name)
    def char_data(data):
        print('Character data:', repr(data))

    p = xml.parsers.expat.ParserCreate()

    p.StartElementHandler = start_element
    p.EndElementHandler = end_element
    p.CharacterDataHandler = char_data

    p.Parse("""<?xml version="1.0"?>
    <parent id="top"><child1 name="paul">Text goes here</child1>
    <child2 name="fred">More text</child2>
    </parent>""", 1)

La salida de este programa es:

    Start element: parent {'id': 'top'}
    Start element: child1 {'name': 'paul'}
    Character data: 'Text goes here'
    End element: child1
    Character data: '\n'
    Start element: child2 {'name': 'fred'}
    Character data: 'More text'
    End element: child2
    Character data: '\n'
    End element: parent

## Descripciones del modelo de contenido

Los modelos de contenido se describen mediante tuplas anidadas. Cada tupla contiene cuatro valores: el tipo, el cuantificador, el nombre y una tupla de niños. Los niños son simplemente descripciones adicionales del modelo de contenido.

Los valores de los dos primeros campos son constantes definidas en el módulo `xml.parsers.expat.model`. Estas constantes se pueden recopilar en dos grupos: el grupo de tipo de modelo y el grupo de cuantificador.

Las constantes en el grupo de tipos de modelo son:

`xml.parsers.expat.model.``XML_CTYPE_ANY`

  Se declaró que el elemento nombrado por el nombre del modelo tiene un modelo de contenido de `ANY`.

`xml.parsers.expat.model.``XML_CTYPE_CHOICE`

  El elemento nombrado permite elegir entre varias opciones; se utiliza para modelos de contenido como `(A | B | C)`.

`xml.parsers.expat.model.``XML_CTYPE_EMPTY`

  Los elementos que se declaran `EMPTY` tienen este tipo de modelo.

`xml.parsers.expat.model.``XML_CTYPE_MIXED`

`xml.parsers.expat.model.``XML_CTYPE_NAME`

`xml.parsers.expat.model.``XML_CTYPE_SEQ`

  Los modelos que representan una serie de modelos que siguen uno tras otro se indican con este tipo de modelo. Se utiliza para modelos como `(A, B, C)`.

Las constantes en el grupo cuantificador son:

`xml.parsers.expat.model.``XML_CQUANT_NONE`

  No se proporciona ningún modificador, por lo que puede aparecer exactamente una vez, como para `A`.

`xml.parsers.expat.model.``XML_CQUANT_OPT`

  El modelo es opcional: puede aparecer una vez o no aparecer, como para `A?`.

`xml.parsers.expat.model.``XML_CQUANT_PLUS`

  El modelo debe aparecer una o más veces (como `A+`).

`xml.parsers.expat.model.``XML_CQUANT_REP`

  El modelo debe aparecer cero o más veces, como en `A*`.

## Constantes de error de expansión

Las siguientes constantes se proporcionan en el módulo `xml.parsers.expat.errors`. Estas constantes son útiles para interpretar algunos de los atributos de los objetos de excepción `ExpatError` que se lanzaran cuando se produce un error. Dado que, por razones de compatibilidad con versiones anteriores, el valor de las constantes es el message de error y no el code de error numérico, puede hacer esto comparando su atributo `code` con `errors.codes[errors.XML_ERROR_CONSTANT_NAME]`.

El módulo `errors` tiene los siguientes atributos:

`xml.parsers.expat.errors.``codes`

  Un diccionario que asigna descripciones de cadenas a sus códigos de error.

  Nuevo en la versión 3.2.

`xml.parsers.expat.errors.``messages`

  Un diccionario que asigna códigos de error numéricos a sus descripciones de cadenas.

  Nuevo en la versión 3.2.

`xml.parsers.expat.errors.``XML_ERROR_ASYNC_ENTITY`

`xml.parsers.expat.errors.``XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF`

  Una referencia de entidad en un valor de atributo se refiere a una entidad externa en lugar de una entidad interna.

`xml.parsers.expat.errors.``XML_ERROR_BAD_CHAR_REF`

  Una referencia de carácter se refiere a un carácter que es ilegal en XML (por ejemplo, carácter `0`, o “`&#0;`”).

`xml.parsers.expat.errors.``XML_ERROR_BINARY_ENTITY_REF`

  Una referencia de entidad se refería a una entidad que se declaró con una notación, por lo que no se puede analizar.

`xml.parsers.expat.errors.``XML_ERROR_DUPLICATE_ATTRIBUTE`

  Un atributo se utilizó más de una vez en una etiqueta de inicio.

`xml.parsers.expat.errors.``XML_ERROR_INCORRECT_ENCODING`

`xml.parsers.expat.errors.``XML_ERROR_INVALID_TOKEN`

  Se lanza cuando un byte de entrada no se puede asignar correctamente a un carácter; por ejemplo, un byte NUL (valor `0`) en un flujo de entrada UTF-8.

`xml.parsers.expat.errors.``XML_ERROR_JUNK_AFTER_DOC_ELEMENT`

  Se produjo algo diferente a los espacios en blanco después del elemento del documento.

`xml.parsers.expat.errors.``XML_ERROR_MISPLACED_XML_PI`

  Se encontró una declaración XML en algún lugar que no sea el comienzo de los datos de entrada.

`xml.parsers.expat.errors.``XML_ERROR_NO_ELEMENTS`

  El documento no contiene elementos (XML requiere que todos los documentos contengan exactamente un elemento de nivel superior)..

`xml.parsers.expat.errors.``XML_ERROR_NO_MEMORY`

  Expat no pudo asignar memoria internamente.

`xml.parsers.expat.errors.``XML_ERROR_PARAM_ENTITY_REF`

  Se encontró una referencia de entidad de parámetro donde no estaba permitida.

`xml.parsers.expat.errors.``XML_ERROR_PARTIAL_CHAR`

  Se encontró un carácter incompleto en la entrada.

`xml.parsers.expat.errors.``XML_ERROR_RECURSIVE_ENTITY_REF`

  Una referencia de entidad contenía otra referencia a la misma entidad; posiblemente a través de un nombre diferente, y posiblemente indirectamente.

`xml.parsers.expat.errors.``XML_ERROR_SYNTAX`

  Se encontró algún error de sintaxis no especificado.

`xml.parsers.expat.errors.``XML_ERROR_TAG_MISMATCH`

  Una etiqueta final no coincidía con la etiqueta inicial abierta más interna.

`xml.parsers.expat.errors.``XML_ERROR_UNCLOSED_TOKEN`

  Algún token (como una etiqueta de inicio) no se cerró antes del final de la transmisión o se encontró el siguiente token.

`xml.parsers.expat.errors.``XML_ERROR_UNDEFINED_ENTITY`

  Se hizo referencia a una entidad que no estaba definida.

`xml.parsers.expat.errors.``XML_ERROR_UNKNOWN_ENCODING`

  La codificación del documento no es compatible con Expat.

`xml.parsers.expat.errors.``XML_ERROR_UNCLOSED_CDATA_SECTION`

  No se cerró una sección marcada con CDATA.

`xml.parsers.expat.errors.``XML_ERROR_EXTERNAL_ENTITY_HANDLING`

`xml.parsers.expat.errors.``XML_ERROR_NOT_STANDALONE`

  El analizador determinó que el documento no era «independiente» aunque se declaró en la declaración XML, y el `NotStandaloneHandler` se estableció y devolvió `0`.

`xml.parsers.expat.errors.``XML_ERROR_UNEXPECTED_STATE`

`xml.parsers.expat.errors.``XML_ERROR_ENTITY_DECLARED_IN_PE`

`xml.parsers.expat.errors.``XML_ERROR_FEATURE_REQUIRES_XML_DTD`

  Se solicitó una operación que requiere que se compile el soporte DTD, pero Expat se configuró sin soporte DTD. Esto nunca debería ser informado por una compilación estándar del módulo `xml.parsers.expat`.

`xml.parsers.expat.errors.``XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING`

  Se solicitó un cambio de comportamiento después de que comenzó el análisis que solo se puede cambiar antes de que haya comenzado el análisis. Esto (actualmente) solo lanzado por `UseForeignDTD()`.

`xml.parsers.expat.errors.``XML_ERROR_UNBOUND_PREFIX`

  Se encontró un prefijo no declarado cuando se habilitó el procesamiento del espacio de nombres.

`xml.parsers.expat.errors.``XML_ERROR_UNDECLARING_PREFIX`

  El documento intentó eliminar la declaración de espacio de nombres asociada con un prefijo.

`xml.parsers.expat.errors.``XML_ERROR_INCOMPLETE_PE`

  El documento no contenía ningún elemento de documento.

`xml.parsers.expat.errors.``XML_ERROR_XML_DECL`

  El documento no contenía ningún elemento de documento.

`xml.parsers.expat.errors.``XML_ERROR_TEXT_DECL`

  Se produjo un error al analizar una declaración de texto en una entidad externa.

`xml.parsers.expat.errors.``XML_ERROR_PUBLICID`

  Se encontraron caracteres en la identificación pública que no están permitidos.

`xml.parsers.expat.errors.``XML_ERROR_SUSPENDED`

  La operación solicitada se realizó en un analizador suspendido, pero no está permitida. Esto incluye intentos de proporcionar información adicional o detener el analizador.

`xml.parsers.expat.errors.``XML_ERROR_NOT_SUSPENDED`

  Se realizó un intento de reanudar el analizador cuando no se había suspendido.

`xml.parsers.expat.errors.``XML_ERROR_ABORTED`

  Esto no se debe informar a las aplicaciones Python.

`xml.parsers.expat.errors.``XML_ERROR_FINISHED`

  La operación solicitada se realizó en un analizador que terminó de analizar la entrada, pero no está permitido. Esto incluye intentos de proporcionar información adicional o detener el analizador.

`xml.parsers.expat.errors.``XML_ERROR_SUSPEND_PE`

Notas al pie

1

  La cadena de codificación incluida en la salida XML debe cumplir con los estándares apropiados. Por ejemplo, «UTF-8» es válido, pero «UTF8» no lo es. Consulte https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl y https://www.iana.org/assignments/character-sets/character-sets.xhtml.