This module defines a class XMLParser which serves as the basis
for parsing text files formatted in XML (eXtended Markup Language).
- XMLParser ()
-
The XMLParser class must be instantiated without arguments.
This class provides the following interface methods:
- reset ()
-
Reset the instance. Loses all unprocessed data. This is called
implicitly at the instantiation time.
- setnomoretags ()
-
Stop processing tags. Treat all following input as literal input
(CDATA).
- setliteral ()
-
Enter literal mode (CDATA mode).
- feed (data)
-
Feed some text to the parser. It is processed insofar as it consists
of complete elements; incomplete data is buffered until more data is
fed or close() is called.
- close ()
-
Force processing of all buffered data as if it were followed by an
end-of-file mark. This method may be redefined by a derived class to
define additional processing at the end of the input, but the
redefined version should always call close().
- translate_references (data)
-
Translate all entity and character references in data and
returns the translated string.
- handle_xml (encoding, standalone)
-
This method is called when the "<?xml ...?>" tag is processed.
The arguments are the values of the encoding and standalone attributes
in the tag. Both encoding and standalone are optional. The values
passed to handle_xml() default to None and the string
'no' respectively.
- handle_doctype (tag, data)
-
This method is called when the "<!DOCTYPE...>" tag is processed.
The arguments are the name of the root element and the uninterpreted
contents of the tag, starting after the white space after the name of
the root element.
- handle_starttag (tag, method, attributes)
-
This method is called to handle start tags for which a
start_tag() method has been defined. The tag
argument is the name of the tag, and the method argument is the
bound method which should be used to support semantic interpretation
of the start tag. The attributes argument is a dictionary of
attributes, the key being the name and the value being the
value of the attribute found inside the tag's <> brackets.
Character and entity references in the value have
been interpreted. For instance, for the tag
<A HREF="http://www.cwi.nl/">, this method would be called as
handle_starttag('A', self.start_A, {'HREF': 'http://www.cwi.nl/'}).
The base implementation simply calls method with attributes
as the only argument.
- handle_endtag (tag, method)
-
This method is called to handle endtags for which an
end_tag() method has been defined. The tag
argument is the name of the tag, and the
method argument is the bound method which should be used to
support semantic interpretation of the end tag. If no
end_tag() method is defined for the closing element, this
handler is not called. The base implementation simply calls
method.
- handle_data (data)
-
This method is called to process arbitrary data. It is intended to be
overridden by a derived class; the base class implementation does
nothing.
- handle_charref (ref)
-
This method is called to process a character reference of the form
"&#ref;". ref can either be a decimal number,
or a hexadecimal number when preceded by an "x".
In the base implementation, ref must be a number in the
range 0-255. It translates the character to ASCII and calls the
method handle_data() with the character as argument. If
ref is invalid or out of range, the method
unknown_charref(ref) is called to handle the error. A
subclass must override this method to provide support for character
references outside of the ASCII range.
- handle_entityref (ref)
-
This method is called to process a general entity reference of the
form "&ref;" where ref is an general entity
reference. It looks for ref in the instance (or class)
variable entitydefs which should be a mapping from entity
names to corresponding translations.
If a translation is found, it calls the method handle_data()
with the translation; otherwise, it calls the method
unknown_entityref(ref). The default entitydefs
defines translations for &, &apos, >,
<, and ".
- handle_comment (comment)
-
This method is called when a comment is encountered. The
comment argument is a string containing the text between the
"<!-" and "->" delimiters, but not the delimiters
themselves. For example, the comment "<!-text->" will
cause this method to be called with the argument 'text'. The
default method does nothing.
- handle_cdata (data)
-
This method is called when a CDATA element is encountered. The
data argument is a string containing the text between the
"<![CDATA[" and "]]>" delimiters, but not the delimiters
themselves. For example, the entity "<![CDATA[text]]>" will
cause this method to be called with the argument 'text'. The
default method does nothing, and is intended to be overridden.
- handle_proc (name, data)
-
This method is called when a processing instruction (PI) is
encountered. The name is the PI target, and the data
argument is a string containing the text between the PI target and the
closing delimiter, but not the delimiter itself. For example, the
instruction "<?XML text?>" will cause this method to be called
with the arguments 'XML' and 'text'. The default method
does nothing. Note that if a document starts with "<?xml
...?>", handle_xml() is called to handle it.
- handle_special (data)
-
This method is called when a declaration is encountered. The
data argument is a string containing the text between the
"<!" and ">" delimiters, but not the delimiters
themselves. For example, the entity "<!ENTITY text>" will
cause this method to be called with the argument 'ENTITY text'. The
default method does nothing. Note that "<!DOCTYPE ...>" is
handled separately if it is located at the start of the document.
- syntax_error (message)
-
This method is called when a syntax error is encountered. The
message is a description of what was wrong. The default method
raises a RuntimeError exception. If this method is
overridden, it is permissable for it to return. This method is only
called when the error can be recovered from. Unrecoverable errors
raise a RuntimeError without first calling
syntax_error().
- unknown_starttag (tag, attributes)
-
This method is called to process an unknown start tag. It is intended
to be overridden by a derived class; the base class implementation
does nothing.
- unknown_endtag (tag)
-
This method is called to process an unknown end tag. It is intended
to be overridden by a derived class; the base class implementation
does nothing.
- unknown_charref (ref)
-
This method is called to process unresolvable numeric character
references. It is intended to be overridden by a derived class; the
base class implementation does nothing.
- unknown_entityref (ref)
-
This method is called to process an unknown entity reference. It is
intended to be overridden by a derived class; the base class
implementation does nothing.
Apart from overriding or extending the methods listed above, derived
classes may also define methods and variables of the following form to
define processing of specific tags. Tag names in the input stream are
case dependent; the tag occurring in method names must be in the
correct case:
- start_tag (attributes)
-
This method is called to process an opening tag tag. The
attributes argument has the same meaning as described for
handle_starttag() above. In fact, the base implementation of
handle_starttag() calls this method.
- end_tag ()
-
This method is called to process a closing tag tag.
- tag_attributes
-
If a class or instance variable tag_attributes exists, it
should be a list or a dictionary. If a list, the elements of the list
are the valid attributes for the element tag; if a dictionary,
the keys are the valid attributes for the element tag, and the
values the default values of the attributes, or None if there
is no default.
In addition to the attributes that were present in the tag, the
attribute dictionary that is passed to handle_starttag() and
unknown_starttag() contains values for all attributes that
have a default value.
