Python cElementTree.Element类代码示例

 def _set_text(self, tag, text):
     elem = self._xmlnode.find(tag)
     if text != None:
         if elem == None:
             elem = Element(tag)
             self._xmlnode.append(elem)
         elem.text = text

    def write_xml(self, xml_doc=None, option=None, element_name=None):
        """ Method writes the XML representation of the external method object. """
        if xml_doc is None:
            xml_obj = Element(self.prop_mo_meta.xml_attribute)
        else:
            if element_name == None:
                xml_obj = SubElement(xml_doc, self.prop_mo_meta.xml_attribute)
            else:
                xml_obj = SubElement(xml_doc, element_name)
        
        for prop in CoreUtils.get_property_list(self._class_id):
            prop_meta = CoreUtils.get_method_property_meta(self._class_id, prop)
            if prop_meta.io == "Output":
                continue
            if prop_meta.is_complex_type:
                if self.get_attr(prop) != None:
                    self.__dict__[prop].write_xml(xml_obj, option, ImcUtils.word_l(prop))
                    #xml_obj.append(self.__dict__[prop].write_xml(xml_obj, option, ImcUtils.word_l(prop)))
                    #print ET.tostring(xml_obj)
            elif self.get_attr(prop) != None:
                xml_obj.set(prop_meta.xml_attribute, self.get_attr(prop))
                
        self.child_write_xml(xml_obj, option)
#        x_child = self.child_write_xml(xml_obj, option)
#        for xchild in x_child:
#            if xchild != None:
#                xml_obj.append(xchild)
        return xml_obj

def _fill_in_location_element(xml_root, location, data_fields):
    fixture_fields = [
        'name',
        'site_code',
        'external_id',
        'latitude',
        'longitude',
        'location_type',
        'supply_point_id',
    ]
    for field in fixture_fields:
        field_node = Element(field)
        val = getattr(location, field)
        field_node.text = six.text_type(val if val is not None else '')
        xml_root.append(field_node)

    # in order to be indexed, custom data fields need to be top-level
    # so we stick them in there with the prefix data_
    for field in data_fields:
        if field.index_in_fixture:
            field_node = Element(_get_indexed_field_name(field.slug))
            val = location.metadata.get(field.slug)
            field_node.text = six.text_type(val if val is not None else '')
            xml_root.append(field_node)

    xml_root.append(_get_metadata_node(location, data_fields))

    def rss2(feed, pretty_print=True):
        indent = '\n    ' if pretty_print else ''
        indent2 = '\n      ' if pretty_print else ''

        rss = Element('rss', version='2.0')
        rss.text = '\n  ' if pretty_print else ''

        channel = SubElement(rss, 'channel')
        channel.text = indent
        channel.tail = '\n' if pretty_print else ''

        set_rss2_text(SubElement(channel, 'title'), feed.title)
        set_rss2_text(SubElement(channel, 'description'), feed.subtitle or '')
        SubElement(channel, 'link').text = feed.link
        SubElement(channel, 'lastBuildDate').text = rss2_date(feed.updated)
        if feed.language: SubElement(channel, 'language').text = feed.language
        if feed.rights: SubElement(channel, 'copyright').text = feed.rights
        if feed.logo:
            image = SubElement(channel, 'image')
            image.text = indent2
            SubElement(image, 'url').text = feed.logo
            SubElement(image, 'title').text = ''
            SubElement(image, 'link').text = feed.link
            for child in image: child.tail = indent2
            image[-1].tail = '\n    ' if pretty_print else ''

        for entry in feed.entries:
            item = entry.rss2(pretty_print)
            item[-1].tail = indent
            channel.append(item)

        for child in channel: child.tail = indent
        channel[-1].tail = '\n  ' if pretty_print else ''
        return rss

    def add_nodes(self, G, graph_element):
        nodes_element = Element('nodes')
        for node,data in G.nodes_iter(data=True):
            node_data=data.copy()
            # 
            node_id=node_data.pop('id',make_str(node))
            kw={'id':node_id}
            label=node_data.pop('label',make_str(node))
            kw['label']=label

            pid=node_data.pop('pid',False)
            if pid:
                kw['pid']=pid
            if 'start' in node_data:
                kw['start']=make_str(node_data.pop('start'))
            if 'end' in node_data:
                kw['end']=make_str(node_data.pop('end'))
                
            # add node element with attributes                
            node_element = Element("node", **kw)

            # add node element and attr subelements
            default=G.graph.get('node_default',{})
            node_data=self.add_parents(node_element, node_data)
            if self.version=='1.1':
                node_data=self.add_slices(node_element, node_data)
            else:
                node_data=self.add_spells(node_element, node_data)
            node_data=self.add_viz(node_element,node_data)
            node_data=self.add_attributes("node", node_element, 
                                          node_data, default)
            nodes_element.append(node_element)
        graph_element.append(nodes_element)

	def saveXML(self):
		if ChannelsBase.channels_changed:
			
			channels = ChannelsBase.channels
			
			# Generate List in RAM
			root = None
			#splog("saveXML channels", channels)
			splog("SP saveXML channels", len(channels))
			
			# Build Header
			from plugin import NAME, VERSION
			root = Element(NAME)
			root.set('version', VERSION)
			root.append(Comment(_("Don't edit this manually unless you really know what you are doing")))
			
			# Build Body
			def build(root, channels):
				if channels:
					for reference, namealternatives in channels.iteritems():
						name, alternatives = namealternatives
						# Add channel
						element = SubElement( root, "Channel", name = stringToXML(name), reference = stringToXML(reference) )
						# Add alternatives
						if alternatives:
							for name in alternatives:
								SubElement( element, "Alternative" ).text = stringToXML(name)
				return root
			
			root = build( root, channels )
			
			self.writeXML( root )

    def to_xml(self):
        node = Element(self.__class__.__name__, {})

        for _annot in self._annotations:
            node.append(_annot.to_xml())

        return node

