Python ElementTree.register_namespace方法代码示例

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def __str__(self):
        #
        # need to register the ome namespace because BioFormats expects
        # that namespace to be the default or to be explicitly named "ome"
        #

        for ns_key in ["ome"]:
            ns = self.ns.get(ns_key) or NS_DEFAULT.format(ns_key=ns_key)
            # ElementTree.register_namespace(ns_key, ns)
            ElementTree.register_namespace('', ns)
        # ElementTree.register_namespace("om", NS_ORIGINAL_METADATA)
        result = BytesIO()
        ElementTree.ElementTree(self.root_node).write(result,
                                                      encoding='utf-8',
                                                      method="xml",
                                                      xml_declaration=True
                                                      # default_namespace = 'http://www.openmicroscopy.org/Schemas/ome/2016-06'
                                                      )
        return result.getvalue().decode() 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def remove_office_metadata(input_file, output_file=None):
	"""
	Remove all metadata from Microsoft Office 2007+ file types such as docx,
	pptx, and xlsx.
	"""
	input_file = os.path.abspath(input_file)
	patches = {}
	ns = {
		'cp': 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties',
		'dc': 'http://purl.org/dc/elements/1.1/',
		'dcterms': 'http://purl.org/dc/terms/',
		'dcmitype': 'http://purl.org/dc/dcmitype/',
		'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
	}
	for prefix, uri in ns.items():
		ElementTree.register_namespace(prefix, uri)

	with zipfile.ZipFile(input_file, 'r') as zin:
		docprops_core = zin.read('docProps/core.xml')
	root = ElementTree.fromstring(docprops_core)
	root.clear()
	docprops_core = ElementTree.tostring(root, 'utf-8')
	patches['docProps/core.xml'] = docprops_core
	archive.patch_zipfile(input_file, patches, output_file=output_file) 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def _getJobInfosFromReqResult(self, r, phase):
        if (len(r.history) > 0):
            print("SERVER RESPONSE : "+r.history[0].text)

        if (r.status_code == 200):
            #et = ElementTree
            #ElementTree.register_namespace('uws', 'http://www.ivoa.net/xml/UWS/v1.0')
            for ns in XML_NS:
                ElementTree.register_namespace(ns, XML_NS[ns])

            try:
                return ElementTree.fromstring(r.text)
            except Exception as e:
                print("Invalid response :")
                print(r.text)
                raise e
        else:
            raise JobError(r, phase)




