Python Element.getElementsByTagName Examples, xml.dom.minidom.Element.getElementsByTagName Python Examples (2024)

 def __renderClassDiagram(self, documentNode: Element, toOgl: MiniDomToOglV10, umlFrame: UmlDiagramsFrame): """ Args: documentNode: A minidom document element toOgl: The converter class umlFrame: Where to render """ oglClasses: OglClasses = toOgl.getOglClasses( documentNode.getElementsByTagName( PyutXmlConstants.ELEMENT_GRAPHIC_CLASS)) oglNotes: OglNotes = toOgl.getOglNotes( documentNode.getElementsByTagName( PyutXmlConstants.ELEMENT_GRAPHIC_NOTE)) oglInterfaces: OglInterfaces = toOgl.getOglInterfaces( documentNode.getElementsByTagName( PyutXmlConstants.ELEMENT_GRAPHIC_LOLLIPOP), oglClasses) oglTextShapes: OglTextShapes = toOgl.getOglTextShapes( documentNode.getElementsByTagName( PyutXmlConstants.ELEMENT_GRAPHIC_TEXT)) mergedOglObjects: OglObjects = cast(OglObjects, oglClasses.copy()) mergedOglObjects.update(oglNotes) self.__displayTheClasses(oglClasses, umlFrame) oglLinks: OglLinks = toOgl.getOglLinks( documentNode.getElementsByTagName( PyutXmlConstants.ELEMENT_GRAPHIC_LINK), mergedOglObjects) self.__displayTheLinks(oglLinks, umlFrame) self.__displayTheNotes(oglNotes, umlFrame) self.__displayTheTextShapes(oglTextShapes, umlFrame) self.__displayTheInterfaces(oglInterfaces, umlFrame)

 def __renderUseCaseDiagram(self, documentNode: Element, toOgl: MiniDomToOglV10, umlFrame: UmlDiagramsFrame): """ Args: documentNode: A minidom document element toOgl: The converter class umlFrame: Where to render """ oglObjects: OglObjects = cast(OglObjects, {}) oglActors: OglActors = toOgl.getOglActors( documentNode.getElementsByTagName('GraphicActor')) oglUseCases: OglUseCases = toOgl.getOglUseCases( documentNode.getElementsByTagName('GraphicUseCase')) oglNotes: OglNotes = toOgl.getOglNotes( documentNode.getElementsByTagName('GraphicNote')) self.__displayTheActors(oglActors, umlFrame) self.__displayTheUseCases(oglUseCases, umlFrame) self.__displayTheNotes(oglNotes, umlFrame) mergedOglObjects: OglObjects = cast(OglObjects, oglObjects.copy()) mergedOglObjects.update(oglActors) mergedOglObjects.update(oglNotes) mergedOglObjects.update(oglUseCases) oglLinks: OglLinks = toOgl.getOglLinks( documentNode.getElementsByTagName("GraphicLink"), mergedOglObjects) self.__displayTheLinks(oglLinks, umlFrame)