def generate_sitemap(links):
    urlset = Element(nstag("urlset"))  # , **nsmap_keyargs) # lxml
    urlset.text = "\n"
    for link in links:
        if isinstance(link, basestring):
            loc = link
            lastmod = changefreq = priority = None
        else:
            loc, lastmod, changefreq, priority = (tuple(link) + (None, None, None))[:4]
        url = SubElement(urlset, nstag("url"))
        url.text = url.tail = "\n"
        SubElement(url, nstag("loc")).text = loc
        if lastmod:
            if not isinstance(lastmod, basestring):
                if getattr(lastmod, "tzinfo", None) is not None:
                    lastmod = lastmod.replace(tzinfo=None) - lastmod.utcoffset()
                lastmod = lastmod.strftime("%Y-%m-%dT%H:%M:%SZ")
            SubElement(url, nstag("lastmod")).text = lastmod
        if changefreq:
            SubElement(url, nstag("changefreq")).text = changefreq
        if priority is not None:
            SubElement(url, nstag("priority")).text = str(priority)
        for child in url:
            child.tail = "\n"
    return urlset

    def iq_handler(self, xml):
        iq = CloudDotIQ(xml)
        print "Got IQ", type(iq), iq

        data = iq.data
        print "Data:", repr(data)
        numBytes = iq.numReturnBytes

        # Set the DM's flag that we're using the device.
        # This is definitely incorrect, but it may be good enough.
        self.dm.scanEvent.wait()
        try:
            self.dm.scanEvent.clear()
            self.device.write(data, modbus=True, checksum=False)
            result = self.device.read(numBytes, modbus=True)
            result = struct.pack("B" * len(result), *result)
        finally:
            self.dm.scanEvent.set()

        # We have the result, send it back in the response.
        etIq = self.Iq(xml=xml)
        result = base64.b64encode(result)
        reply = etIq.reply()
        dataElem = Element("data")
        dataElem.text = result
        qt = Element("query", {"xmlns": "jabber:iq:clouddot"})
        qt.append(dataElem)
        print "qt", qt

        reply.appendxml(qt)
        print "etIq.reply() redux:", reply

        reply.send(block=False)

    def save_graph(self, filename, graph):
        root = Element("statespace")
        root.set("init-node-id", graph.get_root().get_id())

        def save_node(node):
            node_el = SubElement(root, "node")
            node_el.set("id", str(node.get_id()))
            node_el.set("size", str(node.get_size()))
            return node_el

        def save_edge(edge, parent_node_el):
            edge_el = SubElement(parent_node_el, "arc")
            edge_el.set("node-id", edge.get_target().get_id())
            edge_el.set("label", edge.get_label())
            edge_el.set("events-count", str(edge.get_events_count()))
            edge_el.set("time", str(edge.get_time()))
            edge_el.set("pids", str(edge.get_pids()))
            return edge_el

        for n in graph.nodes.values():
            n_el = save_node(n)
            for e in n.get_edges():
                save_edge(e, n_el)

        with open(self.filename, "w") as f:
            f.write(utils.get_pretty_xml(root))
            f.flush()

    def build_indicators_node(self):
        result = Element(self.INDICATORS)
        self._add_possible_dataset_specified_indicators_to_dict()
        for data_indicator in self._indicator_dic:
            result.append(self.build_indicator_node(self._indicator_dic[data_indicator]))

        self._root.append(result)

    def start(self, tag, attrib=None):
        if tag == "_ignore_":
            return self._last
        elif tag in ("h", "p", "pre"):
            self._flush(need_eol=2)
        else:
            self._flush()
            # ~ print 'START', tag

        if tag == "h":
            if not (attrib and "level" in attrib):
                logger.warn('Missing "level" attribute for heading')
                attrib = attrib or {}
                attrib["level"] = 1
        elif tag == "link":
            if not (attrib and "href" in attrib):
                logger.warn('Missing "href" attribute for link')
                attrib = attrib or {}
                attrib["href"] = "404"
                # TODO check other mandatory properties !

        if attrib:
            self._last = Element(tag, attrib)
        else:
            self._last = Element(tag)

        if self._stack:
            self._stack[-1].append(self._last)
        else:
            assert tag == "zim-tree", 'root element needs to be "zim-tree"'
        self._stack.append(self._last)

        self._tail = False
        return self._last

	def save(self):
		# Generate List in RAM
		root = None
		services = self.services
		controllers = self.controllers
		
		# Build Header
		from plugin import NAME, VERSION
		root = Element(NAME)
		root.set('version', VERSION)
		root.append(Comment(_("Don't edit this manually unless you really know what you are doing")))
		
		# Build Body
		def build(root, instances, typ):
			for instance in instances:
				# Add module
				element = SubElement( root, typ, name = stringToXML(instance.getName()), enable = stringToXML(instance.getStringEnable()) )
				# Add options
				options = instance.getStringOptions()
				if options:
					for key, value, description in options:
						SubElement( element, OPTION, key = stringToXML(key) ).text = stringToXML(value)
			return root
		
		if services:
			root = build( root, services, SERVICE)
		if controllers:
			root = build( root, controllers, CONTROLLER)
		
		self.writeXML( root )

