"""Lightweight XML support for Python.

XML is an inherently hierarchical data format, and the most natural way to

represent it is with a tree. This module has two classes for this purpose:

1. ElementTree represents the whole XML document as a tree and

2. Element represents a single node in this tree.

Interactions with the whole document (reading and writing to/from files) are

usually done on the ElementTree level. Interactions with a single XML element

and its sub-elements are done on the Element level.

Element is a flexible container object designed to store hierarchical data

structures in memory. It can be described as a cross between a list and a

dictionary. Each Element has a number of properties associated with it:

'tag' - a string containing the element's name.

'attributes' - a Python dictionary storing the element's attributes.

'text' - a string containing the element's text content.

'tail' - an optional string containing text after the element's end tag.

And a number of child elements stored in a Python sequence.

To create an element instance, use the Element constructor,

or the SubElement factory function.

You can also use the ElementTree class to wrap an element structure

and convert it to and from XML.

"""

#---------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.

# See https://www.python.org/psf/license for licensing details.

#

# ElementTree

# Copyright (c) 1999-2008 by Fredrik Lundh. All rights reserved.

#

# fredrik@pythonware.com

# http://www.pythonware.com

# --------------------------------------------------------------------

# The ElementTree toolkit is

#

# Copyright (c) 1999-2008 by Fredrik Lundh

#

# By obtaining, using, and/or copying this software and/or its

# associated documentation, you agree that you have read, understood,

# and will comply with the following terms and conditions:

#

# Permission to use, copy, modify, and distribute this software and

# its associated documentation for any purpose and without fee is

# hereby granted, provided that the above copyright notice appears in

# all copies, and that both that copyright notice and this permission

# notice appear in supporting documentation, and that the name of

# Secret Labs AB or the author not be used in advertising or publicity

# pertaining to distribution of the software without specific, written

# prior permission.

#

# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-

# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR

# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY

# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

# OF THIS SOFTWARE.

# --------------------------------------------------------------------

__all__ = [

# public symbols

"Comment",

"dump",

"Element", "ElementTree",

"fromstring", "fromstringlist",

"indent", "iselement", "iterparse",

"parse", "ParseError",

"PI", "ProcessingInstruction",

"QName",

"SubElement",

"tostring", "tostringlist",

"TreeBuilder",

"VERSION",

"XML", "XMLID",

"XMLParser", "XMLPullParser",

"register_namespace",

"canonicalize", "C14NWriterTarget",

]

VERSION = "1.3.0"

import sys

import re

import warnings

import io

import collections

import collections.abc

import contextlib

import weakref

from . import ElementPath

class ParseError(SyntaxError):

"""An error when parsing an XML document.

In addition to its exception value, a ParseError contains

two extra attributes:

'code' - the specific exception code

'position' - the line and column of the error

"""

pass

# --------------------------------------------------------------------

def iselement(element):

"""Return True if *element* appears to be an Element."""

return hasattr(element, 'tag')

class Element:

"""An XML element.

This class is the reference implementation of the Element interface.

An element's length is its number of subelements. That means if you

want to check if an element is truly empty, you should check BOTH

its length AND its text attribute.

The element tag, attribute names, and attribute values can be either

bytes or strings.

*tag* is the element name. *attrib* is an optional dictionary containing

element attributes. *extra* are additional element attributes given as

keyword arguments.

Example form:

<tag attrib>text<child/>...</tag>tail

"""

tag = None

"""The element's name."""

attrib = None

"""Dictionary of the element's attributes."""

text = None

"""

Text before first subelement. This is either a string or the value None.

Note that if there is no text, this attribute may be either

None or the empty string, depending on the parser.

"""

tail = None

"""

Text after this element's end tag, but before the next sibling element's

start tag. This is either a string or the value None. Note that if there

was no text, this attribute may be either None or an empty string,

depending on the parser.

"""

def __init__(self, tag, attrib={}, **extra):

if not isinstance(attrib, dict):

raise TypeError("attrib must be dict, not %s" % (

attrib.__class__.__name__,))

self.tag = tag

self.attrib = {**attrib, **extra}

self._children = []

def __repr__(self):

