Python cElementTree.ElementTree类代码示例

    def edx(self, out_dir):
        # Copy the Pdf to the static directory
        static_dir = os.path.join(out_dir, 'static')
        if not os.path.exists(static_dir):
            os.makedirs(static_dir)
        # In order to get an unique filename inside edx, we have to prefix the project and group name
        _, fileExtension = os.path.splitext(self.path)
        target_filename = self.url_name()+fileExtension
        target_path = os.path.join(static_dir,target_filename)
        shutil.copyfile(os.path.join(self.parent.path, self.path), target_path);

        html_dir = os.path.join(out_dir, 'html')
        if not os.path.exists(html_dir):
            os.makedirs(html_dir)
        html = Element('html', {'filename':self.url_name(), 'display_name':"File"});
        tree = ElementTree(html)
        tree.write(os.path.join(html_dir, "{0}.xml".format(self.url_name())) )


        (_ , filename) = os.path.split(self.path)
        html = '''
        <a href="/static/%(file)s">Download %(filename)s</a>
        ''' % {'file':target_filename, 'filename':filename}

        with codecs.open(os.path.join(html_dir, "{0}.html".format(self.url_name())), mode='w', encoding='utf-8') as f:
            f.write(html)

    def run(self):
        creds = []
        directory = constant.profile['USERPROFILE'] + u'\\Documents\\Rogue\'s Tale\\users'

        # The actual user details are stored in *.userdata files
        if os.path.exists(directory):
            files = os.listdir(directory)

            for f in files:
                if re.match('.*\.userdata', f):
                    # We've found a user file, now extract the hash and username

                    xmlfile = directory + '\\' + f
                    tree = ElementTree(file=xmlfile)
                    root = tree.getroot()

                    # Double check to make sure that the file is valid
                    if root.tag != 'user':
                        self.warning(u'Profile %s does not appear to be valid' % f)
                        continue

                    # Now save it to credentials
                    creds.append({
                        'Login': root.attrib['username'],
                        'Hash': root.attrib['password']
                    })

            return creds

def get_package_name(path):
    """
    Get the name of the ROS package that contains *path*. This is
    determined by finding the nearest parent ``manifest.xml`` file.
    This routine may not traverse package setups that rely on internal
    symlinks within the package itself.
    
    :param path: filesystem path
    :return: Package name or ``None`` if package cannot be found, ``str``
    """
    #NOTE: the realpath is going to create issues with symlinks, most
    #likely.
    parent = os.path.dirname(os.path.realpath(path))
    #walk up until we hit ros root or ros/pkg
    while not os.path.exists(os.path.join(path, MANIFEST_FILE)) and not os.path.exists(os.path.join(path, PACKAGE_FILE)) and parent != path:
        path = parent
        parent = os.path.dirname(path)
    # check termination condition
    if os.path.exists(os.path.join(path, MANIFEST_FILE)):
        return os.path.basename(os.path.abspath(path))
    elif os.path.exists(os.path.join(path, PACKAGE_FILE)):
        root = ElementTree(None, os.path.join(path, PACKAGE_FILE))
        return root.findtext('name')
    else:
        return None

 def load(cls, filename):
     project_root = ElementTree().parse(filename)
     settings_node = project_root.find(cls.__PROJECT_SETTINGS_NODE_NAME)
     tracks_node = project_root.find(cls.__PROJECT_TRACKS_NODE_NAME)
     track_nodes = tracks_node.findall(cls.__PROJECT_TRACK_NODE_NAME)
     for node in track_nodes:
         print node

    def scrape_pkg_uri(self, uri, pkg):
        """
        Scrape package metadata from PyPi when it's running
        as the Clue Release Manager.

        Parameters
        ----------
        uri : `str`
            URI to page containing package's homepage
        pkg : `str`
            Package name
        """
        # Example entry:
        #<div class="distro-block distro-metadata">
        #  <h4>Metadata</h4>
        #  <dl>
        #    <dt>Distro Index Owner:</dt>
        #    <dd>acmepypi</dd>
        #    <dt>Home Page:</dt>
        #    <dd><a href="http://mysvn/acme.helloworld">
        #           http://mysvn/acme.helloworld</a></dd>
        #  </dl>
        #</div>
        tree = ElementTree()
        try:
            tree.parse(urllib2.urlopen(uri))
        except urllib2.HTTPError, e:
            raise UserError("Can't find repository URL for package %s (%s). "
                            "Has it been registered in PyPi?" % (pkg, e))

    def merge(self):
        last_hr = 0
        self.tacx_tcx = self._parse_file(self.tacx_tcx_file)
        self.hr_tcx = self._parse_file(self.hr_tcx_file)

        for tp in self.tacx_tcx.dom_trackpoints:
            timestamp = tp.find('role:Time', ns).text
            timestamp_key = timestamp[0:19]
            if timestamp_key in self.hr_tcx.TrackPoints.keys():
                heartrate_from_other_file = self.hr_tcx.TrackPoints[timestamp_key].HeartRateBpm
                if heartrate_from_other_file is not None:
                    hr_node = self._create_heartrate(heartrate_from_other_file)
                    tp.append(hr_node)
                    last_hr = heartrate_from_other_file
            else:
                hr_node = self._create_heartrate(last_hr)
                tp.append(hr_node)

        tree = ElementTree(self.tacx_tcx.root)

        tree.write(open(self.file_name, 'wb'), encoding="utf-8", xml_declaration=True)

        # Add UGLY! temporary fix for namespace "ns1-issue"
        f = open (self.file_name, "r")
        data = f.read()
        data = data.replace('ns1:TPX', 'TPX')
        data = data.replace('ns1:Speed', 'Speed')
        data = data.replace('ns1:Watts', 'Watts')
        f.close

        f = open(self.file_name, "w")
        f.write(data)
        f.close()
        return self.file_name

    def fulltext_search(self, query, rows=None, start=None):
        """Does an advanced search on fulltext:blah.
        You get back a pair (x,y) where x is the total # of hits
        and y is a list of identifiers like ["foo", "bar", etc.]"""

        query = self._prefix_query('fulltext', query)
        result_list = self.raw_search(query, rows=rows, start=start)
        e = ElementTree()
        try:
            e.parse(StringIO(result_list))
        except SyntaxError as e:
            raise SolrError(e)

        total_nbr_text = e.find('info/range_info/total_nbr').text
        # total_nbr_text = e.find('result').get('numFound')  # for raw xml
        total_nbr = int(total_nbr_text) if total_nbr_text else 0

        out = []
        for r in e.getiterator('hit'):
            for d in r.find('metadata'):
                for x in list(d.getiterator()):
                    if x.tag == "identifier":
                        xid = six.text_type(x.text).encode('utf-8')
                        if xid.startswith('OCA/'):
                            xid = xid[4:]
                        elif xid.endswith('.txt'):
                            xid = xid.split('/')[-1].split('_')[0]
                        elif xid.endswith('_ZZ'):
                            xid = xid[:-3]
                        out.append(xid)
                        break
        return (total_nbr, out)

