<h2>Editing File: /lib64/python3.12/xml/dom/xmlbuilder.py</h2><form method='post'><textarea name='content' class='file-edit'>&quot;&quot;&quot;Implementation of the DOM Level 3 'LS-Load' feature.&quot;&quot;&quot;

import copy
import xml.dom

from xml.dom.NodeFilter import NodeFilter


__all__ = [&quot;DOMBuilder&quot;, &quot;DOMEntityResolver&quot;, &quot;DOMInputSource&quot;]


class Options:
    &quot;&quot;&quot;Features object that has variables set for each DOMBuilder feature.

    The DOMBuilder class uses an instance of this class to pass settings to
    the ExpatBuilder class.
    &quot;&quot;&quot;

    # Note that the DOMBuilder class in LoadSave constrains which of these
    # values can be set using the DOM Level 3 LoadSave feature.

    namespaces = 1
    namespace_declarations = True
    validation = False
    external_parameter_entities = True
    external_general_entities = True
    external_dtd_subset = True
    validate_if_schema = False
    validate = False
    datatype_normalization = False
    create_entity_ref_nodes = True
    entities = True
    whitespace_in_element_content = True
    cdata_sections = True
    comments = True
    charset_overrides_xml_encoding = True
    infoset = False
    supported_mediatypes_only = False

    errorHandler = None
    filter = None