return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))

def makeelement(self, tag, attrib):

"""Create a new element with the same type.

*tag* is a string containing the element name.

*attrib* is a dictionary containing the element attributes.

Do not call this method, use the SubElement factory function instead.

"""

return self.__class__(tag, attrib)

def __copy__(self):

elem = self.makeelement(self.tag, self.attrib)

elem.text = self.text

elem.tail = self.tail

elem[:] = self

return elem

def __len__(self):

return len(self._children)

def __bool__(self):

warnings.warn(

"Testing an element's truth value will always return True in "

"future versions. "

"Use specific 'len(elem)' or 'elem is not None' test instead.",

DeprecationWarning, stacklevel=2

)

return len(self._children) != 0 # emulate old behaviour, for now

def __getitem__(self, index):

return self._children[index]

def __setitem__(self, index, element):

if isinstance(index, slice):

for elt in element:

self._assert_is_element(elt)

else:

self._assert_is_element(element)

self._children[index] = element

def __delitem__(self, index):

del self._children[index]

def append(self, subelement):

"""Add *subelement* to the end of this element.

The new element will appear in document order after the last existing

subelement (or directly after the text, if it's the first subelement),

but before the end tag for this element.

"""

self._assert_is_element(subelement)

self._children.append(subelement)

def extend(self, elements):

"""Append subelements from a sequence.

*elements* is a sequence with zero or more elements.

"""

for element in elements:

self._assert_is_element(element)

self._children.append(element)

def insert(self, index, subelement):

"""Insert *subelement* at position *index*."""

self._assert_is_element(subelement)

self._children.insert(index, subelement)

def _assert_is_element(self, e):

# Need to refer to the actual Python implementation, not the

# shadowing C implementation.

if not isinstance(e, _Element_Py):

raise TypeError('expected an Element, not %s' % type(e).__name__)

def remove(self, subelement):

"""Remove matching subelement.

Unlike the find methods, this method compares elements based on

identity, NOT ON tag value or contents. To remove subelements by

other means, the easiest way is to use a list comprehension to

select what elements to keep, and then use slice assignment to update

the parent element.

ValueError is raised if a matching element could not be found.

"""

# assert iselement(element)

try:

self._children.remove(subelement)

except ValueError:

# to align the error message with the C implementation

raise ValueError("Element.remove(x): element not found") from None

def find(self, path, namespaces=None):

"""Find first matching element by tag name or path.

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return the first matching element, or None if no element was found.

"""

return ElementPath.find(self, path, namespaces)

def findtext(self, path, default=None, namespaces=None):

"""Find text for first matching element by tag name or path.

*path* is a string having either an element tag or an XPath,

*default* is the value to return if the element was not found,

*namespaces* is an optional mapping from namespace prefix to full name.

Return text content of first matching element, or default value if

none was found. Note that if an element is found having no text

content, the empty string is returned.

"""

return ElementPath.findtext(self, path, default, namespaces)

def findall(self, path, namespaces=None):

"""Find all matching subelements by tag name or path.

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Returns list containing all matching elements in document order.

"""

return ElementPath.findall(self, path, namespaces)

def iterfind(self, path, namespaces=None):

"""Find all matching subelements by tag name or path.

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return an iterable yielding all matching elements in document order.

"""

return ElementPath.iterfind(self, path, namespaces)

def clear(self):

"""Reset element.

This function removes all subelements, clears all attributes, and sets

the text and tail attributes to None.

"""

self.attrib.clear()

self._children = []

self.text = self.tail = None

def get(self, key, default=None):

"""Get element attribute.

Equivalent to attrib.get, but some implementations may handle this a

bit more efficiently. *key* is what attribute to look for, and

*default* is what to return if the attribute was not found.

Returns a string containing the attribute value, or the default if

attribute was not found.

"""

return self.attrib.get(key, default)

def set(self, key, value):

"""Set element attribute.

Equivalent to attrib[key] = value, but some implementations may handle

this a bit more efficiently. *key* is what attribute to set, and

*value* is the attribute value to set it to.

"""

self.attrib[key] = value

def keys(self):

