Python ElementTree.fromstring函数代码示例

def find_group(request, grouptitle, pgSz):

    # TIMESTAMP = time.strftime("%b %d %Y %H:%M:%S", time.localtime())

    asquery = '%s?as=%s_common%%3Atitle%%3D%%27%s%%27&wf_deleted=false&pgSz=%s' % ('groups', 'groups', grouptitle, pgSz)

    # Make authenticated connection to cspace server...
    (groupurl, grouprecord, dummy, elapsedtime) = getfromCSpace(asquery, request)
    if grouprecord is None:
        return(None, None, 0, [], 'Error: the search for group \'%s.\' failed.' % grouptitle)
    grouprecordtree = fromstring(grouprecord)
    groupcsid = grouprecordtree.find('.//csid')
    if groupcsid is None:
        return(None, None, 0, [], None)
    groupcsid = groupcsid.text

    uri = 'collectionobjects?rtObj=%s&pgSz=%s' % (groupcsid, pgSz)
    try:
        (groupurl, groupmembers, dummy, elapsedtime) = getfromCSpace(uri, request)
        groupmembers = fromstring(groupmembers)
        totalItems = groupmembers.find('.//totalItems')
        totalItems = int(totalItems.text)
        objectcsids = [e.text for e in groupmembers.findall('.//csid')]
    except urllib2.HTTPError, e:
        return (None, None, 0, [], 'Error: we could not make list of group members')

	def __init__(self, firstArgument, robotAddr='', responseValue='', comment=''):
	# single-argument: build from XML
	# multiple-argument: build this class from its component data with optional  comment
		if (robotAddr == '' and responseValue == '' and comment == ''):
			tree = fromstring(firstArgument)
			ts = SubElement(tree, 't')
			ts.text = microtime()
			self.XML = tree

			self.driverAddr = self.XML.findtext('d')
			self.robotAddr = self.XML.findtext('r')
			self.responseValue = self.XML.findtext('re')
 			self.comment = self.XML.findtext('co')
		else:
			self.driverAddr = firstArgument
			self.robotAddr = robotAddr
			self.responseValue = responseValue
 			self.comment = comment
			
			tree = fromstring('<m></m>')
			ts = SubElement(tree, 't')
			ts.text = microtime()
			ds = SubElement(tree, 'd')
			ds.text = self.driverAddr
			rs = SubElement(tree, 'r')
			rs.text = self.robotAddr
			res = SubElement(tree, 're')
			res.text = self.responseValue
			cos = SubElement(tree, 'co')
			cos.text = self.comment
			self.XML = tree
# endclass messageFromRobot

 def resolve(self, item, captcha_cb=None, select_cb=None):
     result = []
     item = item.copy()
     url = item['url']
     if url.endswith('live.html'):
         channel = re.search(r'http://(\w+)\.joj\.sk', url).group(1)
         for original, replacement in {'www': 'joj', 'plus': 'jojplus'}.items():
             if channel == original:
                 channel = replacement
                 break
         for quality, resolution in {'lq': '180p', 'mq': '360p', 'hq': '540p'}.items():
             item = self.video_item()
             item['quality'] = resolution
             item['url'] = 'http://http-stream.joj.sk/joj/' + channel + '/index-' + quality + '.m3u8'
             result.append(item)
     else:
         data = util.request(url)
         playerdata = re.search(r'<div\ class=\"jn-player\"(.+?)>', data).group(1)
         pageid = re.search(r'data-pageid=[\'\"]([^\'\"]+)', playerdata).group(1)
         basepath = re.search(r'data-basepath=[\'\"]([^\'\"]+)', playerdata).group(1)
         videoid = re.search(r'data-id=[\'\"]([^\'\"]+)', playerdata).group(1)
         playlisturl = basepath + 'services/Video.php?clip=' + videoid + 'pageId=' + pageid
         playlist = fromstring(util.request(playlisturl))
         balanceurl = basepath + 'balance.xml?nc=%d' % random.randint(1000, 9999)
         balance = fromstring(util.request(balanceurl))
         for video in playlist.find('files').findall('file'):
             item = self.video_item()
             item['img'] = playlist.attrib.get('large_image')
             item['length'] = playlist.attrib.get('duration')
             item['quality'] = video.attrib.get('quality')
             item['url'] = self.rtmp_url(video.attrib.get('path'), playlist.attrib.get('url'),
                                         video.attrib.get('type'), balance)
             result.append(item)
         result.reverse()
     return select_cb(result)

 def test_compareElement2 (self) :
     clearGlobals()
     x = fromstring("<red><blue></blue></red>")
     iterElement(x)
     y = fromstring("<red><green><blue></blue><yellow></yellow></green></red>")
     z = compareElement(y,x)
     self.assertTrue(z == [])

 def test_searchFunction (self) :
     x = [("mez", 1),("mer", 2)]
     clearGlobals()
     xx = fromstring("<mez><mer></mer></mez>")
     y = fromstring("<mez><mer></mer></mez>")
     z = searchFunction(y,xx, x)
     self.assertTrue(z == True)

    def test_proxy_validate_view_pt_success(self):
        """
        When called with a valid ``ProxyTicket``, a ``GET`` request to
        the view should return a validation success and the
        ``ProxyTicket`` should be consumed and invalid for future
        validation attempts.
        """
        query_str = "?service=%s&ticket=%s" % (self.service_url, self.pt.ticket)
        response = self.client.get(reverse("cas_proxy_validate") + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "user")
        self.assertIsNotNone(elem)
        self.assertEqual(elem.text, "ellen")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get("Content-Type"), "text/xml")
        elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "proxies")
        proxy = list(elem.getiterator(XMLNS + "proxy"))
        self.assertEqual(len(proxy), 1)
        self.assertEqual(proxy[0].text, "http://www.example.com")

        # This request should fail as the ticket was consumed in the preceeding test
        response = self.client.get(reverse("cas_proxy_validate") + query_str)
        tree = ElementTree(fromstring(response.content))
        elem = tree.find(XMLNS + "authenticationFailure")
        self.assertIsNotNone(elem)
        self.assertEqual(elem.get("code"), "INVALID_TICKET")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.get("Content-Type"), "text/xml")