def main():
    options, args = parse_args()
    rootElement = Element('packages')

    packages = {}

    print "Searching for packages.config files:"

    for dirpath, subdirs, filenames in walk('src'):
        for filename in filenames:
            if filename == 'packages.config':
                filepath = join(dirpath, filename)
                print "    " + filepath
                et = parse(filepath)
                for packageElement in et.findall('package'):
                    pkgId = packageElement.get('id')
                    pkgVersion = packageElement.get('version')
                    packages[pkgId, pkgVersion] = packageElement

    print
    print "Writing projectdata/packages.config:"
    rootElement.extend([value for (key,value) in sorted(packages.items())])
    indent(rootElement)
    tree = ElementTree(rootElement)
    dump(tree)
    tree.write('projectdata/packages.config')

 def add_nodes(self, G, graph_element):
     nodes_element = Element('nodes')
     for node, data in G.nodes(data=True):
         node_data = data.copy()
         node_id = make_str(node_data.pop('id', node))
         kw = {'id': node_id}
         label = make_str(node_data.pop('label', node))
         kw['label'] = label
         try:
             pid = node_data.pop('pid')
             kw['pid'] = make_str(pid)
         except KeyError:
             pass
         # add node element with attributes
         node_element = Element('node', **kw)
         # add node element and attr subelements
         default = G.graph.get('node_default', {})
         node_data = self.add_parents(node_element, node_data)
         if self.version == '1.1':
             node_data = self.add_slices(node_element, node_data)
         else:
             node_data = self.add_spells(node_element, node_data)
         node_data = self.add_viz(node_element, node_data)
         node_data = self.add_attributes('node', node_element,
                                         node_data, default)
         nodes_element.append(node_element)
     graph_element.append(nodes_element)