"""Get list of attribute names.

Names are returned in an arbitrary order, just like an ordinary

Python dict. Equivalent to attrib.keys()

"""

return self.attrib.keys()

def items(self):

"""Get element attributes as a sequence.

The attributes are returned in arbitrary order. Equivalent to

attrib.items().

Return a list of (name, value) tuples.

"""

return self.attrib.items()

def iter(self, tag=None):

"""Create tree iterator.

The iterator loops over the element and all subelements in document

order, returning all elements with a matching tag.

If the tree structure is modified during iteration, new or removed

elements may or may not be included. To get a stable set, use the

list() function on the iterator, and loop over the resulting list.

*tag* is what tags to look for (default is to return all elements)

Return an iterator containing all the matching elements.

"""

if tag == "*":

tag = None

if tag is None or self.tag == tag:

yield self

for e in self._children:

yield from e.iter(tag)

def itertext(self):

"""Create text iterator.

The iterator loops over the element and all subelements in document

order, returning all inner text.

"""

tag = self.tag

if not isinstance(tag, str) and tag is not None:

return

t = self.text

if t:

yield t

for e in self:

yield from e.itertext()

t = e.tail

if t:

yield t

def SubElement(parent, tag, attrib={}, **extra):

"""Subelement factory which creates an element instance, and appends it

to an existing parent.

The element tag, attribute names, and attribute values can be either

bytes or Unicode strings.

*parent* is the parent element, *tag* is the subelements name, *attrib* is

an optional directory containing element attributes, *extra* are

additional attributes given as keyword arguments.

"""

attrib = {**attrib, **extra}

element = parent.makeelement(tag, attrib)

parent.append(element)

return element

def Comment(text=None):

"""Comment element factory.

This function creates a special element which the standard serializer

serializes as an XML comment.

*text* is a string containing the comment string.

"""

element = Element(Comment)

element.text = text

return element

def ProcessingInstruction(target, text=None):

"""Processing Instruction element factory.

This function creates a special element which the standard serializer

serializes as an XML comment.

*target* is a string containing the processing instruction, *text* is a

string containing the processing instruction contents, if any.

"""

element = Element(ProcessingInstruction)

element.text = target

if text:

element.text = element.text + " " + text

return element

PI = ProcessingInstruction

class QName:

"""Qualified name wrapper.

This class can be used to wrap a QName attribute value in order to get

proper namespace handing on output.

*text_or_uri* is a string containing the QName value either in the form

{uri}local, or if the tag argument is given, the URI part of a QName.

*tag* is an optional argument which if given, will make the first

argument (text_or_uri) be interpreted as a URI, and this argument (tag)

be interpreted as a local name.

"""

def __init__(self, text_or_uri, tag=None):

if tag:

text_or_uri = "{%s}%s" % (text_or_uri, tag)

self.text = text_or_uri

def __str__(self):

return self.text

def __repr__(self):

return '<%s %r>' % (self.__class__.__name__, self.text)

def __hash__(self):

return hash(self.text)

def __le__(self, other):

if isinstance(other, QName):

return self.text <= other.text

return self.text <= other

def __lt__(self, other):

if isinstance(other, QName):

return self.text < other.text

return self.text < other

def __ge__(self, other):

if isinstance(other, QName):

return self.text >= other.text

return self.text >= other

def __gt__(self, other):

if isinstance(other, QName):

return self.text > other.text

return self.text > other

def __eq__(self, other):

if isinstance(other, QName):

return self.text == other.text

return self.text == other

# --------------------------------------------------------------------

class ElementTree:

"""An XML element hierarchy.

This class also provides support for serialization to and from

standard XML.

*element* is an optional root element node,

*file* is an optional file handle or file name of an XML file whose

contents will be used to initialize the tree with.

"""

def __init__(self, element=None, file=None):

if element is not None and not iselement(element):

raise TypeError('expected an Element, not %s' %

type(element).__name__)

self._root = element # first node

if file:

self.parse(file)

def getroot(self):

"""Return root element of this tree."""

return self._root

def _setroot(self, element):

"""Replace root element of this tree.

This will discard the current contents of the tree and replace it

with the given element. Use with care!

"""

if not iselement(element):

