Python TreeBuilder.close方法代码示例

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def test_xsd_sequence_callback(self):
     from xml.etree.ElementTree import TreeBuilder, tostring
     from c2cgeoportal.lib.dbreflection import _xsd_sequence_callback
     from papyrus.xsd import tag
     tb = TreeBuilder()
     with tag(tb, "xsd:sequence") as tb:
         _xsd_sequence_callback(tb, self.cls)
     e = tb.close()
     self.assertEqual(
         tostring(e),
         '<xsd:sequence>'
         '<xsd:element minOccurs="0" name="child1" nillable="true">'
         '<xsd:simpleType>'
         '<xsd:restriction base="xsd:string">'
         '<xsd:enumeration value="foo" />'
         '<xsd:enumeration value="bar" />'
         '</xsd:restriction>'
         '</xsd:simpleType>'
         '</xsd:element>'
         '<xsd:element minOccurs="0" name="child2" nillable="true">'
         '<xsd:simpleType>'
         '<xsd:restriction base="xsd:string">'
         '<xsd:enumeration value="foo" />'
         '<xsd:enumeration value="bar" />'
         '</xsd:restriction>'
         '</xsd:simpleType>'
         '</xsd:element>'
         '</xsd:sequence>')

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
def emit(output, title_string, structure):
    "Write an SVG file to output representing structure."
    global builder

    builder = TreeBuilder()

    builder.start("svg", dict(xmlns="http://www.w3.org/2000/svg",
                              width=str(width),
                              height=str(height)))
    
    title(title_string)
    structure.depth(3)
    for key, depth in [(3, 3),
                       (1, 5),
                       (2, 6),
                       (1, 10),
                       (1, 11),
                       (2, 15),
                       (3, 16),
                       (1, 22),
                       (2, 25),
                       (1, 25),
                       ]:
        structure.key(key, depth)

    builder.end("svg")

    ElementTree(builder.close()).write(output,
                                       encoding='utf-8',
                                       xml_declaration=True)
    output.write("\n")

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def dumpGEXF(self,targetfp,projectName):
     self.ensureDumpBase()
     tb=TreeBuilder()
     tb.start("gexf",{"xmlns":"http://www.gexf.net/1.2draft","version":"1.2"})
     tb.start("meta",{"lastmodifieddate":str(datetime.datetime.now())})
     tb.start("creator",{})
     tb.data("LAVI Collector")
     tb.end("creator")
     tb.start("description",{})
     tb.data(projectName)
     tb.end("description")
     tb.end("meta")
     tb.start("graph",{"mode":"dynamic","start":formatTstamp(self.mint),"end":formatTstamp(self.maxt)})
     tb.start("nodes",{})
     for id,email,mint,maxt in self.nodesIterator():
         tb.start("node",{"id":id,"label":email,"start":formatTstamp(mint),"end":formatTstamp(maxt)})
         tb.end("node")
     tb.end("nodes")
     tb.start("edges",{})
     for id,sender,rec,tstamp in self.edgesIterator():
         tb.start("edge",{"id":id, "source":sender,"target":rec,"start":formatTstamp(tstamp),"end":formatTstamp(tstamp)})
         tb.end("edge")
     tb.end("edges")
     tb.end("graph")
     tb.end("gexf")
     et=ElementTree(tb.close())
     et.write(targetfp, encoding="UTF-8")

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
    def parse(self, encoding=None, errors='strict', **kwargs):
        """
        Return the contents of toolbox settings file with a nested structure.

        :param encoding: encoding used by settings file
        :type encoding: str
        :param errors: Error handling scheme for codec. Same as ``decode()`` builtin method.
        :type errors: str
        :param kwargs: Keyword arguments passed to ``StandardFormat.fields()``
        :type kwargs: dict
        :rtype: ElementTree._ElementInterface
        """
        builder = TreeBuilder()
        for mkr, value in self.fields(encoding=encoding, errors=errors, **kwargs):
            # Check whether the first char of the field marker
            # indicates a block start (+) or end (-)
            block=mkr[0]
            if block in ("+", "-"):
                mkr=mkr[1:]
            else:
                block=None
            # Build tree on the basis of block char
            if block == "+":
                builder.start(mkr, {})
                builder.data(value)
            elif block == '-':
                builder.end(mkr)
            else:
                builder.start(mkr, {})
                builder.data(value)
                builder.end(mkr)
        return builder.close()

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
    def build(self, root=None):
        if root is None:
            was_root = True
            root = TreeBuilder()
        else:
            was_root = False

        root.start(self.tagname(), self.attrs())
        for i, child in enumerate(self.children):
            if isinstance(child, HTMLBuilder):
                child.build(root=root)
            else:
                if i in self._formatted:
                    try:
                        proxy = TreeProxy(root)
                        parser = XMLParser(html=True, target=proxy)
                        parser.feed(child)
                        proxy.cleanup()
                    except Exception as e:
                        print("Bad formatting", e)
                        root.data(str(child))
                else:
                    root.data(str(child))
        root.end(self.tagname())

        if was_root:
            root = root.close()
            return str(tostring(root, method="html").decode('utf-8'))

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def message(self):
     builder = TreeBuilder()
     builder.start(self.resource_type, dict())
     self.serialize(builder)
     builder.end(self.resource_type)
     msg = tostring(builder.close())
     return msg

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def save(self):
     '''saves action to file'''
     builder = TreeBuilder()
     builder.start("action", { "id" : str(self.id), "type" : str(self.type) })
     builder.start("name", {})
     builder.data(self.name)
     builder.end("name")
     self._write_type(builder)
     builder.end("action")
     doc = ElementTree(builder.close())
     doc.write(self.get_file(self.id))

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def _get_new_album_body(self, title):
     '''
     Формирует XML-элемент для нового альбома.
     @param title: string
     @return Element
     '''
     builder = TreeBuilder(Element)
     builder.start('entry', {'xmlns': ATOM_NS})
     builder.start('title', {})
     builder.data(title.decode('utf8'))
     builder.end('title')
     builder.end('entry')
     node = builder.close()
     return tostring(node)

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
def generate_nic(network):
    builder = TreeBuilder()
    builder.start('interface', {'type': network['type']})
    builder.start('mac', {'address': network['mac']})
    builder.end('mac')
    builder.start('source', network['source'])
    builder.end('source')
    builder.start('model', {'type':'virtio'})
    builder.end('model')
    builder.end('interface')
    return builder.close()