def getStorageSize(nodeParam: minidom.Element, unit: str) -> str: addr = nodeParam.getElementsByTagName('address') if addr and addr[0]: addrLength = addr[0].getAttribute('length') if addrLength: return 8 * int(addrLength) for item in nodeParam.getElementsByTagName('conversion'): if unit == item.getAttribute('units'): storagetype = item.getAttribute('storagetype') if storagetype == 'uint16': return 16 return None

 def parseParty(self, xmlParty: Element) -> InvoiceParty: party = InvoiceParty() xml_ident = xmlParty.getElementsByTagName("cac:PartyIdentification")[0] party.taxId = xmlExtractText(xml_ident, 'cbc:ID') party.accountNumber = "" xml_party_name = xmlParty.getElementsByTagName("cac:PartyName")[0] party.name = xmlExtractText(xml_party_name, 'cbc:Name') xml_address = xmlParty.getElementsByTagName("cac:PostalAddress")[0] party.streetAndNumber = xmlExtractText(xml_address, 'cbc:StreetName') party.cityName = xmlExtractText(xml_address, 'cbc:CityName') party.postalCode = xmlExtractText(xml_address, 'cbc:PostalZone') party.country = xmlExtractText(xml_address, 'cbc:IdentificationCode') return party

 def _parse_element_to_list_of_dict(root: minidom.Element, component: Dict[str, Any], tag: str) -> List[Any]: """ Parse the complex application elements (i.e. parse also the "meta-data" and "intent-filter" information). :param root: The XML element. :param component: The XML element (dictionary of tag and attributes). :param tag: The root element tag (e.g. 'activity', 'service' or 'receiver'). :return: The list of attribute values. """ res = [] for element in root.getElementsByTagName(tag): data = {} for key, value in component.items(): if type(value) is dict: tmp = AndroidManifest._parse_element_to_list_of_dict(element, component[key], key) if len(tmp) > 0: data[key] = tmp elif type(value) is list: tmp = AndroidManifest._parse_element_to_simple_list(element, key, value[0]) if len(tmp) > 0: tmp.sort() data[key] = tmp else: # type(value) is str (in Python 2.7 this will be unicode) if element.hasAttribute(component[key]): data[key] = element.getAttribute(component[key]) res.append(data) return res

 def _getFields(self, xmlClass: Element) -> PyutFields: """ Extracts fields from a DOM element that represents a UML class Args: xmlClass: The DOM version of a UML class Returns: PyutFields """ pyutFields: PyutFields = cast(PyutFields, []) for element in xmlClass.getElementsByTagName(PyutXmlConstants.ELEMENT_MODEL_FIELD): xmlField: Element = cast(Element, element) pyutField: PyutField = PyutField() strVis: str = xmlField.getAttribute(PyutXmlConstants.ATTR_VISIBILITY) vis: PyutVisibilityEnum = PyutVisibilityEnum.toEnum(strVis) pyutField.setVisibility(vis) xmlParam: Element = xmlField.getElementsByTagName(PyutXmlConstants.ELEMENT_MODEL_PARAM)[0] if xmlParam.hasAttribute(PyutXmlConstants.ATTR_DEFAULT_VALUE): pyutField.setDefaultValue(xmlParam.getAttribute(PyutXmlConstants.ATTR_DEFAULT_VALUE)) pyutField.setName(xmlParam.getAttribute(PyutXmlConstants.ATTR_NAME)) pyutType: PyutType = PyutType(xmlParam.getAttribute(PyutXmlConstants.ATTR_TYPE)) pyutField.setType(pyutType) pyutFields.append(pyutField) return pyutFields

 def _parse_element_to_list_of_dict(root: minidom.Element, component: Dict[str, Any], tag: str) -> List[Any]: """ Parse the complex application elements (i.e. parse also the "meta-data" and "intent-filter" information). :param root: The XML element. :param component: The XML element (dictionary of tag and attributes). :param tag: The root element tag (e.g. 'activity', 'service' or 'receiver'). :return: The list of attribute values. """ res = [] for element in root.getElementsByTagName(tag): data = {} for key, value in component.items(): if type(value) is dict: tmp = AndroidManifest._parse_element_to_list_of_dict( element, component[key], key) if len(tmp) > 0: data[key] = tmp elif type(value) is list: tmp = AndroidManifest._parse_element_to_simple_list( element, key, value[0]) if len(tmp) > 0: tmp.sort() data[key] = tmp else: # type(value) is str (in Python 2.7 this will be unicode) if element.hasAttribute(component[key]): data[key] = element.getAttribute(component[key]) res.append(data) return res

 def _getParam(self, Param: Element, pyutMethod: PyutMethod): """ Extract param from Xmi file from Class part. Args: Param: pyutMethod: Returns: PyutParam """ aParam = PyutParam() # param's name name = Param.getElementsByTagName( "Foundation.Core.ModelElement.name")[0].firstChild if name.nodeType == name.TEXT_NODE: self.logger.debug(f'Parameter name: {name.data}') if name.data[-6:] == "Return" or name.data[-6:] == "return": self._getTypeId(Param, pyutMethod, self.dicoReturn) return None else: aParam.setName(name.data) # default value self._getDefaultValue(Param, aParam) # for type self._getTypeId(Param, aParam, self.dicoType) return aParam

 def __init__(self, dom_element: Element) -> None: self._dom_element = dom_element message_cdata = dom_element.getElementsByTagName('log4j:message')[0].firstChild message_cdata_string = '' if message_cdata is not None: message_cdata_string = message_cdata.data throwable_list = self._dom_element.getElementsByTagName('log4j:throwable') if len(throwable_list) == 1: throwable_element = throwable_list[0] else: throwable_element = dom_element.ownerDocument.createElementNS('log4j', 'throwable') location_info_list = self._dom_element.getElementsByTagName('log4j:locationInfo') if len(location_info_list) == 1: location_info_element = location_info_list[0] else: location_info_element = self._dom_element.ownerDocument.createElementNS('log4j', 'locationInfo') location_info = DomLocationInfo(location_info_element) Event.__init__( self, dom_element.getAttribute("logger"), dom_element.getAttribute("timestamp"), dom_element.getAttribute("level"), dom_element.getAttribute("thread"), message_cdata_string, throwable_element, location_info )

 def _getPyutLink(self, obj: Element): """ Args: obj: The GraphicLink DOM element Returns: A tuple of a source ID, destination ID, and a PyutLink object """ link: Element = obj.getElementsByTagName( PyutXmlConstants.ELEMENT_MODEL_LINK)[0] pyutLink: PyutLink = PyutLink() pyutLink.setBidir( bool(link.getAttribute(PyutXmlConstants.ATTR_BIDIRECTIONAL))) pyutLink.destinationCardinality = link.getAttribute( PyutXmlConstants.ATTR_CARDINALITY_DESTINATION) pyutLink.sourceCardinality = link.getAttribute( PyutXmlConstants.ATTR_CARDINALITY_SOURCE) pyutLink.setName(link.getAttribute(PyutXmlConstants.ATTR_NAME)) strLinkType: str = link.getAttribute(PyutXmlConstants.ATTR_TYPE) strLinkType = strLinkType.replace(PyutXmlConstants.V9_LINK_PREFIX, '') linkType: LinkType = LinkType.toEnum(strValue=strLinkType) pyutLink.setType(linkType) # source and destination will be reconstructed by _getOglLinks sourceId = int(link.getAttribute(PyutXmlConstants.ATTR_SOURCE_ID)) destId = int(link.getAttribute(PyutXmlConstants.ATTR_DESTINATION_ID)) return sourceId, destId, pyutLink

 def build_manifest_from_dom(file: File, extended_processing: bool, dom: Element) -> AndroidManifest: if extended_processing: application = dom.getElementsByTagName("application")[0] activities = AndroidManifestParser.parse_activities_from_dom(application) services = AndroidManifestParser.parse_services_from_dom(application) receivers = AndroidManifestParser.parse_broadcast_receivers_from_dom(application) else: activities = [] services = [] receivers = [] return AndroidManifest( filename=file.get_file_name(), size=file.get_size(), md5hash=file.get_md5(), sha1hash=file.get_sha1(), sha256hash=file.get_sha256(), sha512hash=file.get_sha512(), package_name=dom.getAttribute("package"), version=AndroidManifestParser.parse_version_from_dom(dom), sdk=AndroidManifestParser.parse_sdk_from_dom(dom), permissions=AndroidManifestParser.__parse_list_from_dom( dom, tag="uses-permission", attribute="android:name" ), activities=activities, services=services, receivers=receivers )

 def __init__(self, testcase: Element): self.__properties_tag_name = 'property' self.__properties_iter = iter( testcase.getElementsByTagName(self.__properties_tag_name)) self.__current = None print(f"INFO: Successfully extracted properties from test case")