raise TypeError('expected an Element, not %s'

% type(element).__name__)

self._root = element

def parse(self, source, parser=None):

"""Load external XML document into element tree.

*source* is a file name or file object, *parser* is an optional parser

instance that defaults to XMLParser.

ParseError is raised if the parser fails to parse the document.

Returns the root element of the given source document.

"""

close_source = False

if not hasattr(source, "read"):

source = open(source, "rb")

close_source = True

try:

if parser is None:

# If no parser was specified, create a default XMLParser

parser = XMLParser()

if hasattr(parser, '_parse_whole'):

# The default XMLParser, when it comes from an accelerator,

# can define an internal _parse_whole API for efficiency.

# It can be used to parse the whole source without feeding

# it with chunks.

self._root = parser._parse_whole(source)

return self._root

while data := source.read(65536):

parser.feed(data)

self._root = parser.close()

return self._root

finally:

if close_source:

source.close()

def iter(self, tag=None):

"""Create and return tree iterator for the root element.

The iterator loops over all elements in this tree, in document order.

*tag* is a string with the tag name to iterate over

(default is to return all elements).

"""

# assert self._root is not None

return self._root.iter(tag)

def find(self, path, namespaces=None):

"""Find first matching element by tag name or path.

Same as getroot().find(path), which is Element.find()

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return the first matching element, or None if no element was found.

"""

# assert self._root is not None

if path[:1] == "/":

path = "." + path

warnings.warn(

"This search is broken in 1.3 and earlier, and will be "

"fixed in a future version. If you rely on the current "

"behaviour, change it to %r" % path,

FutureWarning, stacklevel=2

)

return self._root.find(path, namespaces)

def findtext(self, path, default=None, namespaces=None):

"""Find first matching element by tag name or path.

Same as getroot().findtext(path), which is Element.findtext()

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return the first matching element, or None if no element was found.

"""

# assert self._root is not None

if path[:1] == "/":

path = "." + path

warnings.warn(

"This search is broken in 1.3 and earlier, and will be "

"fixed in a future version. If you rely on the current "

"behaviour, change it to %r" % path,

FutureWarning, stacklevel=2

)

return self._root.findtext(path, default, namespaces)

def findall(self, path, namespaces=None):

"""Find all matching subelements by tag name or path.

Same as getroot().findall(path), which is Element.findall().

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return list containing all matching elements in document order.

"""

# assert self._root is not None

if path[:1] == "/":

path = "." + path

warnings.warn(

"This search is broken in 1.3 and earlier, and will be "

"fixed in a future version. If you rely on the current "

"behaviour, change it to %r" % path,

FutureWarning, stacklevel=2

)

return self._root.findall(path, namespaces)

def iterfind(self, path, namespaces=None):

"""Find all matching subelements by tag name or path.

Same as getroot().iterfind(path), which is element.iterfind()

*path* is a string having either an element tag or an XPath,

*namespaces* is an optional mapping from namespace prefix to full name.

Return an iterable yielding all matching elements in document order.

"""

# assert self._root is not None

if path[:1] == "/":

path = "." + path

warnings.warn(

"This search is broken in 1.3 and earlier, and will be "

"fixed in a future version. If you rely on the current "

"behaviour, change it to %r" % path,

FutureWarning, stacklevel=2

)

return self._root.iterfind(path, namespaces)

def write(self, file_or_filename,

encoding=None,

xml_declaration=None,

default_namespace=None,

method=None, *,

short_empty_elements=True):

"""Write element tree to a file as XML.

Arguments:

*file_or_filename* -- file name or a file object opened for writing

*encoding* -- the output encoding (default: US-ASCII)

*xml_declaration* -- bool indicating if an XML declaration should be

added to the output. If None, an XML declaration

is added if encoding IS NOT either of:

US-ASCII, UTF-8, or Unicode

*default_namespace* -- sets the default XML namespace (for "xmlns")

*method* -- either "xml" (default), "html, "text", or "c14n"

*short_empty_elements* -- controls the formatting of elements

that contain no content. If True (default)

they are emitted as a single self-closed

tag, otherwise they are emitted as a pair

of start/end tags

"""