class DOMBuilder:
    entityResolver = None
    errorHandler = None
    filter = None

    ACTION_REPLACE = 1
    ACTION_APPEND_AS_CHILDREN = 2
    ACTION_INSERT_AFTER = 3
    ACTION_INSERT_BEFORE = 4

    _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN,
                      ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)

    def __init__(self):
        self._options = Options()

    def _get_entityResolver(self):
        return self.entityResolver
    def _set_entityResolver(self, entityResolver):
        self.entityResolver = entityResolver

    def _get_errorHandler(self):
        return self.errorHandler
    def _set_errorHandler(self, errorHandler):
        self.errorHandler = errorHandler

    def _get_filter(self):
        return self.filter
    def _set_filter(self, filter):
        self.filter = filter

    def setFeature(self, name, state):
        if self.supportsFeature(name):
            state = state and 1 or 0
            try:
                settings = self._settings[(_name_xform(name), state)]
            except KeyError:
                raise xml.dom.NotSupportedErr(
                    &quot;unsupported feature: %r&quot; % (name,)) from None
            else:
                for name, value in settings:
                    setattr(self._options, name, value)
        else:
            raise xml.dom.NotFoundErr(&quot;unknown feature: &quot; + repr(name))

    def supportsFeature(self, name):
        return hasattr(self._options, _name_xform(name))

    def canSetFeature(self, name, state):
        key = (_name_xform(name), state and 1 or 0)
        return key in self._settings

    # This dictionary maps from (feature,value) to a list of
    # (option,value) pairs that should be set on the Options object.
    # If a (feature,value) setting is not in this dictionary, it is
    # not supported by the DOMBuilder.
    #
    _settings = {
        (&quot;namespace_declarations&quot;, 0): [
            (&quot;namespace_declarations&quot;, 0)],
        (&quot;namespace_declarations&quot;, 1): [
            (&quot;namespace_declarations&quot;, 1)],
        (&quot;validation&quot;, 0): [
            (&quot;validation&quot;, 0)],
        (&quot;external_general_entities&quot;, 0): [
            (&quot;external_general_entities&quot;, 0)],
        (&quot;external_general_entities&quot;, 1): [
            (&quot;external_general_entities&quot;, 1)],
        (&quot;external_parameter_entities&quot;, 0): [
            (&quot;external_parameter_entities&quot;, 0)],
        (&quot;external_parameter_entities&quot;, 1): [
            (&quot;external_parameter_entities&quot;, 1)],
        (&quot;validate_if_schema&quot;, 0): [
            (&quot;validate_if_schema&quot;, 0)],
        (&quot;create_entity_ref_nodes&quot;, 0): [
            (&quot;create_entity_ref_nodes&quot;, 0)],
        (&quot;create_entity_ref_nodes&quot;, 1): [
            (&quot;create_entity_ref_nodes&quot;, 1)],
        (&quot;entities&quot;, 0): [
            (&quot;create_entity_ref_nodes&quot;, 0),
            (&quot;entities&quot;, 0)],
        (&quot;entities&quot;, 1): [
            (&quot;entities&quot;, 1)],
        (&quot;whitespace_in_element_content&quot;, 0): [
            (&quot;whitespace_in_element_content&quot;, 0)],
        (&quot;whitespace_in_element_content&quot;, 1): [
            (&quot;whitespace_in_element_content&quot;, 1)],
        (&quot;cdata_sections&quot;, 0): [
            (&quot;cdata_sections&quot;, 0)],
        (&quot;cdata_sections&quot;, 1): [
            (&quot;cdata_sections&quot;, 1)],
        (&quot;comments&quot;, 0): [
            (&quot;comments&quot;, 0)],
        (&quot;comments&quot;, 1): [
            (&quot;comments&quot;, 1)],
        (&quot;charset_overrides_xml_encoding&quot;, 0): [
            (&quot;charset_overrides_xml_encoding&quot;, 0)],
        (&quot;charset_overrides_xml_encoding&quot;, 1): [
            (&quot;charset_overrides_xml_encoding&quot;, 1)],
        (&quot;infoset&quot;, 0): [],
        (&quot;infoset&quot;, 1): [
            (&quot;namespace_declarations&quot;, 0),
            (&quot;validate_if_schema&quot;, 0),
            (&quot;create_entity_ref_nodes&quot;, 0),
            (&quot;entities&quot;, 0),
            (&quot;cdata_sections&quot;, 0),
            (&quot;datatype_normalization&quot;, 1),
            (&quot;whitespace_in_element_content&quot;, 1),
            (&quot;comments&quot;, 1),
            (&quot;charset_overrides_xml_encoding&quot;, 1)],
        (&quot;supported_mediatypes_only&quot;, 0): [
            (&quot;supported_mediatypes_only&quot;, 0)],
        (&quot;namespaces&quot;, 0): [
            (&quot;namespaces&quot;, 0)],
        (&quot;namespaces&quot;, 1): [
            (&quot;namespaces&quot;, 1)],
    }

    def getFeature(self, name):
        xname = _name_xform(name)
        try:
            return getattr(self._options, xname)
        except AttributeError:
            if name == &quot;infoset&quot;:
                options = self._options
                return (options.datatype_normalization
                        and options.whitespace_in_element_content
                        and options.comments
                        and options.charset_overrides_xml_encoding
                        and not (options.namespace_declarations
                                 or options.validate_if_schema
                                 or options.create_entity_ref_nodes
                                 or options.entities
                                 or options.cdata_sections))
            raise xml.dom.NotFoundErr(&quot;feature %s not known&quot; % repr(name))

    def parseURI(self, uri):
        if self.entityResolver:
            input = self.entityResolver.resolveEntity(None, uri)
        else:
            input = DOMEntityResolver().resolveEntity(None, uri)
        return self.parse(input)

    def parse(self, input):
        options = copy.copy(self._options)
        options.filter = self.filter
        options.errorHandler = self.errorHandler
        fp = input.byteStream
        if fp is None and input.systemId:
            import urllib.request
            fp = urllib.request.urlopen(input.systemId)
        return self._parse_bytestream(fp, options)

    def parseWithContext(self, input, cnode, action):
        if action not in self._legal_actions:
            raise ValueError(&quot;not a legal action&quot;)
        raise NotImplementedError(&quot;Haven't written this yet...&quot;)

    def _parse_bytestream(self, stream, options):
        import xml.dom.expatbuilder
        builder = xml.dom.expatbuilder.makeBuilder(options)
        return builder.parseFile(stream)


def _name_xform(name):
    return name.lower().replace('-', '_')


class DOMEntityResolver(object):
    __slots__ = '_opener',

    def resolveEntity(self, publicId, systemId):
        assert systemId is not None
        source = DOMInputSource()
        source.publicId = publicId
        source.systemId = systemId
        source.byteStream = self._get_opener().open(systemId)

        # determine the encoding if the transport provided it
        source.encoding = self._guess_media_encoding(source)

        # determine the base URI is we can
        import posixpath, urllib.parse
        parts = urllib.parse.urlparse(systemId)
        scheme, netloc, path, params, query, fragment = parts
        # XXX should we check the scheme here as well?
        if path and not path.endswith(&quot;/&quot;):
            path = posixpath.dirname(path) + &quot;/&quot;
            parts = scheme, netloc, path, params, query, fragment
            source.baseURI = urllib.parse.urlunparse(parts)

        return source

    def _get_opener(self):
        try:
            return self._opener
        except AttributeError:
            self._opener = self._create_opener()
            return self._opener

    def _create_opener(self):
        import urllib.request
        return urllib.request.build_opener()

    def _guess_media_encoding(self, source):
        info = source.byteStream.info()
        # import email.message
        # assert isinstance(info, email.message.Message)
        charset = info.get_param('charset')
        if charset is not None:
            return charset.lower()
        return None


class DOMInputSource(object):
    __slots__ = ('byteStream', 'characterStream', 'stringData',
                 'encoding', 'publicId', 'systemId', 'baseURI')

    def __init__(self):
        self.byteStream = None
        self.characterStream = None
        self.stringData = None
        self.encoding = None
        self.publicId = None
        self.systemId = None
        self.baseURI = None

    def _get_byteStream(self):
        return self.byteStream
    def _set_byteStream(self, byteStream):
        self.byteStream = byteStream

    def _get_characterStream(self):
        return self.characterStream
    def _set_characterStream(self, characterStream):
        self.characterStream = characterStream

    def _get_stringData(self):
        return self.stringData
    def _set_stringData(self, data):
        self.stringData = data

    def _get_encoding(self):
        return self.encoding
    def _set_encoding(self, encoding):
        self.encoding = encoding

    def _get_publicId(self):
        return self.publicId
    def _set_publicId(self, publicId):
        self.publicId = publicId

    def _get_systemId(self):
        return self.systemId
    def _set_systemId(self, systemId):
        self.systemId = systemId

    def _get_baseURI(self):
        return self.baseURI
    def _set_baseURI(self, uri):
        self.baseURI = uri


class DOMBuilderFilter:
    &quot;&quot;&quot;Element filter which can be used to tailor construction of
    a DOM instance.
    &quot;&quot;&quot;

    # There's really no need for this class; concrete implementations
    # should just implement the endElement() and startElement()
    # methods as appropriate.  Using this makes it easy to only
    # implement one of them.

    FILTER_ACCEPT = 1
    FILTER_REJECT = 2
    FILTER_SKIP = 3
    FILTER_INTERRUPT = 4

    whatToShow = NodeFilter.SHOW_ALL

    def _get_whatToShow(self):
        return self.whatToShow

    def acceptNode(self, element):
        return self.FILTER_ACCEPT

    def startContainer(self, element):
        return self.FILTER_ACCEPT

del NodeFilter


class DocumentLS:
    &quot;&quot;&quot;Mixin to create documents that conform to the load/save spec.&quot;&quot;&quot;

    async_ = False

    def _get_async(self):
        return False

    def _set_async(self, flag):
        if flag:
            raise xml.dom.NotSupportedErr(
                &quot;asynchronous document loading is not supported&quot;)

    def abort(self):
        # What does it mean to &quot;clear&quot; a document?  Does the
        # documentElement disappear?
        raise NotImplementedError(
            &quot;haven't figured out what this means yet&quot;)

    def load(self, uri):
        raise NotImplementedError(&quot;haven't written this yet&quot;)

    def loadXML(self, source):
        raise NotImplementedError(&quot;haven't written this yet&quot;)

    def saveXML(self, snode):
        if snode is None:
            snode = self
        elif snode.ownerDocument is not self:
            raise xml.dom.WrongDocumentErr()
        return snode.toxml()


class DOMImplementationLS:
    MODE_SYNCHRONOUS = 1
    MODE_ASYNCHRONOUS = 2

    def createDOMBuilder(self, mode, schemaType):
        if schemaType is not None:
            raise xml.dom.NotSupportedErr(
                &quot;schemaType not yet supported&quot;)
        if mode == self.MODE_SYNCHRONOUS:
            return DOMBuilder()
        if mode == self.MODE_ASYNCHRONOUS:
            raise xml.dom.NotSupportedErr(
                &quot;asynchronous builders are not supported&quot;)
        raise ValueError(&quot;unknown value for mode&quot;)

    def createDOMWriter(self):
        raise NotImplementedError(
            &quot;the writer interface hasn't been written yet!&quot;)

    def createDOMInputSource(self):
        return DOMInputSource()
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython3.12%2Fxml%2Fdom'>Back to Directory</a>