def process(fc):
	root = fromstring(fc)
	ns = "{http://www.yworks.com/xml/graphml}"

	new_node_code = \
	"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:y="http://www.yworks.com/xml/graphml" xmlns:yed="http://www.yworks.com/xml/yed/3" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd">
		<y:StyleProperties>
		    <y:Property class="com.yworks.yfiles.bpmn.view.TaskTypeEnum" name="com.yworks.bpmn.taskType" value="TASK_TYPE_ABSTRACT"/>
		    <y:Property class="com.yworks.yfiles.bpmn.view.ActivityTypeEnum" name="com.yworks.bpmn.activityType" value="ACTIVITY_TYPE_TASK"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.fill2" value="#d4d4d4"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.fill" value="#ffffff"/>
		    <y:Property class="com.yworks.yfiles.bpmn.view.BPMNTypeEnum" name="com.yworks.bpmn.type" value="ACTIVITY_TYPE"/>
		    <y:Property class="java.awt.Color" name="com.yworks.bpmn.icon.line.color" value="#000000"/>
		</y:StyleProperties>
	</graphml>
	"""
	new_node = fromstring(new_node_code).find("{}StyleProperties".format(ns))

	for node in root.findall('.//{}ShapeNode'.format(ns)):
		node.tag = "{}GenericNode".format(ns)
		node.attrib['configuration'] = "com.yworks.bpmn.Activity.withShadow"

		color = node.find("{}Fill".format(ns))
		del color.attrib['color']
		color.attrib['color1'] = "#FFFFFFE6"
		color.attrib['color2'] = "#D4D4D4CC"
		del color

		node.find("{}BorderStyle".format(ns)).attrib['color'] = '#123EA2'
		node.remove(node.find("{}Shape".format(ns)))

		node.append(new_node)

	return tostring(root, "UTF-8")

def main(argv):
    hostn = 'http://localhost:8080' #localhost at default port
    output = 'odfdump.xml' #default file
    try:
        opts, args = getopt.getopt(argv,"ho:")
    except getopt.GetoptError:
        print('getAllData.py -o <outputfile> host')
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print('getAllData.py -o <outputfile> host')
            sys.exit()
        elif opt == '-o':
            output = arg
    if len(args) >= 1:
        hostn = args[0]

    #request for odf hierarchy
    hierarchyRequest = """<omiEnvelope xmlns="http://www.opengroup.org/xsd/omi/1.0/"  version="1.0" ttl="0">
  <read msgformat="odf">
    <msg>
      <Objects xmlns="http://www.opengroup.org/xsd/odf/1.0/"/>
    </msg>
  </read>
</omiEnvelope>"""
    #request for 9000 newest values(should be enough for now) 
    fullRequest = """<omiEnvelope xmlns="http://www.opengroup.org/xsd/omi/1.0/" version="1.0" ttl="0">
  <read msgformat="odf" newest="9000">
    <msg>
    </msg>
  </read>
