Python etree.ElementTree类代码示例

    def fix_graphml_format_better(cls, name, gridfs):
        cls._logger.info("Reformatting file to fix GDO graphml formatting using element tree")
        replacements = {}
        with gridfs.get_last_version(name) as f:
            tree = ElementTree.parse(f)
            f_id = f._id
            for key_entry in tree.findall("{http://graphml.graphdrawing.org/xmlns}key"):
                key_name = key_entry.attrib['attr.name']
                id = key_entry.attrib['id']
                key_entry.attrib['id'] = key_name
                replacements[id] = key_name
                # cls._logger.info("Name: %s, Key %s", key_name, key_entry)
            # cls._logger.info("Dict %s", replacements)
            root=tree.getroot()
            for data_entry in root.iter("{http://graphml.graphdrawing.org/xmlns}data"):
                found_key = data_entry.attrib['key']
                data_entry.set('key', replacements[found_key])

            ElementTree.register_namespace('', "http://graphml.graphdrawing.org/xmlns")

        with gridfs.new_file(filename=name, content_type="text/xml") as des:
            tree.write(des, encoding='utf-8', method='xml')

        cls._logger.info("Deleting old version of file %s", f_id)
        gridfs.delete(f_id)

 def callback(results):
     reactor.stop()
     for success, result in results:
         if success:
             print ElementTree.dump(result)
         else:
             print result.printTraceback()

def parse_soap_enveloped_saml_thingy(text, expected_tags):
    """Parses a SOAP enveloped SAML thing and returns the thing as
    a string.
    
    :param text: The SOAP object as XML string
    :param expected_tags: What the tag of the SAML thingy is expected to be.
    :return: SAML thingy as a string
    """
    envelope = ElementTree.fromstring(text)

    # Make sure it's a SOAP message
    assert envelope.tag == '{%s}Envelope' % soapenv.NAMESPACE
    
    assert len(envelope) >= 1
    body = None
    for part in envelope:
        if part.tag == '{%s}Body' % soapenv.NAMESPACE:
            assert len(part) == 1
            body = part
            break

    if body is None:
        return ""
    
    saml_part = body[0]
    if saml_part.tag in expected_tags:
        return ElementTree.tostring(saml_part, encoding="UTF-8")
    else:
        raise WrongMessageType("Was '%s' expected one of %s" % (saml_part.tag,
                                                                expected_tags))

def add_to_manifest(repositories, fallback_branch = None):
    try:
        lm = ElementTree.parse(".repo/local_manifests/du_manifest.xml")
        lm = lm.getroot()
    except:
        lm = ElementTree.Element("manifest")

    for repository in repositories:
        repo_name = repository['repository']
        repo_target = repository['target_path']
        if exists_in_tree(lm, repo_name):
            print('DirtyUnicorns/%s already exists' % (repo_name))
            continue

        print('Adding dependency: DirtyUnicorns/%s -> %s' % (repo_name, repo_target))
        project = ElementTree.Element("project", attrib = { "path": repo_target,
            "remote": "du", "name": "%s" % repo_name })

        if 'branch' in repository:
            project.set('revision',repository['branch'])
        elif fallback_branch:
            print("Using fallback branch %s for %s" % (fallback_branch, repo_name))
            project.set('revision', fallback_branch)
        else:
            print("Using default branch for %s" % repo_name)

        lm.append(project)

    indent(lm, 0)
    raw_xml = ElementTree.tostring(lm).decode()
    raw_xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + raw_xml

    f = open('.repo/local_manifests/du_manifest.xml', 'w')
    f.write(raw_xml)
    f.close()

    def run(self):
        """Runner"""
        service_path = rel_path(os.path.join("build",
            "Add to BibDesk.workflow", "Contents", "document.wflow"))
        app_path = rel_path(os.path.join("build", "ADS to BibDesk.app",
            "Contents", "document.wflow"))
        py_path = rel_path("adsbibdesk.py")

        for workflow in (service_path, app_path):
            with open(workflow, 'r') as fh:
                xml = ElementTree.fromstring(fh.read())
            for arr in xml.find('dict').find('array').getchildren():

                # fetch Python code inside the xml
                py = [c for c in arr.find('dict').getchildren()
                      if c.tag == 'dict' and
                      any([i.text and '/usr/bin/env' in i.text
                           for i in c.getchildren()])]

                # rewrite with current file
                if py:
                    logger.info("Inserting {0} into {1}".format(py_path,
                                                                workflow))
                    py[0].find('string').text = open(py_path).read()

            logger.info("Saving {0}".format(workflow))
            with open(workflow, 'wb') as fh:
                fh.write(ElementTree.tostring(xml))
        logger.info("Completed ADS to BibDesk build step")

 def intiMulticopy(self):
     fio = fIO()
     
     fio.filePrompt("folder", "Please select folder locations to copy to.\n"
                    + "These folder locations will be saved.\n"
                    + "When you are done loading in locations, simply\n" 
                    + "press the cancel button in the file explorer.\n")
     
     try:
         tree = ET.parse('filecopylocations.xml')
         xroot = tree.getroot()
         for locs in xroot.findall('Location'):
             xroot.remove(locs)
     except:
         froot = ET.Element('Directories')
         tree = ET.ElementTree(froot)
         tree.write('filecopylocations.xml')
         tree = ET.parse('filecopylocations.xml')
         xroot = tree.getroot()
 
     locnum = 1
     fio.folderLocation()
     floc = fio.getFolderLocation()
     while(floc != ''):
         try:
             loc = ET.SubElement(xroot, 'Location'.format(locnum))
             loc.set('index', '{0}'.format(locnum))
             locnum = locnum + 1
             loc.text = floc
             floc = fio.getFolderLocation()
         except:
             floc = ''
     
     tree.write('filecopylocations.xml')
     ET.dump(xroot)

    def _create_html_file(self, sourcefile, htmlfile, errors):
        name = self.generator.get_name()
        root = ElementTree.fromstring(CPPCHECK_HTML_FILE)
        title = root.find("head/title")
        title.text = "cppcheck - report - %s" % name

        body = root.find("body")
        for div in body.findall("div"):
            if div.get("id") == "page":
                page = div
                break
        for div in page.findall("div"):
            if div.get("id") == "header":
                h1 = div.find("h1")
                h1.text = "cppcheck report - %s" % name
            if div.get("id") == "content":
                content = div
                srcnode = self.generator.bld.root.find_node(sourcefile)
                hl_lines = [e["line"] for e in errors if e.has_key("line")]
                formatter = CppcheckHtmlFormatter(linenos=True, style="colorful", hl_lines=hl_lines, lineanchors="line")
                formatter.errors = [e for e in errors if e.has_key("line")]
                css_style_defs = formatter.get_style_defs(".highlight")
                lexer = pygments.lexers.guess_lexer_for_filename(sourcefile, "")
                s = pygments.highlight(srcnode.read(), lexer, formatter)
                table = ElementTree.fromstring(s)
                content.append(table)

        s = ElementTree.tostring(root, method="html")
        s = CCPCHECK_HTML_TYPE + s
        node = self.generator.path.get_bld().find_or_declare(htmlfile)
        node.write(s)
        return css_style_defs

