saxlib.py

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

    (as opposed to what it contains, which is reported to the
    ContentHandler), such as comments and CDATA marked section
    boundaries.

    To set the LexicalHandler of an XMLReader, use the setProperty
    method with the property identifier
    'http://xml.org/sax/handlers/LexicalHandler'. There is no
    guarantee that the XMLReader will support or recognize this
    property."""

    def comment(self, content):
        """Reports a comment anywhere in the document (including the
        DTD and outside the document element).

        content is a string that holds the contents of the comment."""

    def startDTD(self, name, public_id, system_id):
        """Report the start of the DTD declarations, if the document
        has an associated DTD.

        A startEntity event will be reported before declaration events
        from the external DTD subset are reported, and this can be
        used to infer from which subset DTD declarations derive.

        name is the name of the document element type, public_id the
        public identifier of the DTD (or None if none were supplied)
        and system_id the system identfier of the external subset (or
        None if none were supplied)."""

    def endDTD(self):
        "Signals the end of DTD declarations."

    def startEntity(self, name):
        """Report the beginning of an entity.

        The start and end of the document entity is not reported. The
        start and end of the external DTD subset is reported with the
        pseudo-name '[dtd]'.

        Skipped entities will be reported through the skippedEntity
        event of the ContentHandler rather than through this event.

        name is the name of the entity. If it is a parameter entity,
        the name will begin with '%'."""

    def endEntity(self, name):
        """Reports the end of an entity. name is the name of the
        entity, and follows the same conventions as for
        startEntity."""

    def startCDATA(self):
        """Reports the beginning of a CDATA marked section.

        The contents of the CDATA marked section will be reported
        through the characters event."""

    def endCDATA(self):
        "Reports the end of a CDATA marked section."


#============================================================================
#
# SAX 1.0 COMPATIBILITY CLASSES
# Note that these are all deprecated.
#
#============================================================================

# ===== ATTRIBUTELIST =====

class AttributeList:
    """Interface for an attribute list. This interface provides
    information about a list of attributes for an element (only
    specified or defaulted attributes will be reported). Note that the
    information returned by this object will be valid only during the
    scope of the DocumentHandler.startElement callback, and the
    attributes will not necessarily be provided in the order declared
    or specified."""

    def getLength(self):
        "Return the number of attributes in list."

    def getName(self, i):
        "Return the name of an attribute in the list."

    def getType(self, i):
        """Return the type of an attribute in the list. (Parameter can be
        either integer index or attribute name.)"""

    def getValue(self, i):
        """Return the value of an attribute in the list. (Parameter can be
        either integer index or attribute name.)"""

    def __len__(self):
        "Alias for getLength."

    def __getitem__(self, key):
        "Alias for getName (if key is an integer) and getValue (if string)."

    def keys(self):
        "Returns a list of the attribute names."

    def has_key(self, key):
        "True if the attribute is in the list, false otherwise."

    def get(self, key, alternative=None):
        """Return the value associated with attribute name; if it is not
        available, then return the alternative."""

    def copy(self):
        "Return a copy of the AttributeList."

    def items(self):
        "Return a list of (attribute_name,value) pairs."

    def values(self):
        "Return a list of all attribute values."


# ===== DOCUMENTHANDLER =====

class DocumentHandler:
    """Handle general document events. This is the main client
    interface for SAX: it contains callbacks for the most important
    document events, such as the start and end of elements. You need
    to create an object that implements this interface, and then
    register it with the Parser. If you do not want to implement
    the entire interface, you can derive a class from HandlerBase,
    which implements the default functionality. You can find the
    location of any document event using the Locator interface
    supplied by setDocumentLocator()."""

    def characters(self, ch, start, length):
        "Handle a character data event."

    def endDocument(self):
        "Handle an event for the end of a document."

    def endElement(self, name):
        "Handle an event for the end of an element."

    def ignorableWhitespace(self, ch, start, length):
        "Handle an event for ignorable whitespace in element content."

    def processingInstruction(self, target, data):
        "Handle a processing instruction event."

    def setDocumentLocator(self, locator):
        "Receive an object for locating the origin of SAX document events."

    def startDocument(self):
        "Handle an event for the beginning of a document."

    def startElement(self, name, atts):
        "Handle an event for the beginning of an element."


# ===== HANDLERBASE =====

class HandlerBase(EntityResolver, DTDHandler, DocumentHandler,\
                     ErrorHandler):
    """Default base class for handlers. This class implements the
    default behaviour for four SAX interfaces: EntityResolver,
    DTDHandler, DocumentHandler, and ErrorHandler: rather
    than implementing those full interfaces, you may simply extend
    this class and override the methods that you need. Note that the
    use of this class is optional (you are free to implement the
    interfaces directly if you wish)."""


# ===== PARSER =====

class Parser:
    """Basic interface for SAX (Simple API for XML) parsers. All SAX
    parsers must implement this basic interface: it allows users to
    register handlers for different types of events and to initiate a
    parse from a URI, a character stream, or a byte stream. SAX
    parsers should also implement a zero-argument constructor."""

    def __init__(self):
        self.doc_handler = DocumentHandler()
        self.dtd_handler = DTDHandler()
        self.ent_handler = EntityResolver()
        self.err_handler = ErrorHandler()

    def parse(self, systemId):
        "Parse an XML document from a system identifier."

    def parseFile(self, fileobj):
        "Parse an XML document from a file-like object."

    def setDocumentHandler(self, handler):
        "Register an object to receive basic document-related events."
        self.doc_handler=handler

    def setDTDHandler(self, handler):
        "Register an object to receive basic DTD-related events."
        self.dtd_handler=handler

    def setEntityResolver(self, resolver):
        "Register an object to resolve external entities."
        self.ent_handler=resolver

    def setErrorHandler(self, handler):
        "Register an object to receive error-message events."
        self.err_handler=handler

    def setLocale(self, locale):
        """Allow an application to set the locale for errors and warnings.

        SAX parsers are not required to provide localisation for errors
        and warnings; if they cannot support the requested locale,
        however, they must throw a SAX exception. Applications may
        request a locale change in the middle of a parse."""
        raise SAXNotSupportedException("Locale support not implemented")