# encoding: utf-8
# module lxml.etree
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\lxml\etree.cp311-win_amd64.pyd
# by generator 1.147
""" The ``lxml.etree`` module implements the extended ElementTree API for XML. """

# imports
import builtins as __builtins__ # <module 'builtins' (built-in)>

from .object import object

class _ElementTree(object):
    # no doc
    def find(self, path, namespaces=None): # real signature unknown; restored from __doc__
        """
        find(self, path, namespaces=None)
        
                Finds the first toplevel element with given tag.  Same as
                ``tree.getroot().find(path)``.
        
                The optional ``namespaces`` argument accepts a
                prefix-to-namespace mapping that allows the usage of XPath
                prefixes in the path expression.
        """
        pass

    def findall(self, path, namespaces=None): # real signature unknown; restored from __doc__
        """
        findall(self, path, namespaces=None)
        
                Finds all elements matching the ElementPath expression.  Same as
                getroot().findall(path).
        
                The optional ``namespaces`` argument accepts a
                prefix-to-namespace mapping that allows the usage of XPath
                prefixes in the path expression.
        """
        pass

    def findtext(self, path, default=None, namespaces=None): # real signature unknown; restored from __doc__
        """
        findtext(self, path, default=None, namespaces=None)
        
                Finds the text for the first element matching the ElementPath
                expression.  Same as getroot().findtext(path)
        
                The optional ``namespaces`` argument accepts a
                prefix-to-namespace mapping that allows the usage of XPath
                prefixes in the path expression.
        """
        pass

    def getelementpath(self, element): # real signature unknown; restored from __doc__
        """
        getelementpath(self, element)
        
                Returns a structural, absolute ElementPath expression to find the
                element.  This path can be used in the .find() method to look up
                the element, provided that the elements along the path and their
                list of immediate children were not modified in between.
        
                ElementPath has the advantage over an XPath expression (as returned
                by the .getpath() method) that it does not require additional prefix
                declarations.  It is always self-contained.
        """
        pass

    def getiterator(self, *tags, tag=None): # real signature unknown; restored from __doc__
        """
        getiterator(self, *tags, tag=None)
        
                Returns a sequence or iterator of all elements in document order
                (depth first pre-order), starting with the root element.
        
                Can be restricted to find only elements with specific tags,
                see `_Element.iter`.
        
                :deprecated: Note that this method is deprecated as of
                  ElementTree 1.3 and lxml 2.0.  It returns an iterator in
                  lxml, which diverges from the original ElementTree
                  behaviour.  If you want an efficient iterator, use the
                  ``tree.iter()`` method instead.  You should only use this
                  method in new code if you require backwards compatibility
                  with older versions of lxml or ElementTree.
        """
        pass

    def getpath(self, element): # real signature unknown; restored from __doc__
        """
        getpath(self, element)
        
                Returns a structural, absolute XPath expression to find the element.
        
                For namespaced elements, the expression uses prefixes from the
                document, which therefore need to be provided in order to make any
                use of the expression in XPath.
        
                Also see the method getelementpath(self, element), which returns a
                self-contained ElementPath expression.
        """
        pass

    def getroot(self): # real signature unknown; restored from __doc__
        """
        getroot(self)
        
                Gets the root element for this tree.
        """
        pass

    def iter(self, tag=None, *tags): # real signature unknown; restored from __doc__
        """
        iter(self, tag=None, *tags)
        
                Creates an iterator for the root element.  The iterator loops over
                all elements in this tree, in document order.  Note that siblings
                of the root element (comments or processing instructions) are not
                returned by the iterator.
        
                Can be restricted to find only elements with specific tags,
                see `_Element.iter`.
        """
        pass

    def iterfind(self, path, namespaces=None): # real signature unknown; restored from __doc__
        """
        iterfind(self, path, namespaces=None)
        
                Iterates over all elements matching the ElementPath expression.
                Same as getroot().iterfind(path).
        
                The optional ``namespaces`` argument accepts a
                prefix-to-namespace mapping that allows the usage of XPath
                prefixes in the path expression.
        """
        pass

    def parse(self, source, parser=None, base_url=None): # real signature unknown; restored from __doc__
        """
        parse(self, source, parser=None, base_url=None)
        
                Updates self with the content of source and returns its root.
        """
        pass

    def relaxng(self, relaxng): # real signature unknown; restored from __doc__
        """
        relaxng(self, relaxng)
        
                Validate this document using other document.
        
                The relaxng argument is a tree that should contain a Relax NG schema.
        
                Returns True or False, depending on whether validation
                succeeded.
        
                Note: if you are going to apply the same Relax NG schema against
                multiple documents, it is more efficient to use the RelaxNG
                class directly.
        """
        pass

    def write(self, file, encoding=None, method="xml", pretty_print=False, xml_declaration=None, with_tail=True, standalone=None, doctype=None, compression=0, exclusive=False, inclusive_ns_prefixes=None, with_comments=True, strip_text=False): # real signature unknown; restored from __doc__
        """
        write(self, file, encoding=None, method="xml",
                          pretty_print=False, xml_declaration=None, with_tail=True,
                          standalone=None, doctype=None, compression=0,
                          exclusive=False, inclusive_ns_prefixes=None,
                          with_comments=True, strip_text=False)
        
                Write the tree to a filename, file or file-like object.
        
                Defaults to ASCII encoding and writing a declaration as needed.
        
                The keyword argument 'method' selects the output method:
                'xml', 'html', 'text' or 'c14n'.  Default is 'xml'.
        
                With ``method="c14n"`` (C14N version 1), the options ``exclusive``,
                ``with_comments`` and ``inclusive_ns_prefixes`` request exclusive
                C14N, include comments, and list the inclusive prefixes respectively.
        
                With ``method="c14n2"`` (C14N version 2), the ``with_comments`` and
                ``strip_text`` options control the output of comments and text space
                according to C14N 2.0.
        
                Passing a boolean value to the ``standalone`` option will
                output an XML declaration with the corresponding
                ``standalone`` flag.
        
                The ``doctype`` option allows passing in a plain string that will
                be serialised before the XML tree.  Note that passing in non
                well-formed content here will make the XML output non well-formed.
                Also, an existing doctype in the document tree will not be removed
                when serialising an ElementTree instance.
        
                The ``compression`` option enables GZip compression level 1-9.
        
                The ``inclusive_ns_prefixes`` should be a list of namespace strings
                (i.e. ['xs', 'xsi']) that will be promoted to the top-level element
                during exclusive C14N serialisation.  This parameter is ignored if
                exclusive mode=False.
        
                If exclusive=True and no list is provided, a namespace will only be
                rendered if it is used by the immediate parent or one of its attributes
                and its prefix and values have not already been rendered by an ancestor
                of the namespace node's parent element.
        """
        pass

    def write_c14n(self, file, exclusive=False, with_comments=True, compression=0, inclusive_ns_prefixes=None): # real signature unknown; restored from __doc__
        """
        write_c14n(self, file, exclusive=False, with_comments=True,
                               compression=0, inclusive_ns_prefixes=None)
        
                C14N write of document. Always writes UTF-8.
        
                The ``compression`` option enables GZip compression level 1-9.
        
                The ``inclusive_ns_prefixes`` should be a list of namespace strings
                (i.e. ['xs', 'xsi']) that will be promoted to the top-level element
                during exclusive C14N serialisation.  This parameter is ignored if
                exclusive mode=False.
        
                If exclusive=True and no list is provided, a namespace will only be
                rendered if it is used by the immediate parent or one of its attributes
                and its prefix and values have not already been rendered by an ancestor
                of the namespace node's parent element.
        
                NOTE: This method is deprecated as of lxml 4.4 and will be removed in a
                future release.  Use ``.write(f, method="c14n")`` instead.
        """
        pass

    def xinclude(self): # real signature unknown; restored from __doc__
        """
        xinclude(self)
        
                Process the XInclude nodes in this document and include the
                referenced XML fragments.
        
                There is support for loading files through the file system, HTTP and
                FTP.
        
                Note that XInclude does not support custom resolvers in Python space
                due to restrictions of libxml2 <= 2.6.29.
        """
        pass

    def xmlschema(self, xmlschema): # real signature unknown; restored from __doc__
        """
        xmlschema(self, xmlschema)
        
                Validate this document using other document.
        
                The xmlschema argument is a tree that should contain an XML Schema.
        
                Returns True or False, depending on whether validation
                succeeded.
        
                Note: If you are going to apply the same XML Schema against
                multiple documents, it is more efficient to use the XMLSchema
                class directly.
        """
        pass

    def xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables): # real signature unknown; restored from __doc__
        """
        xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables)
        
                XPath evaluate in context of document.
        
                ``namespaces`` is an optional dictionary with prefix to namespace URI
                mappings, used by XPath.  ``extensions`` defines additional extension
                functions.
        
                Returns a list (nodeset), or bool, float or string.
        
                In case of a list result, return Element for element nodes,
                string for text and attribute values.
        
                Note: if you are going to apply multiple XPath expressions
                against the same document, it is more efficient to use
                XPathEvaluator directly.
        """
        pass

    def xslt(self, _xslt, extensions=None, access_control=None, **_kw): # real signature unknown; restored from __doc__
        """
        xslt(self, _xslt, extensions=None, access_control=None, **_kw)
        
                Transform this document using other document.
        
                xslt is a tree that should be XSLT
                keyword parameters are XSLT transformation parameters.
        
                Returns the transformed tree.
        
                Note: if you are going to apply the same XSLT stylesheet against
                multiple documents, it is more efficient to use the XSLT
                class directly.
        """
        pass

    def _setroot(self, root): # real signature unknown; restored from __doc__
        """
        _setroot(self, root)
        
                Relocate the ElementTree to a new root node.
        """
        pass

    def __copy__(self, *args, **kwargs): # real signature unknown
        pass

    def __deepcopy__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    docinfo = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Information about the document provided by parser and DTD."""

    parser = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """The parser that was used to parse the document in this ElementTree.
        """


    __pyx_vtable__ = None # (!) real value is '<capsule object NULL at 0x000001A5B8BF0F60>'