def ensure_elementtree_imported(verbosity, logfile):
    global ET, ET_has_iterparse
    if ET is not None:
        return
    if "IronPython" in sys.version:
        import xml.etree.ElementTree as ET
        #### 2.7.2.1: fails later with
        #### NotImplementedError: iterparse is not supported on IronPython. (CP #31923)
    else:
        try: import xml.etree.cElementTree as ET
        except ImportError:
            try: import cElementTree as ET
            except ImportError:
                try: import lxml.etree as ET
                except ImportError:
                    try: import xml.etree.ElementTree as ET
                    except ImportError:
                        try: import elementtree.ElementTree as ET
                        except ImportError:
                            raise Exception("Failed to import an ElementTree implementation")
    if hasattr(ET, 'iterparse'):
        _dummy_stream = BYTES_IO(b'')
        try:
            ET.iterparse(_dummy_stream)
            ET_has_iterparse = True
        except NotImplementedError:
            pass
    if verbosity:
        etree_version = repr([
            (item, getattr(ET, item))
            for item in ET.__dict__.keys()
            if item.lower().replace('_', '') == 'version'
            ])
        print(ET.__file__, ET.__name__, etree_version, ET_has_iterparse, file=logfile)

def open_soap_envelope(text):
    """

    :param text: SOAP message
    :return: dictionary with two keys "body"/"header"
    """
    try:
        envelope = ElementTree.fromstring(text)
    except Exception as exc:
        raise XmlParseError("%s" % exc)

    assert envelope.tag == '{%s}Envelope' % soapenv.NAMESPACE
    assert len(envelope) >= 1
    content = {"header": [], "body": None}

    for part in envelope:
        if part.tag == '{%s}Body' % soapenv.NAMESPACE:
            assert len(part) == 1
            content["body"] = ElementTree.tostring(part[0], encoding="UTF-8")
        elif part.tag == "{%s}Header" % soapenv.NAMESPACE:
            for item in part:
                _str = ElementTree.tostring(item, encoding="UTF-8")
                content["header"].append(_str)

    return content

    def to_string(self, endpoints):
        """
        Converts the given endpoint description beans into a string

        :param endpoints: A list of EndpointDescription beans
        :return: A string containing an XML document
        """
        # Make the ElementTree
        root = self._make_xml(endpoints)
        tree = ElementTree.ElementTree(root)

        # Force the default name space
        ElementTree.register_namespace("", EDEF_NAMESPACE)

        # Make the XML
        for encoding in ('unicode', 'UTF-8'):
            # Prepare a StringIO output
            output = StringIO()

            try:
                # Try to write with a correct encoding
                tree.write(output, encoding=encoding, xml_declaration=True,
                           method="xml")
                break

            except LookupError:
                # 'unicode' is needed in Python 3, but unknown in Python 2...
                continue

        else:
            raise LookupError("Couldn't find a valid encoding")

        return output.getvalue()

    def test_postXMLEndpoint(self):
        testURL = "https://api.eveonline.com/server/ServerStatus.xml.aspx"

        res_cache = api.postXMLEndpoint(testURL)
        self.assertIsInstance(res_cache, ET.Element)
        # Test cached response
        self.assertEqual(ET.tostring(api.postXMLEndpoint(testURL)), ET.tostring(res_cache))