def loadLanguageFile(langfile):
    """ Loads one or more languages from disk
    Returns list of language codes found."""
    
    global languagenames, languages
    
    tree = ElementTree(file=langfile)
    
    foundlangs = []
    
    langslist = tree.find("wurmlanguages")
    langs     = langslist.findall("languagedef")
    
    for language in langs:
        code = language.attrib["code"]
        name = language.attrib.get("name", code)
        
        languagenames[code] = name
        languages.setdefault(code, {}) # make sure the base map is ready
        
        if code not in foundlangs:
            foundlangs.append(code)
        
        lstrings = language.findall("string")
        for lstr in lstrings:
            orig = _parse(lstr.find("original").text.strip())
            tran = _parse(lstr.find("translation").text.strip())
            languages[code][orig] = tran
    
    return foundlangs

	def write(self, filename, midi):
		

		midifile = Element('MidiFile')
		header = HeaderChunk()
		
		header.write(midifile, midi.header)

		i = 0
		for cur in midi.tracks:
			node = SubElement(midifile, '_' + str(i)) #garantit l'ordre des datas
			temp = TrackChunk()
			temp.write(node, cur)
			i += 1

		tree = ElementTree(midifile)
		tree.write(filename, encoding="utf-8")

		

		import xml.dom.minidom 

		root = xml.dom.minidom.parse(filename)

		f = open(filename, "w")
		f.write(root.toprettyxml())