def _get_descendant(element: Element, path: str): path = path.split('.') if len(path) > 1: childs = element.getElementsByTagName(path[0]) if len(childs) != 1: msg = "Only the deepest descendant in selection query can be non-unique. Perhaps break the filter into multiple selections?" logger.error(msg) raise NotImplementedError(msg) child = childs[0] return _get_descendant(child, '.'.join(path[1:])) else: rel = element.getElementsByTagName(path[0]) return rel

 def extract_properties(xml_node: minidom.Element) -> dict: """Extract properties in the <ns2:properties> tag of the provided node :param xml_node: minidom.Element, parsed XML node :return: dict, with the extracted properties. """ properties = {} for property_node in xml_node.getElementsByTagName("ns2:properties"): for child_node in property_node.childNodes: try: property_name = child_node.attributes[ "propertyDefinitionId"].value except KeyError: continue node_values = child_node.getElementsByTagName("ns2:value") if len(node_values) == 0 or len( node_values[0].childNodes) == 0: properties[property_name] = {"value": None} else: properties[property_name] = { "value": parsePropValue(node_values[0].childNodes[0].data, child_node.localName) } return properties

 def __init__(self, testsuite: Element): self.__test_case_tag_name = 'testcase' self.all = testsuite.getElementsByTagName(self.__test_case_tag_name) print(f'INFO: Successfully extracted test cases in test suite')