def set_owner(conn, uuid, owner):
    """Set ON_OWNER by uuid.
    @param uuid: uuid of the VM
    @param owner: string representing owner
    """
    vmid = get_id_by_uuid(conn, uuid)

    if not vmid:
        return

    vm = conn.lookupByID(vmid)
    domain = ET.fromstring(vm.XMLDesc(0))
    metadata = domain.find('./metadata') or ET.SubElement(domain, 'metadata')
    owner_e = ET.SubElement(metadata, ET.QName('urn:opennode-tui', 'owner'))
    owner_e.text = owner

    ## TODO: cleanup
    open('/etc/libvirt/qemu/%s.xml' % (vm.name()), 'w').write(ET.tostring(domain))

    data = open('/etc/libvirt/qemu/%s.xml' % (vm.name()), 'r').read()
    domain_n = ET.fromstring(data)
    owner_e = domain_n.find('./metadata/{urn:opennode-tui}owner')
    assert owner_e is not None
    assert owner_e.text == owner
    return owner_e.text

    def test_affiliate_with_supported_seats(self):
        """ Verify that endpoint returns course runs for verified and professional seats only. """
        response = self.client.get(self.affiliate_url)
        self.assertEqual(response.status_code, 200)
        root = ET.fromstring(response.content)
        self.assertEqual(1, len(root.findall('product')))
        self.assert_product_xml(
            root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, self.seat_verified.type))[0],
            self.seat_verified
        )

        # Add professional seat.
        seat_professional = SeatFactory(course_run=self.course_run, type=Seat.PROFESSIONAL)

        response = self.client.get(self.affiliate_url)
        root = ET.fromstring(response.content)
        self.assertEqual(2, len(root.findall('product')))

        self.assert_product_xml(
            root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, self.seat_verified.type))[0],
            self.seat_verified
        )
        self.assert_product_xml(
            root.findall('product/[pid="{}-{}"]'.format(self.course_run.key, seat_professional.type))[0],
            seat_professional
        )

 def multicopy():    
     try:
         tree = ET.parse('filecopylocations.xml')
         xroot = tree.getroot()
         print "\nWould you like to edit the following copy desitinations?\n"
         ET.dump(xroot)
         edit = raw_input("\ny=yes : n=no\n")
         if edit == 'y':
             initMulticopy()
         else:
             pass
     except:
         initMulticopy()
         tree = ET.parse('filecopylocations.xml')
         xroot = tree.getroot()
 
     print "\nPlease select the file you wish to have copied."
 
     try:
         
         fcpyfrom = getFileLocation()
         fcpyname = getFileNameFromFilePath(fcpyfrom)
         fcpyfrom = open(fcpyfrom, 'r').read()
         for loc in xroot.findall('Location'):
             f = open(loc.text + '/' + fcpyname, 'w')
             f.write(fcpyfrom)
             f.close()
         print "\nFile was successfully copied!"
     except:
         print "\nCould not copy file!"
         pass

    def test_get_xml(self):
        self.resModelProgram.metadata.create_element('Description', abstract="test abstract")
        self.resModelProgram.metadata.create_element('Subject', value="test subject")
        release_date = '2016-10-24T21:05:00.315907+00:00'
        self.resModelProgram.metadata.create_element('MpMetadata',
                                                     modelVersion='5.1.011',
                                                     modelProgramLanguage='Fortran',
                                                     modelOperatingSystem='Windows',
                                                     modelReleaseDate=release_date,
                                                     modelWebsite='http://www.hydroshare.org',
                                                     modelCodeRepository='http://www.github.com',
                                                     modelReleaseNotes='releaseNote.pdf',
                                                     modelDocumentation='manual.pdf',
                                                     modelSoftware='utilities.exe',
                                                     modelEngine='sourceCode.zip')

        # test if xml from get_xml() is well formed
        ET.fromstring(self.resModelProgram.metadata.get_xml())
        xml_doc = self.resModelProgram.metadata.get_xml()
        # check to see if the specific metadata are in the xml doc
        self.assertTrue('5.1.011' in xml_doc)
        self.assertTrue('Fortran' in xml_doc)
        self.assertTrue('Windows' in xml_doc)
        self.assertTrue(release_date in xml_doc)
        self.assertTrue('http://www.hydroshare.org' in xml_doc)
        self.assertTrue('http://www.github.com' in xml_doc)
        self.assertTrue('releaseNote.pdf' in xml_doc)
        self.assertTrue('manual.pdf' in xml_doc)
        self.assertTrue('utilities.exe' in xml_doc)
        self.assertTrue('sourceCode.zip' in xml_doc)