cinap_lenrekadd hg and python4bb9e2215 years agoHistory
1260 lines · 40.1 KB · Python
RawDownload
    if text:        element.text = element.text + " " + text    return element PI = ProcessingInstruction ### QName wrapper.  This can be used to wrap a QName attribute value, in# order to get proper namespace handling on output.## @param text A string containing the QName value, in the form {uri}local,#     or, if the tag argument is given, the URI part of a QName.# @param tag Optional tag.  If given, the first argument is interpreted as#     an URI, and this argument is interpreted as a local name.# @return An opaque object, representing the QName. class QName:    def __init__(self, text_or_uri, tag=None):        if tag:            text_or_uri = "{%s}%s" % (text_or_uri, tag)        self.text = text_or_uri    def __str__(self):        return self.text    def __hash__(self):        return hash(self.text)    def __cmp__(self, other):        if isinstance(other, QName):            return cmp(self.text, other.text)        return cmp(self.text, other) ### ElementTree wrapper class.  This class represents an entire element# hierarchy, and adds some extra support for serialization to and from# standard XML.## @param element Optional root element.# @keyparam file Optional file handle or name.  If given, the#     tree is initialized with the contents of this XML file. class ElementTree:     def __init__(self, element=None, file=None):        assert element is None or iselement(element)        self._root = element # first node        if file:            self.parse(file)     ##    # Gets the root element for this tree.    #    # @return An element instance.    # @defreturn Element     def getroot(self):        return self._root     ##    # Replaces the root element for this tree.  This discards the    # current contents of the tree, and replaces it with the given    # element.  Use with care.    #    # @param element An element instance.     def _setroot(self, element):        assert iselement(element)        self._root = element     ##    # Loads an external XML document into this element tree.    #    # @param source A file name or file object.    # @param parser An optional parser instance.  If not given, the    #     standard {@link XMLTreeBuilder} parser is used.    # @return The document root element.    # @defreturn Element     def parse(self, source, parser=None):        if not hasattr(source, "read"):            source = open(source, "rb")        if not parser:            parser = XMLTreeBuilder()        while 1:            data = source.read(32768)            if not data:                break            parser.feed(data)        self._root = parser.close()        return self._root     ##    # Creates a tree iterator for the root element.  The iterator loops    # over all elements in this tree, in document order.    #    # @param tag What tags to look for (default is to return all elements)    # @return An iterator.    # @defreturn iterator     def getiterator(self, tag=None):        assert self._root is not None        return self._root.getiterator(tag)     ##    # Finds the first toplevel element with given tag.    # Same as getroot().find(path).    #    # @param path What element to look for.    # @return The first matching element, or None if no element was found.    # @defreturn Element or None     def find(self, path):        assert self._root is not None        if path[:1] == "/":            path = "." + path        return self._root.find(path)     ##    # Finds the element text for the first toplevel element with given    # tag.  Same as getroot().findtext(path).    #    # @param path What toplevel element to look for.    # @param default What to return if the element was not found.    # @return The text content of the first matching element, or the    #     default value no element was found.  Note that if the element    #     has is found, but has no text content, this method returns an    #     empty string.    # @defreturn string     def findtext(self, path, default=None):        assert self._root is not None        if path[:1] == "/":            path = "." + path        return self._root.findtext(path, default)     ##    # Finds all toplevel elements with the given tag.    # Same as getroot().findall(path).    #    # @param path What element to look for.    # @return A list or iterator containing all matching elements,    #    in document order.    # @defreturn list of Element instances     def findall(self, path):        assert self._root is not None        if path[:1] == "/":            path = "." + path        return self._root.findall(path)     ##    # Writes the element tree to a file, as XML.    #    # @param file A file name, or a file object opened for writing.    # @param encoding Optional output encoding (default is US-ASCII).     def write(self, file, encoding="us-ascii"):        assert self._root is not None        if not hasattr(file, "write"):            file = open(file, "wb")        if not encoding:            encoding = "us-ascii"        elif encoding != "utf-8" and encoding != "us-ascii":            file.write("<?xml version='1.0' encoding='%s'?>\n" % encoding)        self._write(file, self._root, encoding, {})     def _write(self, file, node, encoding, namespaces):        # write XML to file        tag = node.tag        if tag is Comment:            file.write("<!-- %s -->" % _escape_cdata(node.text, encoding))        elif tag is ProcessingInstruction:            file.write("<?%s?>" % _escape_cdata(node.text, encoding))        else:            items = node.items()            xmlns_items = [] # new namespaces in this scope            try:                if isinstance(tag, QName) or tag[:1] == "{":                    tag, xmlns = fixtag(tag, namespaces)                    if xmlns: xmlns_items.append(xmlns)            except TypeError:                _raise_serialization_error(tag)            file.write("<" + _encode(tag, encoding))            if items or xmlns_items:                items.sort() # lexical order                for k, v in items:                    try:                        if isinstance(k, QName) or k[:1] == "{":                            k, xmlns = fixtag(k, namespaces)                            if xmlns: xmlns_items.append(xmlns)                    except TypeError:                        _raise_serialization_error(k)                    try:                        if isinstance(v, QName):                            v, xmlns = fixtag(v, namespaces)                            if xmlns: xmlns_items.append(xmlns)                    except TypeError:                        _raise_serialization_error(v)                    file.write(" %s=\"%s\"" % (_encode(k, encoding),                                               _escape_attrib(v, encoding)))                for k, v in xmlns_items:                    file.write(" %s=\"%s\"" % (_encode(k, encoding),                                               _escape_attrib(v, encoding)))            if node.text or len(node):                file.write(">")                if node.text:                    file.write(_escape_cdata(node.text, encoding))                for n in node:                    self._write(file, n, encoding, namespaces)                file.write("</" + _encode(tag, encoding) + ">")            else:                file.write(" />")            for k, v in xmlns_items:                del namespaces[v]        if node.tail:            file.write(_escape_cdata(node.tail, encoding)) # --------------------------------------------------------------------# helpers ### Checks if an object appears to be a valid element object.## @param An element instance.# @return A true value if this is an element object.# @defreturn flag def iselement(element):    # FIXME: not sure about this; might be a better idea to look    # for tag/attrib/text attributes    return isinstance(element, _ElementInterface) or hasattr(element, "tag") ### Writes an element tree or element structure to sys.stdout.  This# function should be used for debugging only.# <p># The exact output format is implementation dependent.  In this# version, it's written as an ordinary XML file.## @param elem An element tree or an individual element. def dump(elem):    # debugging    if not isinstance(elem, ElementTree):        elem = ElementTree(elem)    elem.write(sys.stdout)    tail = elem.getroot().tail    if not tail or tail[-1] != "\n":        sys.stdout.write("\n") def _encode(s, encoding):    try:        return s.encode(encoding)    except AttributeError:        return s # 1.5.2: assume the string uses the right encoding if sys.version[:3] == "1.5":    _escape = re.compile(r"[&<>\"\x80-\xff]+") # 1.5.2else:    _escape = re.compile(eval(r'u"[&<>\"\u0080-\uffff]+"')) _escape_map = {    "&": "&amp;",    "<": "&lt;",    ">": "&gt;",    '"': "&quot;",} _namespace_map = {    # "well-known" namespace prefixes    "http://www.w3.org/XML/1998/namespace": "xml",    "http://www.w3.org/1999/xhtml": "html",    "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",    "http://schemas.xmlsoap.org/wsdl/": "wsdl",} def _raise_serialization_error(text):    raise TypeError(        "cannot serialize %r (type %s)" % (text, type(text).__name__)        ) def _encode_entity(text, pattern=_escape):    # map reserved and non-ascii characters to numerical entities    def escape_entities(m, map=_escape_map):        out = []        append = out.append        for char in m.group():            text = map.get(char)            if text is None:                text = "&#%d;" % ord(char)            append(text)        return string.join(out, "")    try:        return _encode(pattern.sub(escape_entities, text), "ascii")    except TypeError:        _raise_serialization_error(text) ## the following functions assume an ascii-compatible encoding# (or "utf-16") def _escape_cdata(text, encoding=None, replace=string.replace):    # escape character data    try:        if encoding:            try:                text = _encode(text, encoding)            except UnicodeError:                return _encode_entity(text)        text = replace(text, "&", "&amp;")        text = replace(text, "<", "&lt;")        text = replace(text, ">", "&gt;")        return text    except (TypeError, AttributeError):        _raise_serialization_error(text) def _escape_attrib(text, encoding=None, replace=string.replace):    # escape attribute value    try:        if encoding:            try:                text = _encode(text, encoding)            except UnicodeError:                return _encode_entity(text)        text = replace(text, "&", "&amp;")        text = replace(text, "'", "&apos;") # FIXME: overkill        text = replace(text, "\"", "&quot;")        text = replace(text, "<", "&lt;")        text = replace(text, ">", "&gt;")        return text    except (TypeError, AttributeError):        _raise_serialization_error(text) def fixtag(tag, namespaces):    # given a decorated tag (of the form {uri}tag), return prefixed    # tag and namespace declaration, if any    if isinstance(tag, QName):        tag = tag.text    namespace_uri, tag = string.split(tag[1:], "}", 1)    prefix = namespaces.get(namespace_uri)    if prefix is None:        prefix = _namespace_map.get(namespace_uri)        if prefix is None:            prefix = "ns%d" % len(namespaces)        namespaces[namespace_uri] = prefix        if prefix == "xml":            xmlns = None        else:            xmlns = ("xmlns:%s" % prefix, namespace_uri)    else:        xmlns = None    return "%s:%s" % (prefix, tag), xmlns ### Parses an XML document into an element tree.## @param source A filename or file object containing XML data.# @param parser An optional parser instance.  If not given, the#     standard {@link XMLTreeBuilder} parser is used.# @return An ElementTree instance def parse(source, parser=None):    tree = ElementTree()    tree.parse(source, parser)    return tree ### Parses an XML document into an element tree incrementally, and reports# what's going on to the user.## @param source A filename or file object containing XML data.# @param events A list of events to report back.  If omitted, only "end"#     events are reported.# @return A (event, elem) iterator. class iterparse:     def __init__(self, source, events=None):        if not hasattr(source, "read"):            source = open(source, "rb")        self._file = source        self._events = []        self._index = 0        self.root = self._root = None        self._parser = XMLTreeBuilder()        # wire up the parser for event reporting        parser = self._parser._parser        append = self._events.append        if events is None:            events = ["end"]        for event in events:            if event == "start":                try:                    parser.ordered_attributes = 1                    parser.specified_attributes = 1                    def handler(tag, attrib_in, event=event, append=append,                                start=self._parser._start_list):                        append((event, start(tag, attrib_in)))                    parser.StartElementHandler = handler                except AttributeError:                    def handler(tag, attrib_in, event=event, append=append,                                start=self._parser._start):                        append((event, start(tag, attrib_in)))                    parser.StartElementHandler = handler            elif event == "end":                def handler(tag, event=event, append=append,                            end=self._parser._end):                    append((event, end(tag)))                parser.EndElementHandler = handler            elif event == "start-ns":                def handler(prefix, uri, event=event, append=append):                    try:                        uri = _encode(uri, "ascii")                    except UnicodeError:                        pass                    append((event, (prefix or "", uri)))                parser.StartNamespaceDeclHandler = handler            elif event == "end-ns":                def handler(prefix, event=event, append=append):                    append((event, None))                parser.EndNamespaceDeclHandler = handler     def next(self):        while 1:            try:                item = self._events[self._index]            except IndexError:                if self._parser is None:                    self.root = self._root                    try:                        raise StopIteration                    except NameError:                        raise IndexError                # load event buffer                del self._events[:]                self._index = 0                data = self._file.read(16384)                if data:                    self._parser.feed(data)                else:                    self._root = self._parser.close()                    self._parser = None            else:                self._index = self._index + 1                return item     try:        iter        def __iter__(self):            return self    except NameError:        def __getitem__(self, index):            return self.next() ### Parses an XML document from a string constant.  This function can# be used to embed "XML literals" in Python code.## @param source A string containing XML data.# @return An Element instance.# @defreturn Element def XML(text):    parser = XMLTreeBuilder()    parser.feed(text)    return parser.close() ### Parses an XML document from a string constant, and also returns# a dictionary which maps from element id:s to elements.## @param source A string containing XML data.# @return A tuple containing an Element instance and a dictionary.# @defreturn (Element, dictionary) def XMLID(text):    parser = XMLTreeBuilder()    parser.feed(text)    tree = parser.close()    ids = {}    for elem in tree.getiterator():        id = elem.get("id")        if id:            ids[id] = elem    return tree, ids ### Parses an XML document from a string constant.  Same as {@link #XML}.## @def fromstring(text)# @param source A string containing XML data.# @return An Element instance.# @defreturn Element fromstring = XML ### Generates a string representation of an XML element, including all# subelements.## @param element An Element instance.# @return An encoded string containing the XML data.

Lines 501–1000 of 1260. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t