Python ElementTree.tostring方法代码示例

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
 def test_insert_nested_div(self):
     content_root = ET.fromstring(content_root_text)
     html = ET.fromstring(html_text)
     output = ET.fromstring(output_text)
     make_html.insert(content_root, html)
     self.assertEqual(ET.tostring(html).split('\n'),
                      ET.tostring(output).split('\n'))

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def appendToExistingFiltersFile(filterFileName, xml_filtersRoot):
    print("Updating filters of existing file.")

    existingRoot = Xml.parse(filterFileName).getroot()
    print(Xml.tostring(xml_filtersRoot))
    existingRoot.set("ToolsVersion", ToolsVersion)

    found = False
    for itemGroup in existingRoot:
        for child in itemGroup:
            if child.tag.endswith("Filter"):
                print("Removing all existing filters.")
                found = True
                itemGroup.clear()
                toAppendTo = itemGroup
                break
        if found: break

    if not found:
        print("No existing filters found.")
        toAppendTo = Xml.SubElement(existingRoot, "ItemGroup")

    for itemGroup in xml_filtersRoot:
        for filterElement in itemGroup:
            toAppendTo.append(filterElement)

    with open(filterFileName, "w") as filterFile:
        xmlContent = """<?xml version="1.0" encoding="utf-8"?>\n"""
        xmlContent += Xml.tostring(existingRoot, encoding="unicode");
        filterFile.write(xmlContent)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
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

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def to_xml(elem, encoding=None, pretty=False):
    '''
    Export element to XML

    Parameters
    ----------
    elem : ElementTree.Element or xml-string
        The element to export
    encoding : string, optional
        The output encoding

    Returns
    -------
    string

    '''
    if isinstance(elem, six.string_types):
        elem = ET.fromstring(elem)

    # In-place editing!!
    if pretty:
        xml_indent(elem)

    if encoding is None:
        return ET.tostring(elem, encoding='utf-8').decode()

    return ET.tostring(elem, encoding=encoding)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
    def test_fuzz_data_xml(self):
        """Test _fuzz_data_ with an XML element."""
        data = ElementTree.Element("a")
        sub_ele = ElementTree.Element("b")
        sub_ele.text = "c"
        sub_ele.attrib = {"name": "val"}
        sub_ele2 = ElementTree.Element("ACTION_FIELD:d")
        sub_ele2.text = "e"
        data.append(sub_ele)
        data.append(sub_ele2)
        strings = ["test"]

        contents = []
        expected_contents = [
            '<a><b name="val">test</b><ACTION_FIELD:d>e</ACTION_FIELD:d></a>',
            '<a><b name="test">c</b><ACTION_FIELD:d>e</ACTION_FIELD:d></a>'
        ]

        for i, d in enumerate(
                fuzz_datagen._fuzz_data(strings, data, "ACTION_FIELD:",
                                        "unittest"), 1):
            name, model, stri, param_path = d
            self.assertEqual("unitteststr1_model{0}".format(i), name)
            self.assertEqual("test", stri)
            if six.PY2:
                contents.append(ElementTree.tostring(model))
            else:
                contents.append(ElementTree.tostring(model).decode("utf-8"))
        self.assertEqual(expected_contents, contents)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def feedback(items):
    feedback = ET.Element("items")
    
    def processItem(item):
        itemToAdd = ET.SubElement(feedback, "item")

        data = item.get()

        for (k, v) in data["attrib"].iteritems():
            itemToAdd.set(k, v)

        for (k, v) in data["content"].iteritems():
            if k != "fileIcon" and k != "fileType":
                child = ET.SubElement(itemToAdd, k)
                child.text = v
            if k == "icon":
                if "fileIcon" in data["content"].keys():
                    if data["content"]["fileIcon"] == True:
                        child.set("type", "fileicon")
                if "fileType" in data["content"].keys():
                    if data["content"]["fileType"] == True:
                        child.set("type", "filetype")

    if isinstance(items, list):
        for anItem in items:
            processItem(anItem)
    else:
        processItem(items)

    print ET.tostring(feedback, encoding="utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
        def __bodyOfferModify(self, tsn, pc_body_id, description, duration, size, title, subtitle, url):

            data = {
                'bodyId' : 'tsn:' + tsn,
                'description' : description,
                'duration' : duration,
                'encodingType' : 'mpeg2ProgramStream',
                'partnerId' : 'tivo:pt.3187',
                'pcBodyId' : pc_body_id,
                'publishDate' : time.strftime('%Y-%m-%d %H:%M%S', time.gmtime()),
                'size' : size,
                'source' : 'file:/C%3A%2FDocuments%20and%20Settings%2FStephanie%2FDesktop%2FVideo',
                'state' : 'complete',
                'subtitle' : subtitle,
                'title' : title,
                'url' : url,
            }
            r = urllib2.Request(
                'https://mind.tivo.com:8181/mind/mind7?type=bodyOfferModify&bodyId=tsn:' + tsn, 
                dictcode(data),
                {'Content-Type' : 'x-tivo/dict-binary'}
            )
            result = self.__opener.open(r)

            xml = ElementTree.parse(result).find('.')
            
            self.__log('__bodyOfferModify\n%s\n\n%sg' % (data, ElementTree.tostring(xml)))

            if xml.findtext('state') != 'complete':
                raise Exception(ElementTree.tostring(xml))

            offer_id = xml.findtext('offerId')
            content_id = offer_id.replace('of','ct')

            return offer_id, content_id

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
 def assertXMLEqual(self, first, second, msg=None, ignore_white_space=True):
     if first is None and second is None:
         return True
     if ignore_white_space:
         def cleanup(elem):
             for e in elem.iter():
                 if e.text is not None:
                     e.text = e.text.strip()
                 if e.tail is not None:
                     e.tail = e.tail.strip()
         cleanup(first)
         cleanup(second)
     if (first is None and second is not None) or (second is None and first is not None):
         self.fail("unequal elements: first %r, second %r" % (first, second))
     first_string = ET.tostring(prettify_tree(first, level=2))
     second_string = ET.tostring(prettify_tree(second, level=2))
     if not msg:
         msg = 'xml is not equal'
     msg += "\nfirst_string:\n" + first_string + \
            "\nsecond_string:\n" + second_string
     if first_string != second_string:
         # Could be xml ordering - try reparsing to ensure consistent ordering.
         first_string = _serializePrefToString(_deserializePrefString(first_string))
         second_string = _serializePrefToString(_deserializePrefString(second_string))
     self.assertEqual(first_string, second_string, msg=msg)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def _xml_to_cdltransforms(xml):
    """Given some XML as a string, returns a list of CDLTransform
    objects for each ColorCorrection (returns a one-item list for a
    .cc file)
    """

    tree = ET.fromstring(xml)

    # Strip away xmlns
    for elem in tree.getiterator():
        if elem.tag.startswith("{"):
             elem.tag = elem.tag.partition("}")[2]

    filetype = tree.tag

    if filetype == "ColorCorrection":
        ccxml = ET.tostring(tree)
        cdl = OCIO.CDLTransform()
        cdl.setXML(ccxml)
        return [cdl]

    elif filetype == "ColorCorrectionCollection":
        allcdl = []
        for cc in tree.getchildren():
            ccxml = ET.tostring(cc)
            cdl = OCIO.CDLTransform()
            cdl.setXML(ccxml)
            allcdl.append(cdl)
        return allcdl

    else:
        raise RuntimeError(
            "The supplied file did not have the correct root element, expected"
            " 'ColorCorrection' or 'ColorCorrectionCollection', got %r" % (filetype))

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
 def test_edit_config_2(self, mock_request):
     session = ncclient.transport.SSHSession(self.device_handler)
     session._server_capabilities = [":rollback-on-error", ":validate"]
     obj = EditConfig(
         session,
         self.device_handler,
         raise_mode=RaiseMode.ALL)
     root = """
         system {
             host-name foo-bar;
         }
         """
     obj.request(copy.deepcopy(root), format="text", target="running", error_option="rollback-on-error",
                 default_operation="default", test_option="test")
     node = new_ele("edit-config")
     node.append(util.datastore_or_url("target", "running"))
     sub_ele(node, "error-option").text = "rollback-on-error"
     sub_ele(node, "test-option").text = "test"
     sub_ele(node, "default-operation").text = "default"
     config_text = sub_ele(node, "config-text")
     sub_ele(config_text, "configuration-text").text = root
     xml = ElementTree.tostring(node)
     call = mock_request.call_args_list[0][0][0]
     call = ElementTree.tostring(call)
     self.assertEqual(call, xml)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def test_xml_output(lldpd1, lldpd, lldpcli, namespaces, uname, command,
                    expected):
    with namespaces(2):
        lldpd()
    with namespaces(1):
        result = lldpcli(
            *shlex.split("-f xml show {} details".format(command)))
        assert result.returncode == 0
        out = result.stdout.decode('ascii')
        xml = ET.fromstring(out)

        age = xml.findall('./interface[1]')[0].attrib['age']
        router = xml.findall("./interface[1]/chassis/"
                           "capability[@type='Router']")[0].attrib['enabled']
        station = xml.findall("./interface[1]/chassis/"
                            "capability[@type='Station']")[0].attrib['enabled']
        if 'Dot3' in pytest.config.lldpd.features:
            dot3 = """
   <auto-negotiation enabled="no" label="PMD autoneg" supported="no">
    <current label="MAU oper type">10GigBaseCX4 - X copper over 8 pair 100-Ohm balanced cable</current>
   </auto-negotiation>"""
        else:
            dot3 = ""
        expected = ET.fromstring(expected.format(age=age,
                                                 router=router,
                                                 station=station,
                                                 uname=uname,
                                                 dot3=dot3))
        assert ET.tostring(xml) == ET.tostring(expected)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def hdd(root, test):
    nodes = []
    nodes.append(root)
    fail_nodes = []
    while len(nodes) > 0:
        temp = []
        for node in nodes:
            for child in node:
                if test(string_to_list(ET.tostring(child))) == FAIL: 
                    if len(child) > 0:
                        temp.append(child)
                    else:
                        fail_nodes.append(child)
        nodes = temp
    print len(fail_nodes)
    for node in fail_nodes:
        data = ET.tostring(node)
    
        #replace location of fail to correct fail string
        if FAIL_TAG in data:
            data = data.replace(FAIL_TAG, FAIL_STRING, 1)
        print data
        circumstances = string_to_list(data)
        test(ddmin(circumstances, test))

        showResult(TEMP_FILE)
    return fail_nodes

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def create_main_html(tables_tape,tables_disk, sites_tape, sites_disk, output_dir):
    html = open("main_page.tmpl").read()
    
    column_tape = ""  
    for site in sites_tape:
        column_tape += '<a href="tape_storage_overview_'+site.name+'.html">' + site.name + '</a> ' 


    column_disk = ""  
    for site in sites_disk:
        column_disk += '<a href="disk_storage_overview_'+site.name+'.html">' + site.name + '</a> '

    fp = open(os.path.join(output_dir, "main.html"), "w")
    fp.write(html.format(
                title='Storage Overview',
                title_tape='Tape Storage Overview',
                title_disk='Disk Storage Overview',
                date=date.today(),
                summary_tape=ET.tostring(tables_tape.summary()),
                delta_summary_tape=ET.tostring(tables_tape.summary(delta=True)),
                summary_disk=ET.tostring(tables_disk.summary()),
                delta_summary_disk=ET.tostring(tables_disk.summary(delta=True)),
                column_tape=column_tape,
                column_disk=column_disk, 
                fulldate=date.today()
                )) 

    fp.close()

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
def test_icon():
    # not attribute
    root = etree.Element('root')
    e = Icon('icon_text')
    e.build(root)
    eq_('<root><icon>icon_text</icon></root>', etree.tostring(root))

    # fileicon attribute
    root = etree.Element('root')
    e = Icon('icon_text', type='fileicon')
    e.build(root)
    eq_('<root><icon type="fileicon">icon_text</icon></root>',
        etree.tostring(root))

    # filetype attribute
    root = etree.Element('root')
    e = Icon('icon_text', type='filetype')
    e.build(root)
    eq_('<root><icon type="filetype">icon_text</icon></root>',
        etree.tostring(root))

    # error
    with assert_raises(ValueError) as ve:
        e = Icon('root')
        e.type = 'dummy'
    eq_("type must be ['fileicon', 'filetype', None]", str(ve.exception))

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import tostring [as 别名]
    def check_block(case_block):
        case_block.set('xmlns', XMLNS)
        case_block = ElementTree.fromstring(ElementTree.tostring(case_block))
        case_id = get_case_id(case_block)
        n = 0

        def extra_info():
            return "\n%s\n%s" % (ElementTree.tostring(case_block), map(ElementTree.tostring, blocks))
        match = None
        for block in blocks:
            if get_case_id(block) == case_id:
                if should_have:
                    if line_by_line:
                        check_xml_line_by_line(
                            testcase,
                            ElementTree.tostring(case_block),
                            ElementTree.tostring(block)
                        )
                    match = block
                    n += 1
                    if n == 2:
                        testcase.fail(
                            "Block for case_id '%s' appears twice"
                            " in ota restore for user '%s':%s" % (case_id, user.username, extra_info())
                        )
                else:
                    testcase.fail(
                        "User '%s' gets case '%s' "
                        "but shouldn't:%s" % (user.username, case_id, extra_info())
                    )
        if not n and should_have:
            testcase.fail("Block for case_id '%s' doesn't appear in ota restore for user '%s':%s"
                          % (case_id, user.username, extra_info()))

        return match