if self._root is None:

raise TypeError('ElementTree not initialized')

if not method:

method = "xml"

elif method not in _serialize:

raise ValueError("unknown method %r" % method)

if not encoding:

if method == "c14n":

encoding = "utf-8"

else:

encoding = "us-ascii"

with _get_writer(file_or_filename, encoding) as (write, declared_encoding):

if method == "xml" and (xml_declaration or

(xml_declaration is None and

encoding.lower() != "unicode" and

declared_encoding.lower() not in ("utf-8", "us-ascii"))):

write("<?xml version='1.0' encoding='%s'?>\n" % (

declared_encoding,))

if method == "text":

_serialize_text(write, self._root)

else:

qnames, namespaces = _namespaces(self._root, default_namespace)

serialize = _serialize[method]

serialize(write, self._root, qnames, namespaces,

short_empty_elements=short_empty_elements)

def write_c14n(self, file):

# lxml.etree compatibility. use output method instead

return self.write(file, method="c14n")

# --------------------------------------------------------------------

# serialization support

@contextlib.contextmanager

def _get_writer(file_or_filename, encoding):

# returns text write method and release all resources after using

try:

write = file_or_filename.write

except AttributeError:

# file_or_filename is a file name

if encoding.lower() == "unicode":

encoding="utf-8"

with open(file_or_filename, "w", encoding=encoding,

errors="xmlcharrefreplace") as file:

yield file.write, encoding

else:

# file_or_filename is a file-like object

# encoding determines if it is a text or binary writer

if encoding.lower() == "unicode":

# use a text writer as is

yield write, getattr(file_or_filename, "encoding", None) or "utf-8"

else:

# wrap a binary writer with TextIOWrapper

with contextlib.ExitStack() as stack:

if isinstance(file_or_filename, io.BufferedIOBase):

file = file_or_filename

elif isinstance(file_or_filename, io.RawIOBase):

file = io.BufferedWriter(file_or_filename)

# Keep the original file open when the BufferedWriter is

# destroyed

stack.callback(file.detach)

else:

# This is to handle passed objects that aren't in the

# IOBase hierarchy, but just have a write method

file = io.BufferedIOBase()

file.writable = lambda: True

file.write = write

try:

# TextIOWrapper uses this methods to determine

# if BOM (for UTF-16, etc) should be added

file.seekable = file_or_filename.seekable

file.tell = file_or_filename.tell

except AttributeError:

pass

file = io.TextIOWrapper(file,

encoding=encoding,

errors="xmlcharrefreplace",

newline="\n")

# Keep the original file open when the TextIOWrapper is

# destroyed

stack.callback(file.detach)

yield file.write, encoding

def _namespaces(elem, default_namespace=None):

# identify namespaces used in this tree

# maps qnames to *encoded* prefix:local names

qnames = {None: None}

# maps uri:s to prefixes

namespaces = {}

if default_namespace:

namespaces[default_namespace] = ""

def add_qname(qname):

# calculate serialized qname representation

try:

if qname[:1] == "{":

uri, tag = qname[1:].rsplit("}", 1)

prefix = namespaces.get(uri)

if prefix is None:

prefix = _namespace_map.get(uri)

if prefix is None:

prefix = "ns%d" % len(namespaces)

if prefix != "xml":

namespaces[uri] = prefix

if prefix:

qnames[qname] = "%s:%s" % (prefix, tag)

else:

qnames[qname] = tag # default element

else:

if default_namespace:

# FIXME: can this be handled in XML 1.0?

raise ValueError(

"cannot use non-qualified names with "

"default_namespace option"

)

qnames[qname] = qname

except TypeError:

_raise_serialization_error(qname)

# populate qname and namespaces table

for elem in elem.iter():

tag = elem.tag

if isinstance(tag, QName):

if tag.text not in qnames:

add_qname(tag.text)

elif isinstance(tag, str):

if tag not in qnames:

add_qname(tag)

elif tag is not None and tag is not Comment and tag is not PI:

_raise_serialization_error(tag)

for key, value in elem.items():

if isinstance(key, QName):

key = key.text

if key not in qnames:

add_qname(key)

