Python ElementTree.iselement方法代码示例

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
	def get_client_info(self, client, newClient, _ElementTree):
		eaptypes = client.find('eap-types')
		if ElementTree.iselement(eaptypes):
			eaptypes = eaptypes.text
			if eaptypes != None:
				for eaptype in eaptypes.strip().split(','):
					if eaptype.isdigit():
						newClient.addEapType(int(eaptype))
		identities = client.findall('identity') or []
		for identity in identities:
			tmp = identity.get('eap-type')
			if tmp.isdigit():
				newClient.add_identity(int(tmp), identity.text.strip())
		mschaps = client.findall('mschap') or []
		for mschap in mschaps:
			newClient.add_ms_chap_info(
				int(mschap.get('eap-type')),
				binascii.a2b_hex(mschap.find('challenge').text.strip().replace(':', '')),
				binascii.a2b_hex(mschap.find('response').text.strip().replace(':', '')),
				mschap.get('identity')
			)
		wpsXMLData = client.find('wps-data')
		if ElementTree.iselement(wpsXMLData):
			wpsData = wpsDataHolder()
			for elem in wpsXMLData:
				key = elem.tag.replace('-', ' ')
				value = elem.text.strip()
				if elem.get('encoding') == 'hex':
					wpsData[key] = binascii.a2b_hex(value)
				elif elem.get('encoding') == 'base64':
					wpsData[key] = base64.standard_b64decode(value)
				else:
					wpsData[key] = value
			if len(wpsData):
				newClient.wpsData = wpsData

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def Element(tag, attrib={}, *children, **extra):
    """ Element(tag (,attrdict)? (,subelement|string)* ) -> Element """

    if isinstance(attrib, dict):
        attrib = attrib.copy()
    else:
        children = (attrib,) + children 
        attrib = {}
    attrib.update(extra)

    element = basefactory(tag, attrib)

    prevelem = None
    for arg in children:
        if ElementTree.iselement(arg):
            element.append(arg)
            prevelem = arg
        else:
            if isinstance(arg, basestring):
                if prevelem is None:
                    element.text = (element.text or '') + arg
                else:
                    prevelem.tail = (prevelem.tail or '') + arg
            else:
                try:
                    it = iter(arg)
                except:
                    raise TypeError, "argument type to Element"
                for item in it:
                    if not ElementTree.iselement(item):
                        raise TypeError, "invalid argument type to Element"
                    element.append(item)
    return element

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
	def get_network_info(self, network, newNetwork, _ElementTree, ssid):
		for bssid in network.findall('BSSID'):
			bssid = bssid.text.strip()
			newNetwork.add_BSSID(bssid)
			if ssid != UNKNOWN_SSID_NAME:
				self.BSSIDToSSIDMap[bssid] = ssid
			else:
				self.BSSIDToSSIDMap[bssid] = bssid
				self.OrphanedBSSIDs.append(bssid)
		eaptypes = network.find('SSID').find('eap-types')
		if ElementTree.iselement(eaptypes):
			for eaptype in eaptypes.text.strip().split(','):
				if eaptype.isdigit():
					newNetwork.addEapType(int(eaptype))
		expandedVendorIDs = network.find('SSID').find('expanded-vendor-ids')
		if ElementTree.iselement(expandedVendorIDs):
			for vendorid in expandedVendorIDs.text.strip().split(','):
				if vendorid.isdigit():
					newNetwork.add_expanded_vendor_id(int(vendorid))
		wpsXMLData = network.find('wps-data')
		if ElementTree.iselement(wpsXMLData):
			wpsData = wpsDataHolder()
			for elem in wpsXMLData:
				key = elem.tag.replace('-', ' ')
				value = elem.text.strip()
				encoding = elem.get('encoding')
				if encoding == 'hex':
					wpsData[key] = binascii.a2b_hex(value)
				elif encoding == 'base64':
					wpsData[key] = base64.standard_b64decode(value)
				else:
					wpsData[key] = value
			if len(wpsData):
				newNetwork.wpsData = wpsData

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
 def GET(self, resource_id, metadata_name):
   web.header('Content-Type', 'text/xml');
   print('get_resource_id_metadata_by_name');
   print "getting resourceID="+str(resource_id)+" metadata="+str(metadata_name)+'content_type='+str(http_content_type);
   for child in root:
     if child.attrib['resourceid'] == str(resource_id):
       resource = child;
       common_metadata   = resource.find('CommonMetadata');
       specific_metadata = resource.find('SpecificMetadata');
       
       resource_type = str(common_metadata.find('Type').text).strip();
       
       # Resource specific metadata to restrict search in case of redundant
       # tag/element names
       resource_specific_metadata = specific_metadata.find(resource_type);
       
       print('resource_specific_metadata='+str(ET.tostring(resource_specific_metadata, 'utf-8', method='xml')));
       
       if resource_type == resource_hypermodel:
         print("switch case\n") ;
       
       elif resource_type == resource_hypermodel:
         print("switch case\n"+resource_hypermodel) ;
       elif resource_type == resource_dataset:
         print("switch case\n"+resource_dataset) ;
       
       print('resource_type='+resource_type);
       
       try:
         xml_element_specific = resource_specific_metadata.find(metadata_name);
         xml_element_common   = common_metadata.find(metadata_name);
         
         if ET.iselement(xml_element_common):
           output = ET.tostring(xml_element_common, 'utf-8', method='xml')
           xml_element = xml_element_common
         elif ET.iselement(xml_element_specific):
           output = ET.tostring(xml_element_specific, 'utf-8', method='xml')
           xml_element =xml_element_specific;
         
         
         print 'output='+str(output);
         
         if http_content_type != 'xml':
           output == xml_element.text;
         
         #description = common_meta_data.find('Description');
         #output = ET.tostring(description, 'utf-8', method='xml')
         #output = description.text;
         return output
       
       except:
         print('exception raised')
         app.notfound();
         return;
   
   app.notfound();

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def addContent(parent, content):
    if ET.iselement(parent):
        if ET.iselement(content):
            parent.append(content)
        else:
            parent.text = content
    else:
        if ET.iselement(content):
            parent.text = ET.tostring(content)
        else:
            parent.text = content
            

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
	def __call__(self, tag, *children, **attrib):
		get = self._typemap.get

		if self._namespace is not None and tag[0] != '{':
			tag = self._namespace + tag
		
		if self._nsmap:
			elem = self._makeelement(tag, nsmap=self._nsmap)
		else:
			elem = self._makeelement(tag)
			
		if attrib:
			get(dict)(elem, attrib)

		for item in children:
			if callable(item):
				item = item()
			t = get(type(item))
			if t is None:
				if ET.iselement(item):
					elem.append(item)
					continue
				raise TypeError("bad argument type: %r" % item)
			else:
				v = t(elem, item)
				if v:
					get(type(v))(elem, v)

		return elem

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
 def update_xml_element (self, value=None):
     r"""
         updates inner XML element's attr name along @value param;
         returns True on success, False otherwise;
     """
     # param inits
     if value is None:
         value = self.value
     # end if
     if ET.iselement(self.xml_element):
         # update XML element
         self.xml_element.set(self.name, value)
         # succeeded
         return True
     else:
         raise TypeError(
             "XML element must be of "
             "type '{obj_type}', not '{cur_type}'."
             .format(
                 obj_type=repr(ET.Element),
                 cur_type=repr(self.xml_element),
             )
         )
     # end if
     # failed
     return False

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def handle_entity_prefix(tree, prefix):

    # Collect name of fields which are defined in this form. This is
    # used as we only want to handle prefixes on fieldname and
    # expression for fields which are defined in the form.
    fieldnames = set([f.get("name") for f in tree.findall(".//entity")])

    def replace_fieldnames(m):
        # TODO: Handle % and @ variables to? (ti) <2015-12-17 09:30>
        v = m.group(1)
        if v in fieldnames:
            return "$" + prefix + v
        return m.group(0)

    for n in tree.iter():
        if not ET.iselement(n):
            continue
        if n.tag == "entity":
            # Handle fields
            n.attrib["name"] = prefix + n.attrib["name"]
        elif n.tag in ("rule", "if"):
            # Handle rules and conditionals
            n.attrib["expr"] = _var_re.sub(replace_fieldnames,
                                           n.attrib["expr"])

    return tree

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
    def __format_element(elt_data):
        """
            Private method which ensures that a XML portion to be parsed is
            of type xml.etree.ElementTree.Element.
            If elt_data is a string, then it is converted to an
            XML Element type.

            :param elt_data: XML Element to be parsed or string
            to be converted to a XML Element

            :return: Element
        """
        if isinstance(elt_data, str):
            try:
                xelement = ET.fromstring(elt_data)
            except:
                raise NmapParserException("Error while trying "
                                          "to instanciate XML Element from "
                                          "string {0}".format(elt_data))
        elif ET.iselement(elt_data):
            xelement = elt_data
        else:
            raise NmapParserException("Error while trying to parse supplied "
                                      "data: unsupported format")
        return xelement

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def to_string(obj):
    """Get string representation of an object, special-case for XML Element.

    Args:
      obj (object): Object to represent as a string.
    Returns:
      str: string representation
    Examples:
      ::

        >>> to_string("Hello")
        'Hello'
        >>> to_string(27.5)
        '27.5'
        >>> e = ET.Element('hello', attrib={'key': 'value'})
        >>> print(e)   # doctest: +ELLIPSIS
        <Element ...hello... at ...>
        >>> print(to_string(e))
        <hello key="value" />
    """
    if ET.iselement(obj):
        if sys.version_info[0] >= 3:
            return ET.tostring(obj, encoding='unicode')
        else:
            return ET.tostring(obj)
    else:
        return str(obj)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def read_isce_xml(fname, standardize=True):
    """Read ISCE .xml file into a python dict structure."""
    root = ET.parse(fname).getroot()
    xmlDict = {}

    # imageFile, e.g. filt_fine.unw.xml
    if root.tag.startswith('image'):
        for child in root.findall('property'):
            key = child.get('name')
            value = child.find('value').text
            xmlDict[key] = value

        # Read lat/lon info for geocoded file
        # in form: root/component coordinate*/property name/value
        for coord_name, prefix in zip(['coordinate1', 'coordinate2'], ['X', 'Y']):
            child = root.find("./component[@name='{}']".format(coord_name))
            if ET.iselement(child):
                v_step  = float(child.find("./property[@name='delta']").find('value').text)
                v_first = float(child.find("./property[@name='startingvalue']").find('value').text)
                if abs(v_step) < 1. and abs(v_step) > 1e-7:
                    xmlDict['{}_STEP'.format(prefix)] = v_step
                    xmlDict['{}_FIRST'.format(prefix)] = v_first - v_step / 2.

    # PAMDataset, e.g. hgt.rdr.aux.xml
    elif root.tag == 'PAMDataset':
        meta = root.find("./Metadata[@domain='ENVI']")
        for child in meta.findall("MDI"):
            key = child.get('key')
            value = child.text
            xmlDict[key] = value
        xmlDict['data_type'] = ENVI2NUMPY_DATATYPE[xmlDict['data_type']]

    if standardize:
        xmlDict = standardize_metadata(xmlDict)
    return xmlDict

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
    def __format_attributes(elt_data):
        """
            Private method which converts a single XML tag to a python dict.
            It also checks that the elt_data given as argument is of type
            xml.etree.ElementTree.Element

            :param elt_data: XML Element to be parsed or string
            to be converted to a XML Element

            :return: Element
        """

        rval = {}
        if not ET.iselement(elt_data):
            raise NmapParserException("Error while trying to parse supplied "
                                      "data attributes: format is not XML or "
                                      "XML tag is empty")
        try:
            for dkey in elt_data.keys():
                rval[dkey] = elt_data.get(dkey)
                if rval[dkey] is None:
                    raise NmapParserException("Error while trying to build-up "
                                              "element attributes: empty "
                                              "attribute {0}".format(dkey))
        except:
            raise
        return rval

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def main():
    print "Before Post Parse ETree"
    for root, dirs, files in os.walk(POSTS_PATH):
        for one_file in files:
	    populatePostDictionary(one_file, root)
            
    print "Before User Parse ETree"
    userTree = ET.parse('/mnt/stackoverflow/data/users/stackoverflow.com-Users.xml')
    print "Before User Processing Dictionary"
   
    processUserFile(userTree)

    f2 = open ('/mnt/stackoverflow/data/output/targetDocUserDataDone.txt', 'a')
    f2.write("UserDataDictionaryDone")
    f2.close()

    #done all processing of parents
    for root, dirs, files in os.walk(POSTS_PATH):
        for one_file in files:
            postTree = ET.parse(os.path.join(root,one_file))
            postDocRoot= postTree.getroot()
            for child in postDocRoot:
                if ET.iselement(child):
                    if PARENT_ID in child.attrib:
                        processChild(child)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
 def open(self, string_or_file):
     if isinstance(string_or_file, basestring):
         string_or_file = ElementTree.fromstring(string_or_file)
     elif not ElementTree.iselement(string_or_file):
         string_or_file = ElementTree.parse(string_or_file)
     if string_or_file.getroot().tag == self._get_qname('gpx'):
         self._root = string_or_file.getroot()

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import iselement [as 别名]
def extractAttrByXpath(xpath, nameSpace, ele, tagAttr):
    nodes = ele.xpath(xpath, nameSpace=None)
    result = []
    for node in nodes:
        if ET.iselement(node):
            result.append(node.attrib[tagAttr])
    return result[0] if len(result) == 1 else result