Python Element.append方法代码示例

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    def to_xml(self):
        node = Element(self.__class__.__name__, {})

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

        return node

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
	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 )

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    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

            # 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)
            node_data = self.add_slices(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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    def add_edges(self, G, graph_element):
        def edge_key_data(G):
            # helper function to unify multigraph and graph edge iterator
            if G.is_multigraph():
                for u, v, key, data in G.edges_iter(data=True, keys=True):
                    edge_data = data.copy()
                    edge_data.update(key=key)
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                    yield u, v, edge_id, edge_data
            else:
                for u, v, data in G.edges_iter(data=True):
                    edge_data = data.copy()
                    edge_id = edge_data.pop("id", None)
                    if edge_id is None:
                        edge_id = next(self.edge_id)
                    yield u, v, edge_id, edge_data

        edges_element = Element("edges")
        for u, v, key, edge_data in edge_key_data(G):
            kw = {"id": make_str(key)}
            edge_weight = edge_data.pop("weight", False)
            if edge_weight:
                kw["weight"] = make_str(edge_weight)
            edge_type = edge_data.pop("type", False)
            if edge_type:
                kw["type"] = make_str(edge_type)
            edge_element = Element("edge", source=make_str(u), target=make_str(v), **kw)
            default = G.graph.get("edge_default", {})
            edge_data = self.add_viz(edge_element, edge_data)
            edge_data = self.add_attributes("edge", edge_element, edge_data, default)
            edges_element.append(edge_element)
        graph_element.append(edges_element)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 def get_attr_id(self, title, attr_type, edge_or_node, default, mode):
     # find the id of the attribute or generate a new id
     try:
         return self.attr[edge_or_node][mode][title]
     except KeyError:
         # generate new id
         new_id = str(next(self.attr_id))
         self.attr[edge_or_node][mode][title] = new_id
         attr_kwargs = {'id': new_id, 'title': title, 'type': attr_type}
         attribute = Element('attribute', **attr_kwargs)
         # add subelement for data default value if present
         default_title = default.get(title)
         if default_title is not None:
             default_element = Element('default')
             default_element.text = make_str(default_title)
             attribute.append(default_element)
         # new insert it into the XML
         attributes_element = None
         for a in self.graph_element.findall('attributes'):
             # find existing attributes element by class and mode
             a_class = a.get('class')
             a_mode = a.get('mode', 'static') # default mode is static
             if a_class == edge_or_node and a_mode == mode:
                 attributes_element = a
         if attributes_element is None:
             # create new attributes element
             attr_kwargs = {'mode': mode, 'class': edge_or_node}
             attributes_element = Element('attributes', **attr_kwargs)
             self.graph_element.insert(0, attributes_element)
         attributes_element.append(attribute)
     return new_id

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    def build_time_node(self, ref_time):
        #Building top node
        time_node = Element(self.TIME)

        #Managging different time instances
        if type(ref_time) is Instant:
            time_node.attrib[self.TIME_ATT_UNIT] = "instant"
            time_node.text = ref_time.get_time_string()
        elif type(ref_time) is YearInterval:
            time_node.attrib[self.TIME_ATT_UNIT] = "years"
            time_node.text = ref_time.get_time_string()
        elif type(ref_time) is MonthInterval:
            time_node.attrib[self.TIME_ATT_UNIT] = "months"
            time_node.text = ref_time.get_time_string()
        elif type(ref_time) is Interval:
            if ref_time.frequency == Interval.YEARLY:
                time_node.attrib[self.TIME_ATT_UNIT] = "years"
            else:
                time_node.attrib[self.TIME_ATT_UNIT] = "months"
            interval_node = Element(self.TIME_INTERVAL)
            beg_node = Element(self.TIME_INTERVAL_BEG)
            beg_node.text = str(ref_time.start_time)
            end_node = Element(self.TIME_INTERVAL_END)
            end_node.text = str(ref_time.end_time)
            interval_node.append(beg_node)
            interval_node.append(end_node)
            time_node.append(interval_node)

        else:
            raise RuntimeError("Unrecognized time type. Impossible to build node")
        #Returning final node
        return time_node

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
	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 )

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 def add_attributes(self, node_or_edge, xml_obj, data, default):
     # Add attrvalues to node or edge
     attvalues = Element("attvalues")
     if len(data) == 0:
         return data
     if "start" in data or "end" in data:
         mode = "dynamic"
     else:
         mode = "static"
     for k, v in list(data.items()):
         # rename generic multigraph key to avoid any name conflict
         if k == "key":
             k = "networkx_key"
         attr_id = self.get_attr_id(make_str(k), self.xml_type[type(v)], node_or_edge, default, mode)
         if type(v) == list:
             # dynamic data
             for val, start, end in v:
                 e = Element("attvalue")
                 e.attrib["for"] = attr_id
                 e.attrib["value"] = make_str(val)
                 e.attrib["start"] = make_str(start)
                 e.attrib["end"] = make_str(end)
                 attvalues.append(e)
         else:
             # static data
             e = Element("attvalue")
             e.attrib["for"] = attr_id
             e.attrib["value"] = make_str(v)
             attvalues.append(e)
     xml_obj.append(attvalues)
     return data

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
    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)

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 def add_attributes(self, node_or_edge, xml_obj, data, default):
     # Add attrvalues to node or edge
     attvalues=Element('attvalues')
     if len(data)==0:
         return data
     if 'start' in data or 'end' in data:
         mode='dynamic'
     else:
         mode='static'
     for k,v in data.items():
         # rename generic multigraph key to avoid any name conflict
         if k == 'key':
             k='networkx_key' 
         attr_id = self.get_attr_id(make_str(k), self.xml_type[type(v)],
                                    node_or_edge, default, mode)
         if type(v)==list:
             # dynamic data
             for val,start,end in v:
                 e=Element("attvalue")                
                 e.attrib['for']=attr_id
                 e.attrib['value']=make_str(val)
                 e.attrib['start']=make_str(start)
                 e.attrib['end']=make_str(end)
                 attvalues.append(e)                    
         else:
             # static data
             e=Element("attvalue")
             e.attrib['for']=attr_id
             e.attrib['value']=make_str(v)
             attvalues.append(e)
     xml_obj.append(attvalues)
     return data

# 需要导入模块: from xml.etree.cElementTree import Element [as 别名]
# 或者: from xml.etree.cElementTree.Element import append [as 别名]
 def list_to_xml(l, item):
     el = Element("data")
     for val in l:
         child = Element(item)
         child.text = str(val)
         el.append(child)
     print(tostring(el))