lxml 5.4.0__cp310-cp310-macosx_10_9_universal2.whl → 6.0.0__cp310-cp310-macosx_10_9_universal2.whl

lxml/saxparser.pxi

@@ -217,7 +217,7 @@ cdef class _SaxParserContext(_ParserContext):
         finally:
             self._parser = None  # clear circular reference ASAP
         if self._matcher is not None:
-            self._matcher.cacheTags(self._doc, True) # force entry in libxml2 dict
+            self._matcher.cacheTags(self._doc, force_into_dict=True)
         return 0
 
     cdef int pushEvent(self, event, xmlNode* c_node) except -1:
@@ -297,7 +297,7 @@ cdef void _handleSaxStart(
     cdef int i
     cdef size_t c_len
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     cdef int event_filter = context._event_filter
@@ -345,7 +345,7 @@ cdef void _handleSaxTargetStart(
     cdef int i
     cdef size_t c_len
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
 
@@ -411,7 +411,7 @@ cdef void _handleSaxTargetStart(
 cdef void _handleSaxStartNoNs(void* ctxt, const_xmlChar* c_name,
                               const_xmlChar** c_attributes) noexcept with gil:
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -436,7 +436,7 @@ cdef void _handleSaxStartNoNs(void* ctxt, const_xmlChar* c_name,
 cdef void _handleSaxTargetStartNoNs(void* ctxt, const_xmlChar* c_name,
                                     const_xmlChar** c_attributes) noexcept with gil:
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -493,7 +493,7 @@ cdef void _handleSaxEnd(void* ctxt, const_xmlChar* c_localname,
                         const_xmlChar* c_prefix,
                         const_xmlChar* c_namespace) noexcept with gil:
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -516,7 +516,7 @@ cdef void _handleSaxEnd(void* ctxt, const_xmlChar* c_localname,
 
 cdef void _handleSaxEndNoNs(void* ctxt, const_xmlChar* c_name) noexcept with gil:
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -569,7 +569,7 @@ cdef int _pushSaxEndEvent(_SaxParserContext context,
 cdef void _handleSaxData(void* ctxt, const_xmlChar* c_data, int data_len) noexcept with gil:
     # can only be called if parsing with a target
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -586,7 +586,7 @@ cdef void _handleSaxTargetDoctype(void* ctxt, const_xmlChar* c_name,
                                   const_xmlChar* c_system) noexcept with gil:
     # can only be called if parsing with a target
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -602,7 +602,7 @@ cdef void _handleSaxTargetDoctype(void* ctxt, const_xmlChar* c_name,
 
 cdef void _handleSaxStartDocument(void* ctxt) noexcept with gil:
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     context._origSaxStartDocument(ctxt)
@@ -619,7 +619,7 @@ cdef void _handleSaxTargetPI(void* ctxt, const_xmlChar* c_target,
                              const_xmlChar* c_data) noexcept with gil:
     # can only be called if parsing with a target
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -638,7 +638,7 @@ cdef void _handleSaxPIEvent(void* ctxt, const_xmlChar* target,
                             const_xmlChar* data) noexcept with gil:
     # can only be called when collecting pi events
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     context._origSaxPI(ctxt, target, data)
@@ -656,7 +656,7 @@ cdef void _handleSaxPIEvent(void* ctxt, const_xmlChar* target,
 cdef void _handleSaxTargetComment(void* ctxt, const_xmlChar* c_data) noexcept with gil:
     # can only be called if parsing with a target
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     try:
@@ -672,7 +672,7 @@ cdef void _handleSaxTargetComment(void* ctxt, const_xmlChar* c_data) noexcept wi
 cdef void _handleSaxComment(void* ctxt, const_xmlChar* text) noexcept with gil:
     # can only be called when collecting comment events
     c_ctxt = <xmlparser.xmlParserCtxt*>ctxt
-    if c_ctxt._private is NULL or c_ctxt.disableSAX:
+    if c_ctxt._private is NULL or xmlparser.xmlCtxtIsStopped(c_ctxt):
         return
     context = <_SaxParserContext>c_ctxt._private
     context._origSaxComment(ctxt, text)

lxml/schematron.pxi

@@ -69,9 +69,6 @@ cdef class Schematron(_Validator):
     """
     cdef schematron.xmlSchematron* _c_schema
     cdef xmlDoc* _c_schema_doc
-    def __cinit__(self):
-        self._c_schema = NULL
-        self._c_schema_doc = NULL
 
     def __init__(self, etree=None, *, file=None):
         cdef _Document doc
@@ -83,6 +80,14 @@ cdef class Schematron(_Validator):
         if not config.ENABLE_SCHEMATRON:
             raise SchematronError, \
                 "lxml.etree was compiled without Schematron support."
+
+        import warnings
+        warnings.warn(
+            "The (non-ISO) Schematron feature is deprecated and will be removed from libxml2 and lxml. "
+            "Use 'lxml.isoschematron' instead.",
+            DeprecationWarning,
+        )
+
         if etree is not None:
             doc = _documentOrRaise(etree)
             root_node = _rootNodeOrRaise(etree)

lxml/serializer.pxi

@@ -476,6 +476,50 @@ cdef _write_attr_string(tree.xmlOutputBuffer* buf, const char *string):
         tree.xmlOutputBufferWrite(buf, cur - base, base)
 
 
+cdef void _write_cdata_section(tree.xmlOutputBuffer* buf, const char* c_data, const char* c_end):
+    tree.xmlOutputBufferWrite(buf, 9, "<![CDATA[")
+    while c_end - c_data > limits.INT_MAX:
+        tree.xmlOutputBufferWrite(buf, limits.INT_MAX, c_data)
+        c_data += limits.INT_MAX
+    tree.xmlOutputBufferWrite(buf, c_end - c_data, c_data)
+    tree.xmlOutputBufferWrite(buf, 3, "]]>")
+
+
+cdef _write_cdata_string(tree.xmlOutputBuffer* buf, bytes bstring):
+    cdef const char* c_data = bstring
+    cdef const char* c_end = c_data + len(bstring)
+    cdef const char* c_pos = c_data
+    cdef bint nothing_written = True
+
+    while True:
+        c_pos = <const char*> cstring_h.memchr(c_pos, b']', c_end - c_pos)
+        if not c_pos:
+            break
+        c_pos += 1
+        next_char = c_pos[0]
+        c_pos += 1
+        if next_char != b']':
+            continue
+        # Found ']]', c_pos points to next character.
+        while c_pos[0] == b']':
+            c_pos += 1
+        if c_pos[0] != b'>':
+            if c_pos == c_end:
+                break
+            # c_pos[0] is neither ']' nor '>', continue with next character.
+            c_pos += 1
+            continue
+
+        # Write section up to ']]' and start next block at trailing '>'.
+        _write_cdata_section(buf, c_data, c_pos)
+        nothing_written = False
+        c_data = c_pos
+        c_pos += 1
+
+    if nothing_written or c_data < c_end:
+        _write_cdata_section(buf, c_data, c_end)
+
+
 ############################################################
 # output to file-like objects
 
@@ -519,6 +563,7 @@ cdef class _FilelikeWriter:
     cdef object _close_filelike
     cdef _ExceptionContext _exc_context
     cdef _ErrorLog error_log
+
     def __cinit__(self, filelike, exc_context=None, compression=None, close=False):
         if compression is not None and compression > 0:
             filelike = GzipFile(
@@ -659,6 +704,12 @@ cdef _FilelikeWriter _create_output_buffer(
             f"unknown encoding: '{c_enc.decode('UTF-8') if c_enc is not NULL else u''}'")
     try:
         f = _getFSPathOrObject(f)
+
+        if c_compression and not HAS_ZLIB_COMPRESSION and _isString(f):
+            # Let "_FilelikeWriter" fall back to Python's GzipFile.
+            f = open(f, mode="wb")
+            close = True
+
         if _isString(f):
             filename8 = _encodeFilename(f)
             if b'%' in filename8 and (
@@ -695,7 +746,10 @@ cdef xmlChar **_convert_ns_prefixes(tree.xmlDict* c_dict, ns_prefixes) except NU
     try:
         for prefix in ns_prefixes:
              prefix_utf = _utf8(prefix)
-             c_prefix = tree.xmlDictExists(c_dict, _xcstr(prefix_utf), len(prefix_utf))
+             c_prefix_len = len(prefix_utf)
+             if c_prefix_len > limits.INT_MAX:
+                raise ValueError("Prefix too long")
+             c_prefix = tree.xmlDictExists(c_dict, _xcstr(prefix_utf), <int> c_prefix_len)
              if c_prefix:
                  # unknown prefixes do not need to get serialised
                  c_ns_prefixes[i] = <xmlChar*>c_prefix
@@ -725,6 +779,13 @@ cdef _tofilelikeC14N(f, _Element element, bint exclusive, bint with_comments,
             if inclusive_ns_prefixes else NULL)
 
         f = _getFSPathOrObject(f)
+
+        close = False
+        if compression and not HAS_ZLIB_COMPRESSION and _isString(f):
+            # Let "_FilelikeWriter" fall back to Python's GzipFile.
+            f = open(f, mode="wb")
+            close = True
+
         if _isString(f):
             filename8 = _encodeFilename(f)
             c_filename = _cstr(filename8)
@@ -733,7 +794,7 @@ cdef _tofilelikeC14N(f, _Element element, bint exclusive, bint with_comments,
                     c_doc, NULL, exclusive, c_inclusive_ns_prefixes,
                     with_comments, c_filename, compression)
         elif hasattr(f, 'write'):
-            writer   = _FilelikeWriter(f, compression=compression)
+            writer   = _FilelikeWriter(f, compression=compression, close=close)
             c_buffer = writer._createOutputBuffer(NULL)
             try:
                 with writer.error_log:
@@ -1556,6 +1617,11 @@ cdef class _IncrementalFileWriter:
                 else:
                     tree.xmlOutputBufferWriteEscape(self._c_out, _xcstr(bstring), NULL)
 
+            elif isinstance(content, CDATA):
+                if self._status > WRITER_IN_ELEMENT:
+                    raise LxmlSyntaxError("not in an element")
+                _write_cdata_string(self._c_out, (<CDATA>content)._utf8_data)
+
             elif iselement(content):
                 if self._status > WRITER_IN_ELEMENT:
                     raise LxmlSyntaxError("cannot append trailing element to complete XML document")
@@ -1568,8 +1634,10 @@ cdef class _IncrementalFileWriter:
 
             elif content is not None:
                 raise TypeError(
-                    f"got invalid input value of type {type(content)}, expected string or Element")
+                    f"got invalid input value of type {type(content)}, expected string, CDATA or Element")
+
             self._handle_error(self._c_out.error)
+
         if not self._buffered:
             tree.xmlOutputBufferFlush(self._c_out)
             self._handle_error(self._c_out.error)

lxml/xslt.pxi

@@ -664,9 +664,16 @@ cdef _convert_xslt_parameters(xslt.xsltTransformContext* transform_ctxt,
                     v = (<XPath>value)._path
                 else:
                     v = _utf8(value)
-                params[i] = <const_char*>tree.xmlDictLookup(c_dict, _xcstr(k), len(k))
+
+                c_len = len(k)
+                if c_len > limits.INT_MAX:
+                    raise ValueError("Parameter name too long")
+                params[i] = <const_char*> tree.xmlDictLookup(c_dict, _xcstr(k), <int> c_len)
                 i += 1
-                params[i] = <const_char*>tree.xmlDictLookup(c_dict, _xcstr(v), len(v))
+                c_len = len(v)
+                if c_len > limits.INT_MAX:
+                    raise ValueError("Parameter value too long")
+                params[i] = <const_char*> tree.xmlDictLookup(c_dict, _xcstr(v), <int> c_len)
                 i += 1
     except:
         python.lxml_free(params)
@@ -732,7 +739,7 @@ cdef class _XSLTResultTree(_ElementTree):
                 raise XSLTSaveError("No document to serialise")
         c_compression = compression or 0
         xslt.LXML_GET_XSLT_ENCODING(c_encoding, self._xslt._c_style)
-        writer = _create_output_buffer(file, <const_char*>c_encoding, compression, &c_buffer, close=False)
+        writer = _create_output_buffer(file, <const_char*>c_encoding, c_compression, &c_buffer, close=False)
         if writer is None:
             with nogil:
                 r = xslt.xsltSaveResultTo(c_buffer, doc._c_doc, self._xslt._c_style)

lxml-6.0.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: lxml
+Version: 6.0.0
+Summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API.
+Home-page: https://lxml.de/
+Author: lxml dev team
+Author-email: lxml@lxml.de
+Maintainer: lxml dev team
+Maintainer-email: lxml@lxml.de
+License: BSD-3-Clause
+Project-URL: Source, https://github.com/lxml/lxml
+Project-URL: Bug Tracker, https://bugs.launchpad.net/lxml
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Topic :: Text Processing :: Markup :: XML
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+License-File: LICENSE.txt
+License-File: LICENSES.txt
+Provides-Extra: source
+Provides-Extra: cssselect
+Requires-Dist: cssselect>=0.7; extra == "cssselect"
+Provides-Extra: html5
+Requires-Dist: html5lib; extra == "html5"
+Provides-Extra: htmlsoup
+Requires-Dist: BeautifulSoup4; extra == "htmlsoup"
+Provides-Extra: html-clean
+Requires-Dist: lxml_html_clean; extra == "html-clean"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+lxml is a Pythonic, mature binding for the libxml2 and libxslt libraries.
+It provides safe and convenient access to these libraries using the
+ElementTree API.
+
+It extends the ElementTree API significantly to offer support for XPath,
+RelaxNG, XML Schema, XSLT, C14N and much more.
+
+To contact the project, go to the `project home page <https://lxml.de/>`_
+or see our bug tracker at https://launchpad.net/lxml
+
+In case you want to use the current in-development version of lxml,
+you can get it from the github repository at
+https://github.com/lxml/lxml .  Note that this requires Cython to
+build the sources, see the build instructions on the project home page.
+
+
+After an official release of a new stable series, bug fixes may become available at
+https://github.com/lxml/lxml/tree/lxml-6.0 .
+Running ``pip install https://github.com/lxml/lxml/archive/refs/heads/lxml-6.0.tar.gz``
+will install the unreleased branch state as soon as a maintenance branch has been established.
+Note that this requires Cython to be installed at an appropriate version for the build.
+
+6.0.0 (2025-06-26)
+==================
+
+Features added
+--------------
+
+* GH#463: ``lxml.html.diff`` is faster and provides structurally better diffs.
+  Original patch by Steven Fernandez.
+
+* GH#405: The factories ``Element`` and ``ElementTree`` can now be used in type hints.
+
+* GH#448: Parsing from ``memoryview`` and other buffers is supported to allow zero-copy parsing.
+
+* GH#437: ``lxml.html.builder`` was missing several HTML5 tag names.
+  Patch by Nick Tarleton.
+
+* GH#458: ``CDATA`` can now be written into the incremental ``xmlfile()`` writer.
+  Original patch by Lane Shaw.
+
+* A new parser option ``decompress=False`` was added that controls the automatic
+  input decompression when using libxml2 2.15.0 or later.  Disabling this option
+  by default will effectively prevent decompression bombs when handling untrusted
+  input.  Code that depends on automatic decompression must enable this option.
+  Note that libxml2 2.15.0 was not released yet, so this option currently has no
+  effect but can already be used.
+
+* The set of compile time / runtime supported libxml2 feature names is available as
+  ``etree.LIBXML_COMPILED_FEATURES`` and ``etree.LIBXML_FEATURES``.
+  This currently includes
+  ``catalog``, ``ftp``, ``html``, ``http``, ``iconv``, ``icu``,
+  ``lzma``, ``regexp``, ``schematron``, ``xmlschema``, ``xpath``, ``zlib``.
+
+Bugs fixed
+----------
+
+* GH#353: Predicates in ``.find*()`` could mishandle tag indices if a default namespace is provided.
+  Original patch by Luise K.
+
+* GH#272: The ``head`` and ``body`` properties of ``lxml.html`` elements failed if no such element
+  was found.  They now return ``None`` instead.
+  Original patch by FVolral.
+
+* Tag names provided by code (API, not data) that are longer than ``INT_MAX``
+  could be truncated or mishandled in other ways.
+
+* ``.text_content()`` on ``lxml.html`` elements accidentally returned a "smart string"
+  without additional information.  It now returns a plain string.
+
+* LP#2109931: When building lxml with coverage reporting, it now disables the ``sys.monitoring``
+  support due to the lack of support in https://github.com/nedbat/coveragepy/issues/1790
+
+Other changes
+-------------
+
+* Support for Python < 3.8 was removed.
+
+* Parsing directly from zlib (or lzma) compressed data is now considered an optional
+  feature in lxml.  It may get removed from libxml2 at some point for security reasons
+  (compression bombs) and is therefore no longer guaranteed to be available in lxml.
+
+  As of this release, zlib support is still normally available in the binary wheels
+  but may get disabled or removed in later (x.y.0) releases.  To test the availability,
+  use ``"zlib" in etree.LIBXML_FEATURES``.
+
+* The ``Schematron`` class is deprecated and will become non-functional in a future lxml version.
+  The feature will soon be removed from libxml2 and stop being available.
+
+* GH#438: Wheels include the ``arm7l`` target.
+
+* GH#465: Windows wheels include the ``arm64`` target.
+  Patch by Finn Womack.
+
+* Binary wheels use the library versions libxml2 2.14.4 and libxslt 1.1.43.
+  Note that this disables direct HTTP and FTP support for parsing from URLs.
+  Use Python URL request tools instead (which usually also support HTTPS).
+  To test the availability, use ``"http" in etree.LIBXML_FEATURES``.
+
+* Windows binary wheels use the library versions libxml2 2.11.9, libxslt 1.1.39 and libiconv 1.17.
+  They are now based on VS-2022.
+
+* Built using Cython 3.1.2.
+
+* The debug methods ``MemDebug.dump()`` and ``MemDebug.show()`` were removed completely.
+  libxml2 2.13.0 discarded this feature.
+
+