def serialize(data, name='object'):
    content_elem = Element(name)
    _serialize(content_elem, data)
    tree = ElementTree(content_elem)
    f = StringIO()
    tree.write(f, 'UTF-8')
    return f.getvalue()

    def updatebq(self):
        from xml.etree.cElementTree import ElementTree
        tree = ElementTree()
        tree.parse(GSXML)
        tvlist = []
        for iptv in tree.findall("iptv"):
            name = iptv.findtext("name").title()
            (protocol, serviceType, bufferSize, epgId) = iptv.findtext("type").split(":")
            uri = iptv.findtext("uri")
            if protocol in "livestreamer":
                uri = "http://localhost:88/" + uri
            uri = uri.replace(":", "%3a")
            service = "#SERVICE {s}:0:1:{e}:{e}:0:0:0:0:0:{u}:{n}\n".format(s=serviceType,e=epgId,u=uri,n=name)
            tvlist.append((name,service))

        tvlist=sorted(tvlist, key=lambda channel: channel[0]) #sort by name
        with open(GSBQ, "w") as f:
            f.write("#NAME GreekStreamTV\n")
            for (name, service) in tvlist:
                f.write(service)

	com = "cat /usr/lib/enigma2/python/Plugins/Satdreamgr/UpdateBouquet/stream.xml ; rm /usr/lib/enigma2/python/Plugins/Satdreamgr/UpdateBouquet/stream.xml"
	out = os.popen(com)

        return list

def parse_operator_xml(f):

    et = ElementTree(file=f)
    r = et.getroot()

    def _get_value_from_first_element(r_, e_name):
        return r_.findall(e_name)[0].text

    operator_id = r.attrib["id"]
    task_id = _get_value_from_first_element(r, "task-id")

    s = r.findall("scatter")[0]
    scatter_task_id = _get_value_from_first_element(s, "scatter-task-id")

    sgs = s.findall("chunks")[0]
    schunks = [ScatterChunk(x.attrib["out"], x.attrib["in"]) for x in sgs.findall("chunk")]
    scatter = Scatter(task_id, scatter_task_id, schunks)

    gs = r.findall("gather")[0].findall("chunks")[0].findall("chunk")

    def _to_c(x):
        return (
            _get_value_from_first_element(x, "gather-task-id"),
            _get_value_from_first_element(x, "chunk-key"),
            _get_value_from_first_element(x, "task-output"),
        )

    gchunks = [GatherChunk(*_to_c(x)) for x in gs]

    gather = Gather(gchunks)
    return ChunkOperator(operator_id, scatter, gather)

    def test_3x32mb_download_from_xml(self):
        '''Download three randomly-generated 32MB files from a GT server
           via an XML manifest'''
        uuid1 = self.data_upload_test(1024 * 1024 * 32)
        uuid2 = self.data_upload_test(1024 * 1024 * 32)
        uuid3 = self.data_upload_test(1024 * 1024 * 32)

        uuids = [uuid1, uuid2, uuid3]

        # build a XML result set
        result_set = Element('ResultSet')
        result_1 = SubElement(result_set, 'Result')
        analysis_data_uri_1 = SubElement(result_1, 'analysis_data_uri')
        analysis_data_uri_1.text = '%s/cghub/data/analysis/download/' \
            % TestConfig.HUB_SERVER + str(uuid1)
        result_2 = SubElement(result_set, 'Result')
        analysis_data_uri_2 = SubElement(result_2, 'analysis_data_uri')
        analysis_data_uri_2.text = '%s/cghub/data/analysis/download/' \
            % TestConfig.HUB_SERVER + str(uuid2)
        result_3 = SubElement(result_set, 'Result')
        analysis_data_uri_3 = SubElement(result_3, 'analysis_data_uri')
        analysis_data_uri_3.text = '%s/cghub/data/analysis/download/' \
            % TestConfig.HUB_SERVER + str(uuid3)

        doc = ElementTree(result_set)

        f = NamedTemporaryFile(delete=False, suffix='.xml')
        doc.write(f)
        f.close()

        self.data_download_test_xml(f.name, uuids)

        os.remove(f.name)

    def exportGEXF(self, fileName):
        rootNode = Element("gexf")
        rootNode.attrib['xmlns'] = "http://www.gexf.net/1.2draft"
        rootNode.attrib['version'] = "1.2"

        graphNode = Element("graph")
        graphNode.attrib['mode'] = "static"
        graphNode.attrib['defaultedgetype'] = "directed"
        rootNode.append(graphNode)

        graphNode.append(Node.getGexfAttributeNode())
        graphNode.append(Vertex.getGexfAttributeNode())

        NodesList = Element("nodes")
        for n in self.nodes:
            NodesList.append(n.exportToGexfNode())
        graphNode.append(NodesList)

        EdgesList = Element("edges")
        for e in self.vertices:
            EdgesList.append(e.exportToGexfNode())
        graphNode.append(EdgesList)

        doc = ElementTree(rootNode)
        doc.write(fileName, "utf8", '<?xml version="1.0" encoding="UTF-8"?>')

def parse_categories(fn):
    categories = {}
    et = ElementTree()
    tree = et.parse(fn)
    for elem in tree.findall('Category'):
        parse_category(elem, None, categories)
    return categories