# vim:set sw=4 ts=4 et:
# -*- coding: utf-8 -*-

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
def write_xml(f, taxes, _solr=None, rows=0):
    """ Export an XML file for the given taxonomies to the (open) file handle
        specified.
    
        If a SOLR connection is supplied, then include document elements for
        each category.
    
    """
    x = TreeBuilder()
    x.start("taxonomy", {})

    def f_pre(term):
        x.start("category", {"id": str(term.uid)})
        x.start("name", {})
        x.data(term.name)
        x.end("name")
        for clue, positive in term.iter_clues():
            attrs = {}
            if not positive:
                attrs["negative"] = "true"
            x.start("clue", attrs)
            x.data(clue)
            x.end("clue")
        if _solr is not None:
            count, docs = get_docs_for_category(_solr, term, rows=rows)
            x.start("count", {})
            x.data(str(count))
            x.end("count")
            for doc_id, title, score in docs:
                x.start("doc", {"id": doc_id, "score": str(score)})
                x.start("name", {})
                x.data(title)
                x.end("name")
                x.end("doc")

    def f_post(term):
        x.end("category")

    for term in taxes:
        term.walk(f_pre, f_post)

    x.end("taxonomy")

    xml = ElementTree(x.close())
    xml.write(f, xml_declaration=True, encoding="utf-8")

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
def generate_disk(disk, devicename):
    """
    Creates XML representation of disk for libvirt based on disk_definition

    disk_definition is something like
            {
                'type': 'network',
                'device': 'disk',
                'format': 'raw',
                'source': {
                    'protocol': 'sheepdog',
                    'name': 'Alice',
                    'hosts': [('127.0.0.1', '7000'),],
                },
            }
     or
             {
                'type': 'file',
                'device': 'disk',
                'format': 'qcow2',
                'source': {
                    'file': '/var/lib/libvirt/images/Alice.img',
                },
            },

    devicename is string representing devicename (eg. vda, vdb, ...)
    """

    builder = TreeBuilder()
    builder.start('disk',
                {'type': disk['type'], 'device': disk['device']})
    builder.start('source', sans(disk['source'], 'hosts'))
    for host in disk['source'].get('hosts', []):
        builder.start('host', {'name': host[0], 'port': host[1]})
        builder.end('host')
    builder.end('source')
    builder.start('target', {'dev': devicename, 'bus': 'virtio'})
    builder.end('target')
    builder.start('driver', {'name': 'qemu', 'cache': 'none', 'type': disk['format']})
    builder.end('driver')
    builder.end('disk')
    return builder.close()

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
class XMLDumper(object):
    """XML-dumper for raw (unresolved) COD parse trees.
    """

    def __init__(self, output_file, log_file=sys.stderr):
        from xml.etree.ElementTree import TreeBuilder

        self._out = output_file
        self._log = log_file
        self._tb = TreeBuilder()

    def log(self, msg):
        print >>self._log, msg

    def start(self, tag, **attrs):
        return self._tb.start(tag, dict((k, str(v)) for k, v in attrs.iteritems()))

    def data(self, data):
        self._tb.data(data)
        return self

    def end(self, tag):
        x = self._tb.end(tag)
        self.data("\n")
        return x

    def close(self):
        from xml.etree.ElementTree import TreeBuilder

        x = self._tb.close()
        self._tb = TreeBuilder()
        return x

    def dump_cod(self, cod_file):
        from xml.etree.ElementTree import ElementTree

        self.start(type(cod_file).__name__)
        self.dump_struct(cod_file)
        self.end(type(cod_file).__name__)

        etree = ElementTree(self.close())
        etree.write(self._out)
        return etree

    def dump_struct(self, struct):
        for name in struct:
            self.dump_field(name, getattr(struct, name))

    def dump_field(self, name, value):
        from bytecleaver import Struct

        attrs = {"name": name}
        # try:
        #    attrs['raw'] = repr(value._C.get_range(value._start, value._end))
        # except:
        #    pass
        if isinstance(value, Struct):
            attrs["start"] = str(value._start)
            attrs["end"] = str(value._end)
            attrs["length"] = str(len(value))

        self.start(type(value).__name__, **attrs)
        self.dump_value(value)
        self.end(type(value).__name__)

    def dump_value(self, value):
        from bytecleaver import Struct

        if isinstance(value, Struct):
            self.dump_struct(value)
        elif type(value) is list:
            for i, item in enumerate(value):
                self.start(type(item).__name__, index=str(i))
                self.dump_value(item)
                self.end(type(item).__name__)
        else:
            self.data(repr(value))

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]