</omiEnvelope>"""


    #register namespaces so that we don't get wrong namespaces in the request
    register_namespace("omi","omi.xsd")
    register_namespace("odf", "odf.xsd")
    register_namespace("", "http://www.w3.org/2001/XMLSchema-instance")
    headers = {'Content-Type': 'application/xml'}

    #current hierarchy
    r = requests.post(hostn, data = hierarchyRequest, headers = headers).text

    root = fromstring(r)
    
    objects = root.find(".//{http://www.opengroup.org/xsd/odf/1.0/}Objects")
    #remove values and add metadata and description tags
    update_odf(objects)

    fullRoot = fromstring(fullRequest)

    fullRoot.find(".//{http://www.opengroup.org/xsd/omi/1.0/}msg").append(objects)

    #write result to file. note: result might be big so iterate over the result
    with open(output,'wb') as handle:
        r2 = requests.post(hostn, data = tostring(fullRoot, encoding="utf-8"), headers = headers, stream = True)
        if not r2.ok:
            print("INVALID RESPONSE")
        for block in r2.iter_content(1024):
            handle.write(block)

 def test_findMatches3(self):
     sourceElement = fromstring("<THU><Team><ACRush></ACRush><Jelly></Jelly><Cooly></Cooly></Team><JiaJia><Team><Ahyangyi></Ahyangyi><Dragon></Dragon><Cooly><Amber></Amber></Cooly></Team></JiaJia></THU>")
     searchPatternElement = fromstring("<Team><Cooly></Cooly></Team>")
     matches = []
     FindMatchesInElement(sourceElement, searchPatternElement, ReferenceType(1), matches)
     answer = [2, 7]
     self.assert_(len(answer) == len(matches) and all(answer[i] == matches[i] for i in range(len(answer)-1)))

 def test_findMatches2(self):
     sourceElement = fromstring("<red><green><blue></blue><yellow></yellow></green></red>")
     searchPatternElement = fromstring("<green><blue></blue></green>")
     matches = []
     FindMatchesInElement(sourceElement, searchPatternElement, ReferenceType(1), matches)
     answer = [2]
     self.assert_(len(answer) == len(matches) and all(answer[i] == matches[i] for i in range(len(answer)-1)))

 def test_eval_2 (self) :
     # Query tree have more than 2 layers
     a = fromstring("<a><b><c></c><d><f></f></d></b></a>")  
     b = fromstring("<b><d><f></f></d></b>")
     v = xmleval(a,b)
     print (str(v))
     self.assertTrue(v == [1,2])

 def test_xml_check (self) :
     s = "<A><B><C></C><D></D></B></A>"
     c = fromstring(s)
     t = "<A><B></B></A>"
     p = fromstring(t)
     r = xml_check(c, p)
     self.assertTrue(r == True)

 def test_eval_3 (self) :
     # Query tree does not exist in source tree
     a = fromstring("<a><b><c></c><d></d></b></a>")  
     b = fromstring("<b><e></e></b>")
     v = xmleval(a,b)
     print (str(v))
     self.assertTrue(v == [0])

 def test3_findPattern(self): # Verify that 2nd element is correct
     xmltree = "<xml><outer><middle><inner></inner></middle></outer></xml>"
     globals1 = StoreGlob1(fromstring(xmltree))
     xml_findPattern(globals1,fromstring(xmltree))
     pattern = globals1.curPattern
     testelement = fromstring("<middle></middle>")
     self.assertTrue(pattern[2].tag == testelement.tag)

def mergeLogs(fromFilePath, toFilePath, outputFilePath):
    utf8open = lambda s: open(s, 'r', 'utf8')

    outputDoc = E('html')

    with utf8open(fromFilePath) as fromFile, utf8open(toFilePath) as toFile:

        # the body and HTML tags are left open so the app can just append
        # when a new message comes in. we have to close them.
        # note: this could also be taken care of by BeautifulSoup or
        # perhaps lxml.html

        fromDoc = fromstring(fromFile.read() + '</BODY></HTML>')
        toDoc = fromstring(toFile.read() + '</BODY></HTML>')

        # copy the head tag so formatting and stuff is preserved in our new doc
        outputDoc.append(fromDoc.find('HEAD').copy())

        fromMessages = fromDoc.findall('./BODY/div')
        toMessages = toDoc.findall('./BODY/div')

        allMessages = list(fromMessages) + list(toMessages)
        allMessages.sort(key = lambda e: time.strptime(e.attrib['timestamp'], '%Y-%m-%d %H:%M:%S'))

        body = SE(outputDoc, 'BODY', attrib = fromDoc.find('BODY').attrib)
        body.extend(x.copy() for x in allMessages)

    ElementTree(outputDoc).write(outputFilePath, 'utf8')