def get_objects(root: minidom.Element): object_list = [] for object in root.getElementsByTagName(name='object'): box = get_bound_boxes(object) name = get_name(object) object_list.append(','.join(box) + ',' + name) return object_list

def get_bound_boxes(root: minidom.Element): bound_box = root.getElementsByTagName(name="bndbox") assert len(bound_box) == 1 bound_box: minidom.Element = bound_box[0] return [str(bound_box.getElementsByTagName(name="xmin")[0].childNodes[0].data), str(bound_box.getElementsByTagName(name="ymin")[0].childNodes[0].data), str(bound_box.getElementsByTagName(name="xmax")[0].childNodes[0].data), str(bound_box.getElementsByTagName(name="ymax")[0].childNodes[0].data)]

 def _getImplementors(self, xmlClass: Element) -> Implementors: implementors: Implementors = Implementors([]) for xmlImplementor in xmlClass.getElementsByTagName(PyutXmlConstants.ELEMENT_IMPLEMENTOR): className: ClassName = xmlImplementor.getAttribute(PyutXmlConstants.ATTR_IMPLEMENTING_CLASS_NAME) implementors.append(className) return implementors

 def __renderClassDiagram(self, documentNode: Element, toOgl: MiniDomToOgl, umlFrame: UmlFrame): """ Args: documentNode: A minidom document element toOgl: The converter class umlFrame: Where to render """ oglClasses: OglClasses = toOgl.getOglClasses(documentNode.getElementsByTagName(PyutXmlConstants.ELEMENT_GRAPHIC_CLASS)) oglNotes: OglNotes = toOgl.getOglNotes(documentNode.getElementsByTagName('GraphicNote')) mergedOglObjects: OglObjects = cast(OglObjects, oglClasses.copy()) mergedOglObjects.update(oglNotes) self.__displayTheClasses(oglClasses, umlFrame) oglLinks: OglLinks = toOgl.getOglLinks(documentNode.getElementsByTagName("GraphicLink"), mergedOglObjects) self.__displayTheLinks(oglLinks, umlFrame) self.__displayTheNotes(oglNotes, umlFrame)

 def value_from_xml_element(self, xml: minidom.Element, registry: ObjectRegistry): if xml.tagName != self.tag_name: raise ValueError("Wrong value type (%s instead of %s)" % (xml.tagName, self.tag_name)) guid = xml.getAttribute("guid") if guid and guid in registry.registry: value = registry.registry[guid] elif self.typename == "vector": value = NVector( float(xml_text(xml.getElementsByTagName("x")[0])), float(xml_text(xml.getElementsByTagName("y")[0])) ) if xml.getAttribute("guid"): value.guid = xml.getAttribute("guid") registry.register(value) elif self.typename == "color": value = NVector( float(xml_text(xml.getElementsByTagName("r")[0])), float(xml_text(xml.getElementsByTagName("g")[0])), float(xml_text(xml.getElementsByTagName("b")[0])), float(xml_text(xml.getElementsByTagName("a")[0])) ) elif self.typename == "gradient": value = [ GradientPoint.from_dom(sub, registry) for sub in xml_child_elements(xml, GradientPoint.type.typename) ] elif self.typename == "real" or self.typename == "angle": value = float(xml.getAttribute("value")) elif self.typename == "integer": value = int(xml.getAttribute("value")) elif self.typename == "time": value = FrameTime.parse_string(xml.getAttribute("value"), registry) elif self.typename == "bool": value = str_to_bool(xml.getAttribute("value")) elif self.typename == "string": return xml_text(xml) elif self.typename == "bone_object": # Already done above but this forces the guid to be present return registry.get_object(xml.getAttribute("guid")) else: raise ValueError("Unsupported type %s" % self.typename) return self.type_wrapper(value)

 def _parse_patterns(self, xdom: Element) -> Dict[str, str]: result: Dict[str, str] = dict() patterns = xdom.getElementsByTagName("patterns") for pattern in patterns: for node in pattern.childNodes: if not isinstance(node, Text): result[node.tagName] = self._to_text(node) return result

 def _generateControlPoints(self, link: Element) -> ControlPoints: controlPoints: ControlPoints = cast(ControlPoints, []) for controlPoint in link.getElementsByTagName(PyutXmlConstants.ELEMENT_MODEL_CONTROL_POINT): x = PyutUtils.strFloatToInt(controlPoint.getAttribute(PyutXmlConstants.ATTR_X)) y = PyutUtils.strFloatToInt(controlPoint.getAttribute(PyutXmlConstants.ATTR_Y)) controlPoints.append(ControlPoint(x, y)) return controlPoints

 def _parse_labels(self, xdom: Element) -> Dict[str, str]: result: Dict[str, str] = dict() labels = xdom.getElementsByTagName("labels") for label in labels: for node in label.childNodes: if not isinstance(node, Text): result[self._to_text(node)] = node.tagName return result

 def parseHeader(self, xmlHeader: Element) -> InvoiceHeader: header = InvoiceHeader() header.number = xmlExtractText(xmlHeader, 'NUMER_PELNY') header.invoiceDate = xmlExtractDate(xmlHeader, 'DATA_WYSTAWIENIA') header.salesDate = xmlExtractDate(xmlHeader, 'DATA_OPERACJI') header.currency = xmlExtractText(xmlHeader, 'SYMBOL') payment_xml = xmlHeader.getElementsByTagName("PLATNOSC")[0] header.paymentDueDate = xmlExtractDate(payment_xml, 'TERMIN') header.paymentTerms = xmlExtractText(payment_xml, 'FORMA') header.documentFunctionCode = "" return header

 def _parse_mappings(self, xdom: Element) -> Dict[str, str]: result: Dict[str, str] = dict() mappings = xdom.getElementsByTagName("mappings") for mapping in mappings: for node in mapping.childNodes: if not isinstance(node, Text): result[node.getAttribute("inbound")] = node.getAttribute( "outbound") return result

 def _generateMethodParameters( self, xmlMethod: Element, methodDef: MethodDefinition) -> MethodDefinition: parameters: Parameters = [] for xmlParam in xmlMethod.getElementsByTagName(ELEMENT_MODEL_PARAM): paramDef: ParameterDefinition = self._getParam(xmlParam=xmlParam) parameters.append(paramDef) methodDef.parameters = parameters return methodDef

 def __parse_metadata_from_dom(dom: Element) -> List[Dict]: metadata = [] for element in dom.getElementsByTagName("meta-data"): data = AndroidManifestParser.__parse_dict_from_dom( element, attributes={ "name": "android:name", "value": "android:value" } ) metadata.append(data) return metadata

 def parse_broadcast_receivers_from_dom(dom: Element) -> List[Dict]: receivers = [] for element in dom.getElementsByTagName("receiver"): receiver = AppBroadcastReceiver( name=element.getAttribute("android:name"), metadata=AndroidManifestParser.__parse_metadata_from_dom(element), intent_filters=AndroidManifestParser.__parse_intent_filters_from_dom(element), enabled=AndroidManifestParser.__parse_bool_from_dom(element, "android:enabled"), exported=AndroidManifestParser.__parse_bool_from_dom(element, "android:exported") ) receivers.append(receiver) return receivers

 def parse_activities_from_dom(dom: Element) -> List[AppActivity]: activities = [] for element in dom.getElementsByTagName("activity"): activity = AppActivity( name=element.getAttribute("android:name"), metadata=AndroidManifestParser.__parse_metadata_from_dom(element), intent_filters=AndroidManifestParser.__parse_intent_filters_from_dom(element), parent_name=AndroidManifestParser.__parse_str_from_dom(element, "android:parentActivityName"), launch_mode=AndroidManifestParser.__parse_str_from_dom(element, "android:launchMode"), no_history=AndroidManifestParser.__parse_str_from_dom(element, "android:noHistory") ) activities.append(activity) return activities

 def _getMethods(self, xmlClass: Element) -> PyutMethods: """ Converts XML methods to `PyutMethod`s Args: xmlClass: A DOM element that is a UML Class Returns: A list of `PyutMethod`s associated with the class """ allMethods: PyutMethods = cast(PyutMethods, []) for xmlMethod in xmlClass.getElementsByTagName( PyutXmlConstants.ELEMENT_MODEL_METHOD): pyutMethod: PyutMethod = PyutMethod( xmlMethod.getAttribute(PyutXmlConstants.ATTR_NAME)) strVis: str = xmlMethod.getAttribute( PyutXmlConstants.ATTR_VISIBILITY) vis: PyutVisibilityEnum = PyutVisibilityEnum.toEnum(strVis) pyutMethod.setVisibility(visibility=vis) returnElt: Element = xmlMethod.getElementsByTagName( PyutXmlConstants.ELEMENT_MODEL_RETURN)[0] retTypeStr: str = returnElt.getAttribute( PyutXmlConstants.ATTR_TYPE) retType: PyutType = PyutType(retTypeStr) pyutMethod.setReturns(retType) # # Code supports multiple modifiers, but the dialog allows input of only one # modifiers: NodeList = xmlMethod.getElementsByTagName( PyutXmlConstants.ELEMENT_MODEL_MODIFIER) for xmlModifier in modifiers: xmlModifier: Element = cast(Element, xmlModifier) modName: str = xmlModifier.getAttribute( PyutXmlConstants.ATTR_NAME) pyutModifier: PyutModifier = PyutModifier(modName) pyutMethod.addModifier(pyutModifier) methodParameters = [] for xmlParam in xmlMethod.getElementsByTagName( PyutXmlConstants.ELEMENT_MODEL_PARAM): methodParameters.append(self._getParam(xmlParam)) pyutMethod.setParams(methodParameters) allMethods.append(pyutMethod) return allMethods

 def parseSummary(self, xmlSummary: Element) -> InvoiceSummary: summary = InvoiceSummary() summary.totalLines = xmlExtractText(xmlSummary, 'TotalLines') summary.totalNetAmount = xmlExtractText(xmlSummary, 'TotalNetAmount') summary.totalTaxableBasis = xmlExtractText(xmlSummary, 'TotalTaxableBasis') summary.totalTaxAmount = xmlExtractText(xmlSummary, 'TotalTaxAmount') summary.totalGrossAmount = xmlExtractText(xmlSummary, 'TotalGrossAmount') summary.grossAmountInWords = xmlExtractText(xmlSummary, 'GrossAmountInWords') summary.taxSummary = self.parseTaxSummary( xmlSummary.getElementsByTagName("Tax-Summary-Line")[0]) return summary

 def _parse_element_to_simple_list(root: minidom.Element, tag: str, attribute: str) -> List[Any]: """ Parse the simple application elements (i.e. only the "android:name"). :param root: The XML element. :param tag: The root element tag to look for (e.g. "uses-permission", "action", "category", ...). :param attribute: The unique tag attribute name (e.g. "android:name"). :return: The list of attribute values. """ res = [] for element in root.getElementsByTagName(tag): res.append(element.getAttribute(attribute)) if len(res) > 0: res.sort() return res