# Convertion into text 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def prepare_domain_xml(domain_name, qemu_bin_path, nitro_image_path, open_vnc, enable_kvmi):
    with open("template_domain.xml") as templ:
        domain_xml = templ.read()
        domain_xml = domain_xml.format(domain_name=domain_name,
                                       qemu_bin_path=qemu_bin_path,
                                       nitro_image_path=nitro_image_path)
        root = tree.fromstring(domain_xml)
        if open_vnc:
            # search for graphics element
            graphics_elem = root.findall("./devices/graphics")[0]
            graphics_elem.attrib['listen'] = '0.0.0.0'
        if enable_kvmi:
            tree.register_namespace("qemu", "http://libvirt.org/schemas/domain/qemu/1.0")
            kvmi_args = tree.fromstring(QEMU_ARGS_XML)
            argument = kvmi_args.find("./*[2]")
            argument.attrib["value"] = argument.attrib["value"].format(
                path="/tmp/{}-introspector".format(domain_name))
            root.append(kvmi_args)
        domain_xml = tree.tostring(root).decode()
        return domain_xml
    return None 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def bug_200709_register_namespace():
    """

    >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))
    '<ns0:title xmlns:ns0="http://namespace.invalid/does/not/exist/" />'
    >>> ET.register_namespace("foo", "http://namespace.invalid/does/not/exist/")
    >>> ET.tostring(ET.Element("{http://namespace.invalid/does/not/exist/}title"))
    '<foo:title xmlns:foo="http://namespace.invalid/does/not/exist/" />'

    And the Dublin Core namespace is in the default list:

    >>> ET.tostring(ET.Element("{http://purl.org/dc/elements/1.1/}title"))
    '<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/" />'

    """ 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def __init__(self, *args, **kwargs):
        ET.register_namespace("svg", self._SVG_namespace)
        super(SvgFragmentImage, self).__init__(*args, **kwargs)
        # Save the unit size, for example the default box_size of 10 is '1mm'.
        self.unit_size = self.units(self.box_size) 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def __init__(self, request_body, cache, generator):
        self.error_message = ""
        self.cache = cache
        self.generator = generator
        self.root = element_tree.fromstring(request_body)
        self.document_key = None
        self.hmac_key = None
        self.public_key = None
        self.use_playready_content_key = False
        element_tree.register_namespace("cpix", "urn:dashif:org:cpix")
        element_tree.register_namespace("pskc", "urn:ietf:params:xml:ns:keyprov:pskc")
        element_tree.register_namespace("speke", "urn:aws:amazon:com:speke")
        element_tree.register_namespace("ds", "http://www.w3.org/2000/09/xmldsig#")
        element_tree.register_namespace("enc", "http://www.w3.org/2001/04/xmlenc#") 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def get_et_tree(cls, html):
        et_tree = ET.fromstring(html)
        ET.register_namespace('', cls.NAMESPACE[1:-1])
        return et_tree 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def __init__(self):
        self.headers = {
            'Content-Type': 'text/xml',
            'Accept': 'application/*',
            'X-NotificationClass': self.NOTIFICATION_CLS,
            'X-WindowsPhone-Target': self.TARGET,
        }
        ElementTree.register_namespace('wp', 'WPNotification') 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def resize_imgs(input_dir):
    ElementTree.register_namespace("", "http://www.w3.org/2000/svg")
    for img in input_dir.iterdir():
        tree = ElementTree.parse(str(img))
        root = tree.getroot()
        root.attrib["width"] = "144"
        root.attrib["height"] = "144"
        with open(img, "w+") as fd:
            fd.write(ElementTree.tostring(root, encoding="unicode", method="xml"))
        dst = img.parent / img.name.replace("_48px", "").replace("ic_", "")
        shutil.move(str(img), str(dst)) 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def transform_mission_xml(self, params, mission_xml):
        """Additional transforms on mission xml."""
        ns = '{http://ProjectMalmo.microsoft.com}'
        xml = None  # parse if needed

        # Video options to apply to all agents.
        if params.videoResolution is not None or params.videoWithDepth is not None:
            if xml is None:
                ElementTree.register_namespace('', 'http://ProjectMalmo.microsoft.com')
                xml = ElementTree.fromstring(mission_xml)
            elements = xml.findall(ns + "AgentSection")
            for e in elements:
                e = e.find(ns + "AgentHandlers")
                vp = e.find(ns + "VideoProducer")
                if vp is None:
                    vp = ElementTree.Element(ns + "VideoProducer")
                    e.append(vp)
                w = vp.find(ns + "Width")
                w.text = str(params.videoResolution[0] if params.videoResolution else '800')
                h = vp.find(ns + "Height")
                h.text = str(params.videoResolution[1] if params.videoResolution else '600')
                if params.videoWithDepth is not None:
                    vp.attrib['want_depth'] = 'true' if params.videoWithDepth else 'false'

        if xml is not None:
            mission_xml = ElementTree.tostring(xml)
        return mission_xml 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def testExtractOperations(self):
    """Tests whether operations XML was extracted and formatted correctly.

    Verifies that the xsi_type has been properly assigned.
    """
    _, operations = self.GenerateOperations('CampaignCriterionOperation', 1)
    raw_xml = self.request_builder._GenerateRawRequestXML(operations)
    operations_xml = self.request_builder._ExtractOperations(raw_xml)
    # Put operations in a format that allows us to easily verify the behavior.
    ElementTree.register_namespace(
        'xsi', 'http://www.w3.org/2001/XMLSchema-instance')
    # Need to declare xsi for ElementTree to parse operations properly.
    body = ElementTree.fromstring(
        '<body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">%s'
        '</body>' % operations_xml)
    self.assertTrue(body.tag == 'body')
    ops_element = body.find('operations')
    # Check that the xsi_type has been set correctly.
    self.assertTrue(ops_element.attrib[
        '{http://www.w3.org/2001/XMLSchema-instance}type'] ==
                    'CampaignCriterionOperation')
    operand = ops_element.find('operand')
    self.assertTrue(operand.attrib[
        '{http://www.w3.org/2001/XMLSchema-instance}type'] ==
                    'NegativeCampaignCriterion')
    criterion = operand.find('criterion')
    self.assertTrue(criterion.attrib[
        '{http://www.w3.org/2001/XMLSchema-instance}type'] ==
                    'Keyword') 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def remove_xml_element_file(name, path):
    """ Remove XML elements from a single file """
    ET.register_namespace("", "http://soap.sforce.com/2006/04/metadata")
    tree = elementtree_parse_file(path)
    tree = remove_xml_element(name, tree)
    return tree.write(path, encoding=UTF8, xml_declaration=True) 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def remove_xml_element_string(name, content):
    """ Remove XML elements from a string """
    ET.register_namespace("", "http://soap.sforce.com/2006/04/metadata")
    tree = ET.fromstring(content)
    tree = remove_xml_element(name, tree)
    clean_content = ET.tostring(tree, encoding=UTF8)
    return clean_content 

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import register_namespace [as 别名]
def register_namespace_prefixes():
    prefixes = (('saml', saml.NAMESPACE),
                ('samlp', samlp.NAMESPACE),
                ('md', md.NAMESPACE),
                ('ds', xmldsig.NAMESPACE),
                ('xenc', xmlenc.NAMESPACE))
    for prefix, namespace in prefixes:
        ElementTree.register_namespace(prefix, namespace)