#.........这里部分代码省略.........
            attrs["position"] = str(node.position)

        if type(node) is not SchemeNode:
            attrs["scheme_node_type"] = "%s.%s" % (type(node).__name__,
                                                   type(node).__module__)
        builder.start("node", attrs)
        builder.end("node")

    builder.end("nodes")

    ## Links
    link_ids = defaultdict(inf_range().__next__)
    builder.start("links", {})
    for link in scheme.links:
        source = link.source_node
        sink = link.sink_node
        source_id = node_ids[source]
        sink_id = node_ids[sink]
        attrs = {"id": str(link_ids[link]),
                 "source_node_id": str(source_id),
                 "sink_node_id": str(sink_id),
                 "source_channel": link.source_channel.name,
                 "sink_channel": link.sink_channel.name,
                 "enabled": "true" if link.enabled else "false",
                 }
        builder.start("link", attrs)
        builder.end("link")

    builder.end("links")

    ## Annotations
    annotation_ids = defaultdict(inf_range().__next__)
    builder.start("annotations", {})
    for annotation in scheme.annotations:
        annot_id = annotation_ids[annotation]
        attrs = {"id": str(annot_id)}
        data = None
        if isinstance(annotation, SchemeTextAnnotation):
            tag = "text"
            attrs.update({"rect": repr(annotation.rect)})

            # Save the font attributes
            font = annotation.font
            attrs.update({"font-family": font.get("family", None),
                          "font-size": font.get("size", None)})
            attrs = [(key, value) for key, value in attrs.items()
                     if value is not None]
            attrs = dict((key, str(value)) for key, value in attrs)

            data = annotation.text

        elif isinstance(annotation, SchemeArrowAnnotation):
            tag = "arrow"
            attrs.update({"start": repr(annotation.start_pos),
                          "end": repr(annotation.end_pos)})

            # Save the arrow color
            try:
                color = annotation.color
                attrs.update({"fill": color})
            except AttributeError:
                pass

            data = None
        else:
            log.warning("Can't save %r", annotation)
            continue
        builder.start(tag, attrs)
        if data is not None:
            builder.data(data)
        builder.end(tag)

    builder.end("annotations")

    builder.start("thumbnail", {})
    builder.end("thumbnail")

    # Node properties/settings
    builder.start("node_properties", {})
    for node in scheme.nodes:
        data = None
        if node.properties:
            try:
                data, format = dumps(node.properties, format=data_format,
                                     pickle_fallback=pickle_fallback)
            except Exception:
                log.error("Error serializing properties for node %r",
                          node.title, exc_info=True)
            if data is not None:
                builder.start("properties",
                              {"node_id": str(node_ids[node]),
                               "format": format})
                builder.data(data)
                builder.end("properties")

    builder.end("node_properties")
    builder.end("scheme")
    root = builder.close()
    tree = ElementTree(root)
    return tree

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
 def serialize(self):
   builder = TreeBuilder()
   builder.start(self.resource_type, dict())
   self.encode(builder)
   builder.end(self.resource_type)
   return tostring(builder.close())

# 需要导入模块: from xml.etree.ElementTree import TreeBuilder [as 别名]
# 或者: from xml.etree.ElementTree.TreeBuilder import close [as 别名]
builder.start("trkseg", {})

for waypoint in route["waypointList"]:

	coords = {"lat":str(waypoint["lat"]), "lon":str(waypoint["lon"])}
	builder.start("trkpt", coords)
	
	builder.start("ele", {})
	builder.data(str(waypoint["alt"]))
	builder.end("ele")
	
	builder.start("time", {})
	time = datetime.utcfromtimestamp(waypoint["time"]/1000)
	builder.data(time.strftime("%Y-%m-%dT%H:%M:%SZ"))
	builder.end("time")
	
	builder.end("trkpt")

builder.end("trkseg")

builder.end("trk")

builder.end("gpx")

root = builder.close()

tree = ElementTree(root)

tree.write(open(sys.argv[1][:-5]+".gpx", "wb"), "utf-8")