Software: Apache/2.2.3 (CentOS). PHP/5.1.6 uname -a: Linux mx-ll-110-164-51-230.static.3bb.co.th 2.6.18-194.el5PAE #1 SMP Fri Apr 2 15:37:44 uid=48(apache) gid=48(apache) groups=48(apache) Safe-mode: OFF (not secure) /usr/share/doc/PyXML-0.8.4/ drwxr-xr-x | |
| Viewing file: Select action/file-type:
Python/XML Reference Guide
_________________________________________________________________
The Python/XML Special Interest Group
xml-sig@python.org
(edited by akuchling@acm.org)
Abstract:
XML is the Extensible Markup Language, a subset of SGML, intended to
allow the creation and processing of application-specific markup
languages. Python makes an excellent language for processing XML data.
This document is the reference manual for the Python/XML package,
containing several XML modules.
This is a draft document; 'XXX' in the text indicates that something
has to be filled in later, or rewritten, or verified, or something.
Contents
* 1 xml.dom Extensions
+ 1.1 UserDataHandler Objects
* 2 xml.dom.ext.c14n -- Canonical XML generation
* 3 xml.dom.minidom Extensions
* 4 xml.dom.xmlbuilder -- DOM Level 3 Load/Save Interface
+ 4.1 DOMImplementationLS Extensions
+ 4.2 DocumentLS Extensions
+ 4.3 DOMBuilder Objects
+ 4.4 Subclassing DOMBuilder
* 5 xml.ns -- XML Namespace constants
* 6 xml.parsers.expat Extensions
* 7 xml.parsers.sgmllib -- Accelerated SGML Parser
* 8 xml.parsers.sgmlop -- XML/SGML Parser Accelerator
* 9 xml.sax.saxexts
+ 9.1 ExtendedParser methods
+ 9.2 ParserFactory methods
* 10 xml.sax.saxlib
+ 10.1 AttributeList methods
+ 10.2 DocumentHandler methods
+ 10.3 DTDHandler methods
+ 10.4 EntityResolver methods
+ 10.5 ErrorHandler methods
+ 10.6 Locator methods
+ 10.7 Parser methods
+ 10.8 SAXException methods
+ 10.9 SAXParseException methods
* 11 xml.sax.saxutils
+ 11.1 Location methods
* 12 xml.utils.iso8601
* About this document ...
1 xml.dom Extensions
Note: The material in this section describes features of the xml.dom
module that does not appear in the version of the module included with
Python. This is written as a supplement to the corresponding section
in the Python 2.2.1 documentation. We intend that all or most of these
additions be added to the Python standard library in a future release.
Starting with PyXML 0.8, some features of the DOM Level 3 working
drafts are being added. These features are based on working drafts and
will be changed as the drafts are updated. Use at your own risk.
exception ValidationErr
New exception. The validation features of the Level 3 DOM can
raise this exception when validation constraints are not met.
The rest of the validation features have not been implemented,
but any Python DOM implementation would use the same exception,
so it is offered at this point.
The additional exception code defined in the Level 3 DOM specification
map to the exception described above:
Constant Exception
VALIDATION_ERR ValidationErr
The Node class has grown a number of additional constants useful for
some of the new methods added in DOM Level 3. These constants are:
TREE_POSITION_PRECEDING, TREE_POSITION_FOLLOWING,
TREE_POSITION_ANCESTOR, TREE_POSITION_DESCENDENT,
TREE_POSITION_EQUIVALENT, TREE_POSITION_SAME_NODE,
TREE_POSITION_DISCONNECTED.
Additional classes have been added to provide access to constants and
serve as base classes for implementations:
class UserDataHandler
The DOM Level 3 Core adds a method setUserData() which accepts
an instance conforming to the UserDataHandler interface. This
class provides the constants used as arguments to the handle()
of that interface. The constants provided are NODE_CLONED,
NODE_IMPORTED, NODE_DELETED, and NODE_RENAMED. Implementation
classes may choose to subclass from this class, but there is no
reason for them to do so.
class DOMError
The DOM Level 3 Core feature adds support for a user-settable
error handler. This class provides the constants used to
indicate the severity of an error, and may be used as a base
class by DOM implementations. These constants should be used to
test the value of the severity member of instances of this
interface. The constants provided are SEVERITY_WARNING,
SEVERITY_ERROR, and SEVERITY_FATA_ERROR.
1.1 UserDataHandler Objects
The UserDataHandler interface, introduced in the DOM Level 3 Core
(draft) specification, is used to allow DOM clients to manage
node-specific application data stored using the setUserData() method
on nodes.
UserDataHandler implementations need only define one method:
handle( operation, key, data, src, dest)
This method is called for a few particular events in the
lifespan the node on which it was registered. For each type of
event, operation indicates the specific operation being
performed on the node, key gives the key for which data and the
handler object were registered, data is the actual data object,
and src is the node on which the handler was registered. The
dest argument will always be either None or a different node,
depending on the specific operation.
If operation is NODE_CLONED, then dest is the clone of src; src
and dest will always belong to the same document unless src is
a DOCUMENT_TYPE_NODE.
It operation is NODE_IMPORTED, then dest is the imported
version of src, and belongs to a different document.
If operation is NODE_RENAMED, then src and dest are intended to
represent the same node, but different node objects are used.
This is not called when Document.renameNode() does not create a
new node instance.
If operation is NODE_DELETED, then src is about to be deleted
(not just removed from the document tree), and dest is None. It
is not expected that Python implementations of the DOM will
implement this, since doing so properly may interfere with the
reclamation of unused nodes.
The constants passed as the values for the operation argument
of this method are available from the xml.dom.UserDataHandler
class.
2 xml.dom.ext.c14n -- Canonical XML generation
This module takes a DOM element node (and all its children) and
generates canonical XML as defined by the W3C candidate recommendation
http://www.w3.org/TR/xml-c14n. (Unlike the specification, however,
general document subsets are not supported.)
The module name, c14n, comes from the standard way of abbreviating the
word "canonicalization." This module is typically imported by doing
from xml.dom.ext import Canonicalize.
Canonicalize( node[output[**keywords]])
This function generates the canonical format. If output is
specified, the data is sent by invoking its write method, the
the function will return None. If output is omitted or has the
value None, then the Canonicalize will return the data as a
string.
The keyword argument comments, if non-zero, directs the
function to leave any comment nodes in the output. By default,
they are removed.
The keyword argument stripspace, if non-zero, directs the
function to strip all extra whitespace from text elements. By
default, whitespace is preserved. This argument should be used
with caution, as the canonicalization specification directs
that whitespace be preserved.
The keyword argument nsdict may be used to provide a namespace
dictionary that is assumed to be in the node's containing
context. The keys are namespace prefixes, and the values are
the namespace URI's. If nsdict is None or an empty dictionary,
then an initial dictionary containing just the URI's for the
xml and xmlns prefixes will be used.
3 xml.dom.minidom Extensions
The implementation of xml.dom.minidom in PyXML contains support for
more of the DOM Level 2 Core specification than the version packaged
in Python, and incorporates partial support for the draft DOM Level 3
Core and Load/Save specifications. This additional support includes
the interfaces documented for the xml.dom.xmlbuilder module.
This section describes the major extensions beyond what's documented
for this module in the Python Library Reference for Python 2.2.1.
The Entity and Notation node types are now supported.
These additional Node attributes have been implemented or changed:
toxml( [encoding])
The optional encoding argument has been added to the toxml()
method. When specified and not None, the output document uses
the given encoding. Changed in version 0.8: the encoding
argument was added.
isSupported( feature, version)
This is equivalent to calling hasFeature(feature, version) on
the corresponding DOMImplementation object. Added in DOM
Level 2 Core.
getInterface( feature)
Return the interface object for the current node that supports
the feature feature if isSupported(feature, None) returns true,
otherwise returns None. It is not expected that Python DOM
implementations will normally need this, but a DOM
implementation that adds substantial new functionality may want
to require the use of this method to provide access to a helper
object that implements extension-specific methods. Added in DOM
Level 3.
getUserData( key)
Retrieve the data registered with the node for the key key
using setUserData(). Returns None if no data was registered for
key. Added in DOM Level 3.
setUserData( key, data, handler)
Set the object data to be associated with a key key on the
current node. key can be any hashable object, and will be used
as a dictionary key. Any previous value registered for the same
value of key will be discarded.
The handler argument should be None or an implementation of the
UserDataHandler interface. Added in DOM Level 3.
These additional Text attributes have been added based on the Level 3
drafts. These are also available on CDATASection nodes.
wholeText
Returns the textual content for a contiguous range of nodes of
type TEXT_NODE and CDATA_SECTION_NODE nodes containing the
current node.
replaceWholeText( content)
Replace a contiguous range of nodes of type TEXT_NODE and
CDATA_SECTION_NODE nodes containing the current node, with a
single node containing the text content. Returns the node
containing content. If content is an empty string, removes the
entire range of affected nodes and returns None.
These methods and attributes have been added to the Document
interface:
actualEncoding
The encoding used by the parser, if it was overridden by source
context (such as HTTP headers) rather than determined based on
the bytes of the source document. If only the source document
was used to determine the encoding, this is None Added in DOM
Level 3.
encoding
The encoding specified in the XML declaration, or None if the
declaration or encoding pseudo-attribute were omitted. Added in
DOM Level 3.
standalone
If the standalone pseudo-attribute was given in the document's
XML declaration, this will be True if the value was "yes" or
False if the value was "no". If the XML declaration or
standalone pseudo-attribute were omitted, this will be None.
Added in DOM Level 3.
version
The value of the version pseudo-attribute from the XML
declaration, if present, or None. Added in DOM Level 3.
importNode( node, deep)
Imports a node node from another document. If deep is true,
child nodes are recursively imported. Nodes of type
DOCUMENT_NODE and DOCUMENT_TYPE_NODE cannot be imported; if
node has one of these values for its nodeType attribute,
xml.dom.NotSupportedErr will be raised. Added in DOM Level 2.
renameNode( node, namespaceURI, name)
Added in DOM Level 3.
Implementation specific behavior: The DOM Level 2 Core specification
leaves some room for differing behaviors for how some node types are
handled by the Node.cloneNode() method. Before PyXML 0.8.1, the
specific behavior exhibited by PyXML varied as an accident of
implementation. Starting with PyXML 0.8.1, the following behavior is
considered intentional and will be maintained.
When called on a Document node, cloneNode() with the deep argument set
to true will create a new document with the children recursively
imported into the new document. When deep is false, cloneNode() will
return None, as the operation is no reasonable meaning for the
operation.
When called on a DocumentType node, cloneNode() will return None if it
is owned by a document. If it is not owned, a new document type node
is created with all of the attributes copied over, except for the
entities and notations fields. If deep is true, these will be new
NamedNodeMap objects which hold clones of the Entity and Notation
nodes, as appropriate. If deep is false, these will be initialized to
new, empty NamedNodeMap objects.
4 xml.dom.xmlbuilder -- DOM Level 3 Load/Save Interface
New in version 0.8.
Warning: The xml.dom.xmlbuilder represents the DOM Level 3 Load/Save
interface, which is only defined in a W3C working draft at this time.
The Python API presented here is modelled on the 25 July 2002 version
of the working draft, and is expected to change as new drafts are
released. Backward compatibility to support older versions of this
interface will not be preserved.
This module provides API support for the DOM Level 3 Load/Save
specification. It includes an implementation of the loading components
of that specification only at this time.
Tow groups of classes are provided. The first group implements the
objects specific to the Load/Save specification, and the second
provides a group of mixin classes that can be used by a DOM
implementation to make use of the first group of classes.
Implementation classes:
DOMInputSource DOMEntityResolver DOMBuilder DOMBuilderFilter
Mixin classes:
class DOMImplementationLS
Class that can be mixed into an implementation of the
DOMImplementation interface. This implementation provides the
MODE_SYNCHRONOUS and MODE_ASYNCHRONOUS constants and the
createDOMBuilder(), createDOMWriter(), and
createDOMInputSource() methods. Most DOM implementations should
be able to re-use the createDOMInputSource() method, and will
need to override the createDOMBuilder() method if it will
actually be using a different DOM builder. The
createDOMWriter() method should be usable for all
implementations once the DOMWriter has been implemented, but
that has not yet been done in PyXML.
class DocumentLS
Class that can be mixed in to a Document implementation to
provide access to features of the Load/Save interface. There
isn't much that can be provided by this implementation, so most
methods raise NotSupportedErr.
4.1 DOMImplementationLS Extensions
The DOMImplementationLS mixin class is designed to be used in an
implementation of the DOMImplementation interface. This class provides
the constants MODE_SYNCHRONOUS and MODE_ASYNCHRONOUS, and the
following methods:
createDOMBuilder( mode, schemaType)
Returns a DOMBuilder instance. Specific DOM implementations
will usually need to override this to return a specialized
subclass of the DOMBuilder class; see the documentation on the
DOMBuilder for information on how and when to write a subclass
of that.
createDOMWriter( )
For now, raises NotImplementedError since the writer interface
has not been implemented yet.
createDOMInputSource( )
Returns a DOMInputSource instance with all attributes set to
None.
4.2 DocumentLS Extensions
The DocumentLS mixin class for a Document adds the following methods:
load( uri)
Load a new document from a URI into this DOM Document instance.
This is not yet implemented in PyXML.
loadXML( source)
Load a new document from a DOMInputSource into this DOM
Document instance. This is not yet implemented in PyXML.
saveXML( snode)
Return an XML serialization of the DOM node snode as a string.
snode must belong to this document; if not,
xml.dom.WrongDocumentErr will be raised.
The following attribute is also added:
async
If set to a true value, the load() and loadXML() methods should
load documents asynchronously. If false, these methods will
operate in a synchronous mode. PyXML does not support setting
this to true.
4.3 DOMBuilder Objects
The DOMBuilder class provides support for configuring the DOM
construction process, and allows alternate DOM construction methods to
be provided by subclasses.
The general public API has two aspects, configuration and Document
creation. The configuration aspect provides the following attributes
and methods:
canSetFeature( name, state)
Return true if the feature name can be set to state, otherwise
returns false. If feature name is not supported, returns false.
getFeature( name)
Returns the state for the feature name. If name is unrecognized
or not supported, xml.dom.NotFoundErr is raised.
setFeature( name, state)
Set the feature name to state. If feature name is not
recognized, xml.dom.NotFoundErr is raised; if the specific
state requested is not supported, xml.dom.NotSupportedErr is
raised.
supportsFeature( name)
Returns true if the feature name is supported at all, otherwise
returns false. A true return does not imply that any particular
value for the feature is supported.
The Document-creation aspect of the public API is provided by these
methods:
parse( input)
Returns a document based on the DOMInputSource given as input.
parseURI( uri)
Returns a document from the URI given by uri.
parseWithContext( input, cnode, action)
Note: Not implemented in the current version.
Legal values for action are given by the constants
ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, ACTION_INSERT_AFTER,
and ACTION_INSERT_BEFORE, all defined on the DOMBuilder class.
Subclasses are expected to define the following method to determine
how the Document instances returned by the parse() method will be
created.
Warning: The interface for subclasses is very preliminary, and should
be considered likely to change in future releases.
_parse_bytestream( stream, options)
Returns a Document instance parsed from the file object given
as stream using the configuration options in the options
object. The default implementation uses xml.parsers.expat to
construct documents using the xml.dom.minidom DOM
implementation.
4.4 Subclassing DOMBuilder
There are two important aspects to subclassing the DOMBuilder:
implementing a useful subclass and getting a DOMImplementation that
uses it.
The first aspect is faily easy; to create a DOMBuilder that uses a
different parser, use a subclass that overrides the
_parse_bytestream() method, documented above. The implementation of a
specialized DOM builder may not be trivial, but the integration with
the provided DOMBuilder class will be reasonably direct.
The second aspect, creating a DOM implementation that uses the new
DOMBuilder implementation, is a little more tedious, but not
excessively so. The DOMImplementationLS mixin class can be used, and
the createDOMBuilder() method overridden to use the new DOMBuilder
implementation. This makes less sense if you want to re-use most of an
existing DOM implementation, however.
To use a new DOMBuilder with existing DOM implementation code, such as
xml.dom.minidom, the easiest approach is to subclass an existing
DOMImplementation class. For xml.dom.minidom, this could be done this
way:
import xml.dom
from xml.dom.minidom import DOMImplementation
from xml.dom.xmlbuilder import DOMBuilder
class MyDOMBuilder(DOMBuilder):
def __init__(self, implementation):
self._implementation = implementation
def _parse_bytestream(self, stream, options):
raise xml.dom.NotSupportedErr(
"I'm just an example; don't expect much.")
class MyDOMImplementation(DOMImplementation):
def createDOMBuilder(self, mode, schemaType):
# check for the supported mode and schemaType
if schemaType is not None:
raise xml.dom.NotSupportedErr(
"unsupported schema type: %s" % schemaType)
if mode != DOMImplementation.MODE_SYNCHRONOUS:
raise xml.dom.NotSupportedErr(
"asynchronous loading not supported")
return MyDOMBuilder(self)
# minidom just stores the implementation on the class instance,
# so we need to do the same to override that attribute on instances.
#
MyDOMImplementation.implementation = MyDOMImplementation()
5 xml.ns -- XML Namespace constants
This module contains the definitions of namespaces (and sometimes
other URI's) used by a variety of XML standards. Each class has a
short all-uppercase name, which should follow any (emerging)
convention for how that standard is commonly used. For example, "ds"
is almost always used as the namespace prefixes for items in XML
Signature, so "DS" is the class name. Attributes within that class
define symbolic names (hopefully evocative) for ``constants'' used in
that standard.
class XMLNS
The Namespaces in XML recommendation defines the concept and
syntactic constructs relating to XML namespaces.
BASE
The namespace URI assigned to namespace declarations.
This is assigned to attributes named xmlns and attributes
which have a namespace prefix of xmlns.
XML
The namespace bound to this URI is used for all elements
and attributes which start with the letters "xml",
regardless of case. No other elements or attributes are
allowed to use this namespace.
HTML
This namespace is recommended for use with HTML 4.0.
class XLINK
The XML Linking Language defines document linking semantics and
an attribute language that allows these semantics to be
expressed in XML documents.
BASE
The URI of the global attributes defined in the XLink
specification. All attributes that define the presence
and behavior of links are in this namespace.
class SOAP
Simple Object Access Protocol defines a means of communicating
with objects on servers. It can be used as a remote procedure
call (RPC) mechanism, or as a basis for message passing
systems.
ENV
This URI is used for the namespace of the ``envelope''
which contains the message. Elements in this namespace
provide for destination identification and other
information needed to route and decode the message.
ENC
The namespace URI used for the optional payload encoding
defined in section 5 of the SOAP specification.
ACTOR_NEXT
The URI specified in section 4.2.2 of the SOAP
specification which is used to indicate the destination
of a SOAP message.
class DSIG
The namespace URIs given here are defined by the XML digital
signature specification.
BASE
The basic namespace defined by the specification.
C14N
The URI by which Canonical XML (Version 1.0) is
identified when used as a transformation or
canonicalization method.
C14N_COMM
This URI identifies ``canonical XML with comments,'' as
described in Canonical XML (Version 1.0), section 2.1.
C14N_EXCL
The URI by which the canonicalization variant defined in
Exclusive XML Canonicalization (Version 1.0) is
identified when used as a transformation or
canonicalization method.
The specification also assigns URIs to specific methods of
computing message digests and signatures, and other encoding
techniques used in the specification.
DIGEST_SHA1
The URI for the SHA-1 digest method.
DIGEST_MD2
The URI for the MD2 digest method.
DIGEST_MD5
The URI for the MD5 digest method.
SIG_DSA_SHA1
The URI used to specify the Digital Signature Algorithm
(DSA) with the SHA-1 hash algorithm. DSA is specified in
FIPS PUB 186-2, Digital Signature Standard (DSS).
SIG_RSA_SHA1
The URI indicating the RSA signature algorithm using
SHA-1 for the secure hash.
HMAC_SHA1
URI for the SHA-1 HMAC algorithm.
ENC_BASE64
URI used to denote the base64 encoding and transform.
ENVELOPED
URI used to specify the enveloped signature transform
method (section 6.6.4 of the specification).
XPATH
URI used to specify the XPath filtering transform method
(section 6.6.3 of the specification).
XSLT
URI used to specify the XSLT transform method (section
6.6.5 of the specification).
class RNG
The URIs provided here are used with the Relax NG schema
language.
BASE
The namespace URI of the elements defined by the Relax NG
Specification.
class SCHEMA
BASE
XSD1
XSD2
XSD3
XSI1
XSI2
XSI3
Two additional convenience attributes are defined:
XSD_LIST
A sequence of all ... namespaces.
XSI_LIST
A sequence of all ... namespaces.
class XSLT
XSLT, defined in XML Stylesheet Language -- Transformations,
defines a single namespace:
BASE
This URI is used as the namespace for all XSLT elements
and for XSLT attributes attached to non-XSLT elements.
class WSDL
The Web Services Description Language (WSDL) defines a language
to specify the logical interactions with applications that use
Web technologies as their access mechanism; this can be thought
of as an IDL for servers that speak HTTP instead of XDR or
IIOP.
BASE
The basic namespace defined in this specification.
BIND_SOAP
The URI of the SOAP binding for WSDL.
BIND_HTTP
HTTP bindings for WSDL using the GET and POST methods.
BIND_MIME
The URI of the namespace for MIME-type bindings for WSDL.
6 xml.parsers.expat Extensions
The version of the xml.parsers.expat module currently shipped with
PyXML extends that provided by the standard Python library by exposing
features of recent versions of the C implementation of the underlying
Expat parser. These extensions are described here; the base
documentation for this module is that published as part of the Python
Library Reference.
The module provides a new data attribute:
features
A list of name-value pairs giving some information about the
compilation of Expat being used. This is generated directly
from the feature information provided by Expat's
XML_GetFeatureList() function. It is unlikely to be of interest
to most applications.
This was added in PyXML 0.8.1 to support Expat 1.95.5 and
newer.
The parser provides a new method:
UseForeignDTD( [flag])
Tells Expat whether is should attempt to load an
application-provided external subset if one is not specified by
the document type declaration. If flag is true or omitted,
Expat will attempt to load an external subset by calling the
ExternalEntityRefHandler callback with systemId and publicId
both set to None; this is done only if the document does not
specify a external subset. If flag is false (or this method is
never called), Expat will not attempt such a load. This method
should only be called before parsing has actually started;
ExpatError will be raised if this is called after parsing has
begun.
This was added in PyXML 0.8.1 to support Expat 1.95.5 and
newer.
and one new attribute:
namespace_prefixes
Set to true on a parser with namespaces enabled to request that
the actual prefix is reported as well as the namespace URI for
each namespace-qualified name. This modifies the element or
attribute names passed to the StartElementHandler and
EndElementHandler callbacks, if true. If set to a true value,
the names passed to these callbacks will have the prefix added
to the end, separated from the local name by the value of the
namespace_separator passed to the parser constructor. No
additional information will be added if the name uses the
default namespace. This should only be called before parsing
has begun.
This was added in PyXML 0.8 to support Expat 1.95.4 and newer.
One new callback method has been added as well:
SkippedEntityHandler( name, is_param_entity)
This is called when an external entity is not read, and gives
information about the entity. The entity name will have been
previously reported by the EntityDeclHandler, if set.
This was added in PyXML 0.8 to support Expat 1.95.4 and newer.
See Also:
Expat Home Page
The home page for the Expat project provides information about
new versions of the library and user resources such as
3rd-party language bindings and mailing lists.
7 xml.parsers.sgmllib -- Accelerated SGML Parser
This module is an alternate implementation of the sgmllib module from
the Python standard library. This implementation uses the
xml.parsers.sgmlop accelerator to improve performance.
This module does create a cyclic reference. In order to break the
cycle, be sure to call the close() method of the parser instances when
done with them.
8 xml.parsers.sgmlop -- XML/SGML Parser Accelerator
The xml.parsers.sgmlop module is a C implementation of a parser
similar in interface to the xmllib.XMLParser and sgmllib.SGMLParser
classes from the Python standard library. Additional support is
provided for a basic tree-constructor which is intended to be used in
conjunction with the parsers implemented by this module.
9 xml.sax.saxexts
make_parser( [parser])
A utility function that returns a Parser object for a
non-validating XML parser. If parser is specified, it must be a
parser name; otherwise, a list of available parsers is checked
and the fastest one chosen.
HTMLParserFactory
An instance of the ParserFactory class that's already been
prepared with a list of HTML parsers. Simply call its
make_parser() method to get a Parser object.
class ParserFactory( )
A general class to be used by applications for creating parsers
on foreign systems where the list of installed parsers is
unknown.
SGMLParserFactory
An instance of the ParserFactory class that's already been
prepared with a list of SGML parsers. Simply call its
make_parser() method to get a parser object.
XMLParserFactory
An instance of the ParserFactory class that's already been
prepared with a list of nonvalidating XML parsers. Simply call
its make_parser() method to get a parser object.
XMLValParserFactory
An instance of the ParserFactory class that's already been
prepared with a list of validating XML parsers. Simply call its
make_parser() method to get a parser object.
class ExtendedParser( )
This class is an experimental extended parser interface, that
offers additional functionality that may be useful. However,
it's not specified by the SAX specification.
9.1 ExtendedParser methods
close( )
Called after the last call to feed, when there are no more
data.
feed( data)
Feeds data to the parser.
get_parser_name( )
Returns a single-word parser name.
get_parser_version( )
Returns the version of the imported parser, which may not be
the one the driver was implemented for.
is_dtd_reading( )
True if the parser is non-validating, but conforms to the XML
specification by reading the DTD.
is_validating( )
Returns true if the parser is validating, false otherwise.
reset( )
Makes the parser start parsing afresh.
9.2 ParserFactory methods
get_parser_list( )
Returns the list of possible drivers. Currently this starts out
as ["xml.sax.drivers.drv_xmltok",
"xml.sax.drivers.drv_xmlproc",
"xml.sax.drivers.drv_xmltoolkit",
"xml.sax.drivers.drv_xmllib"].
make_parser( [driver_name])
Returns a SAX driver for the first available parser of the
parsers in the list. Note that the list contains drivers, so it
first tries the driver and if that exists imports it to see if
the parser also exists. If no parsers are available a
SAXException is thrown.
Optionally, driver_name can be a string containing the name of
the driver to be used; the stored parser list will then not be
used at all.
set_parser_list( list)
Sets the driver list to list.
10 xml.sax.saxlib
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.
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().
class DTDHandler( )
Handle DTD events. This interface specifies only those DTD
events required for basic parsing (unparsed entities and
attributes). If you do not want to implement the entire
interface, you can extend HandlerBase, which implements the
default behaviour.
class EntityResolver( )
This is the basic interface for resolving entities. If you
create an object implementing this interface, then register the
object with your Parser instance, the parser will call the
method in your object to resolve all external entities. Note
that HandlerBase implements this interface with the default
behaviour.
class ErrorHandler( )
This is the basic interface for SAX error handlers. If you
create an object that implements this interface, then register
the object with your Parser, the parser will call the methods
in your object to report all warnings and errors. There are
three levels of errors available: warnings, (possibly)
recoverable errors, and unrecoverable errors. All methods take
a SAXParseException as the only parameter.
class HandlerBase( )
Default base class for handlers. This class implements the
default behaviour for four SAX interfaces, inheriting from them
all: 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, since
you are free to implement the interfaces directly if you wish.
class Locator( )
Interface for associating a SAX event with a document location.
A locator object will return valid results only during calls to
methods of the SAXDocumentHandler class; at any other time, the
results are unpredictable.
class Parser( )
Basic interface for SAX 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.
class SAXException( msg, exception, locator)
Encapsulate an XML error or warning. This class can contain
basic error or warning information from either the XML parser
or the application: you can subclass it to provide additional
functionality, or to add localization. Note that although you
will receive a SAXException as the argument to the handlers in
the ErrorHandler interface, you are not actually required to
throw the exception; instead, you can simply read the
information in it.
class SAXParseException( msg, exception, locator)
Encapsulate an XML parse error or warning.
This exception will include information for locating the error
in the original XML document. Note that although the
application will receive a SAXParseException as the argument to
the handlers in the ErrorHandler interface, the application is
not actually required to throw the exception; instead, it can
simply read the information in it and take a different action.
Since this exception is a subclass of SAXException, it inherits
the ability to wrap another exception.
10.1 AttributeList methods
The AttributeList class supports some of the behaviour of Python
dictionaries; the len() function and has_key(), keys() methods are
available, and attr['href'] will retrieve the value of the href
attribute. There are also additional methods specific to
AttributeList:
getLength( )
Return the number of attributes in the list.
getName( i)
Return the name of attribute i in the list.
getType( i)
Return the type of an attribute in the list. i can be either
the integer index or the attribute name.
getValue( i)
Return the value of an attribute in the list. i can be either
the integer index or the attribute name.
10.2 DocumentHandler methods
characters( ch, start, length)
Handle a character data event.
endDocument( )
Handle an event for the end of a document.
endElement( name)
Handle an event for the end of an element.
ignorableWhitespace( ch, start, length)
Handle an event for ignorable whitespace in element content.
processingInstruction( target, data)
Handle a processing instruction event.
setDocumentLocator( locator)
Receive an object for locating the origin of SAX document
events. You'll probably want to store the value of locator as
an attribute of the handler instance.
startDocument( )
Handle an event for the beginning of a document.
startElement( name, attrs)
Handle an event for the beginning of an element.
10.3 DTDHandler methods
notationDecl( name, publicId, systemId)
Handle a notation declaration event.
unparsedEntityDecl( publicId, systemId, notationName)
Handle an unparsed entity declaration event.
10.4 EntityResolver methods
resolveEntity( name, publicId, systemId)
Resolve the system identifier of an entity.
10.5 ErrorHandler methods
error( exception)
Handle a recoverable error.
fatalError( exception)
Handle a non-recoverable error.
warning( exception)
Handle a warning.
10.6 Locator methods
getColumnNumber( )
Return the column number where the current event ends.
getLineNumber( )
Return the line number where the current event ends.
getPublicId( )
Return the public identifier for the current event.
getSystemId( )
Return the system identifier for the current event.
10.7 Parser methods
parse( systemId)
Parse an XML document from a system identifier.
parseFile( fileobj)
Parse an XML document from a file-like object.
setDocumentHandler( handler)
Register an object to receive basic document-related events.
setDTDHandler( handler)
Register an object to receive basic DTD-related events.
setEntityResolver( resolver)
Register an object to resolve external entities.
setErrorHandler( handler)
Register an object to receive error-message events.
setLocale( 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.
10.8 SAXException methods
getException( )
Return the embedded exception, if any.
getMessage( )
Return a message for this exception.
10.9 SAXParseException methods
The SAXParseException class has a locator attribute, containing an
instance of the Locator class, which represents the location in the
document where the parse error occurred. The following methods are
delegated to this instance.
getColumnNumber( )
Return the column number of the end of the text where the
exception occurred.
getLineNumber( )
Return the line number of the end of the text where the
exception occurred.
getPublicId( )
Return the public identifier of the entity where the exception
occurred.
getSystemId( )
Return the system identifier of the entity where the exception
occurred.
11 xml.sax.saxutils
escape( data[, entities])
Escape "&", "<", and ">" in a string of data.
You can escape other strings of data by passing a dictionary as
the optional entities parameter. The keys and values must all
be strings; each key will be replaced with its corresponding
value.
quoteattr( data[, entities])
Similar to escape(), but also prepares data to be used as an
attribute value. The return value is a quoted version of data
with any additional required replacements. quoteattr() will
select a quote character based on the content of data,
attempting to avoid encoding any quote characters in the
string. If both single- and double-quote characters are already
in data, the double-quote characters will be encoded and data
will be wrapped in doule-quotes. The resulting string can be
used directly as an attribute value:
>>> print "<element attr=%s>" % quoteattr("ab ' cd \" ef")
<element attr="ab ' cd " ef">
This function is useful when generating attribute values for
HTML or any SGML using the reference concrete syntax.
class Canonizer( writer)
A SAX document handler that produces canonicalized XML output.
writer must support a write() method which accepts a single
string.
class ErrorPrinter( )
A simple class that just prints error messages to standard
error (sys.stderr).
class ESISDocHandler( writer)
A SAX document handler that produces naive ESIS output. writer
must support a write() method which accepts a single string.
class EventBroadcaster( list)
Takes a list of objects and forwards any method calls received
to all objects in the list. The attribute list holds the list
and can freely be modified by clients.
class Location( locator)
Represents a location in an XML entity. Initialized by being
passed a locator, from which it reads off the current location,
which is then stored internally.
11.1 Location methods
getColumnNumber( )
Return the column number of the location.
getLineNumber( )
Return the line number of the location.
getPublicId( )
Return the public identifier for the location.
getSystemId( )
Return the system identifier for the location.
12 xml.utils.iso8601
The xml.utils.iso8601 module provides conversion routines between the
ISO 8601 representations of date/time values and the floating point
values used elsewhere in Python. The floating point represtentation is
particularly useful in conjunction with the standard time module.
Currently, this module supports a small superset of the ISO 8601
profile described by the World Wide Web Consortium (W3C). This is a
subset of ISO 8601, but covers the cases expected to be used most
often in the context of XML processing and Web applications. Future
versions of this module may support a larger subset of
ISO 8601-defined formats.
parse( s)
Parse an ISO 8601 date representation (with an optional
time-of-day component) and return the date in seconds since the
epoch.
parse_timezone( timezone)
Parse an ISO 8601 time zone designator and return the offset
relative to Universal Coordinated Time (UTC) in seconds. If
timezone is not valid, ValueError is raised.
tostring( t[, timezone])
Return formatted date/time value according to the profile
described by the W3C. If timezone is provided, it must be the
offset from UTC in seconds specified as a number, or time zone
designator which can be parsed by parse_timezone(). If timezone
is specified as a string and cannot be parsed by
parse_timezone(), ValueError will be raised.
ctime( t)
Return formatter date/time value using the local timezone. This
is equivalent to "tostring(t, time.timezone)".
See Also:
Data elements and interchange formats -- Information interchange --
Representation of dates and times.
The actual ISO 8601 standard published by the International
Organization for Standardization, 1988.
ISO 8601 date/time representations
Gary Houston's description of the ISO 8601 formats for humans,
written in January 1993.
A Summary of the International Standard Date and Time Notation
Markus Kuhn's excellent discussion of international date/time
representations.
Date and Time Formats
World Wide Web Consortium Technical Note from September 1998,
written by Misha Wolf and Charles Wicksteed.
About this document ...
Python/XML Reference Guide
This document was generated using the LaTeX2HTML translator.
LaTeX2HTML is Copyright © 1993, 1994, 1995, 1996, 1997, Nikos Drakos,
Computer Based Learning Unit, University of Leeds, and Copyright ©
1997, 1998, Ross Moore, Mathematics Department, Macquarie University,
Sydney.
The application of LaTeX2HTML to the Python documentation has been
heavily tailored by Fred L. Drake, Jr. Original navigation icons were
contributed by Christopher Petrilli.
_________________________________________________________________
Python/XML Reference Guide
_________________________________________________________________
Release 0.8.
|
:: Command execute :: | |
:: Shadow's tricks :D :: | |
Useful Commands
|
|
:: Preddy's tricks :D :: | |
Php Safe-Mode Bypass (Read Files)
|
|
--[ c999shell v. 1.0 pre-release build #16 Modded by Shadow & Preddy | RootShell Security Group | r57 c99 shell | Generation time: 0.0146 ]-- |