if isinstance(value, QName) and value.text not in qnames:

add_qname(value.text)

text = elem.text

if isinstance(text, QName) and text.text not in qnames:

add_qname(text.text)

return qnames, namespaces

def _serialize_xml(write, elem, qnames, namespaces,

short_empty_elements, **kwargs):

tag = elem.tag

text = elem.text

if tag is Comment:

write("<!--%s-->" % text)

elif tag is ProcessingInstruction:

write("<?%s?>" % text)

else:

tag = qnames[tag]

if tag is None:

if text:

write(_escape_cdata(text))

for e in elem:

_serialize_xml(write, e, qnames, None,

short_empty_elements=short_empty_elements)

else:

write("<" + tag)

items = list(elem.items())

if items or namespaces:

if namespaces:

for v, k in sorted(namespaces.items(),

key=lambda x: x[1]): # sort on prefix

if k:

k = ":" + k

write(" xmlns%s=\"%s\"" % (

k,

_escape_attrib(v)

))

for k, v in items:

if isinstance(k, QName):

k = k.text

if isinstance(v, QName):

v = qnames[v.text]

else:

v = _escape_attrib(v)

write(" %s=\"%s\"" % (qnames[k], v))

if text or len(elem) or not short_empty_elements:

write(">")

if text:

write(_escape_cdata(text))

for e in elem:

_serialize_xml(write, e, qnames, None,

short_empty_elements=short_empty_elements)

write("</" + tag + ">")

else:

write(" />")

if elem.tail:

write(_escape_cdata(elem.tail))

HTML_EMPTY = {"area", "base", "basefont", "br", "col", "embed", "frame", "hr",

"img", "input", "isindex", "link", "meta", "param", "source",

"track", "wbr"}

def _serialize_html(write, elem, qnames, namespaces, **kwargs):

tag = elem.tag

text = elem.text

if tag is Comment:

write("<!--%s-->" % _escape_cdata(text))

elif tag is ProcessingInstruction:

write("<?%s?>" % _escape_cdata(text))

else:

tag = qnames[tag]

if tag is None:

if text:

write(_escape_cdata(text))

for e in elem:

_serialize_html(write, e, qnames, None)

else:

write("<" + tag)

items = list(elem.items())

if items or namespaces:

if namespaces:

for v, k in sorted(namespaces.items(),

key=lambda x: x[1]): # sort on prefix

if k:

k = ":" + k

write(" xmlns%s=\"%s\"" % (

k,

_escape_attrib(v)

))

for k, v in items:

if isinstance(k, QName):

k = k.text

if isinstance(v, QName):

v = qnames[v.text]

else:

v = _escape_attrib_html(v)

# FIXME: handle boolean attributes

write(" %s=\"%s\"" % (qnames[k], v))

write(">")

ltag = tag.lower()

if text:

if ltag == "script" or ltag == "style":

write(text)

else:

write(_escape_cdata(text))

for e in elem:

_serialize_html(write, e, qnames, None)

if ltag not in HTML_EMPTY:

write("</" + tag + ">")

if elem.tail:

write(_escape_cdata(elem.tail))

def _serialize_text(write, elem):

for part in elem.itertext():

write(part)

if elem.tail:

write(elem.tail)

_serialize = {

"xml": _serialize_xml,

"html": _serialize_html,

"text": _serialize_text,

# this optional method is imported at the end of the module

# "c14n": _serialize_c14n,

}

def register_namespace(prefix, uri):

"""Register a namespace prefix.

The registry is global, and any existing mapping for either the

given prefix or the namespace URI will be removed.

*prefix* is the namespace prefix, *uri* is a namespace uri. Tags and

attributes in this namespace will be serialized with prefix if possible.

ValueError is raised if prefix is reserved or is invalid.

"""

if re.match(r"ns\d+$", prefix):

raise ValueError("Prefix format reserved for internal use")

for k, v in list(_namespace_map.items()):

if k == uri or v == prefix:

del _namespace_map[k]

_namespace_map[uri] = prefix

_namespace_map = {

# "well-known" namespace prefixes

"http://www.w3.org/XML/1998/namespace": "xml",