lxml 5.3.2__cp38-cp38-win32.whl → 6.0.0__cp38-cp38-win32.whl

lxml/parser.pxi

@@ -3,6 +3,14 @@
 from lxml.includes cimport xmlparser
 from lxml.includes cimport htmlparser
 
+cdef object _GenericAlias
+try:
+    from types import GenericAlias as _GenericAlias
+except ImportError:
+    # Python 3.8 - we only need this as return value from "__class_getitem__"
+    def _GenericAlias(cls, item):
+        return f"{cls.__name__}[{item.__name__}]"
+
 
 class ParseError(LxmlSyntaxError):
     """Syntax error while parsing an XML document.
@@ -53,7 +61,6 @@ cdef class _ParserDictionaryContext:
     cdef list _implied_parser_contexts
 
     def __cinit__(self):
-        self._c_dict = NULL
         self._implied_parser_contexts = []
 
     def __dealloc__(self):
@@ -295,9 +302,7 @@ cdef class _FileReaderContext:
         self._filelike = filelike
         self._close_file_after_read = close_file
         self._encoding = encoding
-        if url is None:
-            self._c_url = NULL
-        else:
+        if url is not None:
             url = _encodeFilename(url)
             self._c_url = _cstr(url)
         self._url = url
@@ -419,8 +424,6 @@ cdef class _FileReaderContext:
 cdef int _readFilelikeParser(void* ctxt, char* c_buffer, int c_size) noexcept with gil:
     return (<_FileReaderContext>ctxt).copyToBuffer(c_buffer, c_size)
 
-cdef int _readFileParser(void* ctxt, char* c_buffer, int c_size) noexcept nogil:
-    return stdio.fread(c_buffer, 1,  c_size, <stdio.FILE*>ctxt)
 
 ############################################################
 ## support for custom document loaders
@@ -542,11 +545,8 @@ cdef class _ParserContext(_ResolverContext):
     cdef bint _collect_ids
 
     def __cinit__(self):
-        self._c_ctxt = NULL
         self._collect_ids = True
-        if not config.ENABLE_THREADING:
-            self._lock = NULL
-        else:
+        if config.ENABLE_THREADING:
             self._lock = python.PyThread_allocate_lock()
         self._error_log = _ErrorLog()
 
@@ -573,6 +573,9 @@ cdef class _ParserContext(_ResolverContext):
         return context
 
     cdef void _initParserContext(self, xmlparser.xmlParserCtxt* c_ctxt) noexcept:
+        """
+        Connects the libxml2-level context to the lxml-level parser context.
+        """
         self._c_ctxt = c_ctxt
         c_ctxt._private = <void*>self
 
@@ -597,6 +600,12 @@ cdef class _ParserContext(_ResolverContext):
                 raise ParserError, "parser locking failed"
         self._error_log.clear()
         self._doc = None
+        # Connect the lxml error log with libxml2's error handling. In the case of parsing
+        # HTML, ctxt->sax is not set to null, so this always works. The libxml2 function
+        # that does this is htmlInitParserCtxt in HTMLparser.c. For HTML (and possibly XML
+        # too), libxml2's SAX's serror is set to be the place where errors are sent when
+        # schannel is set to ctxt->sax->serror in xmlCtxtErrMemory in libxml2's
+        # parserInternals.c.
         # Need a cast here because older libxml2 releases do not use 'const' in the functype.
         self._c_ctxt.sax.serror = <xmlerror.xmlStructuredErrorFunc> _receiveParserError
         self._orig_loader = _register_document_loader() if set_document_loader else NULL
@@ -642,6 +651,9 @@ cdef _initParserContext(_ParserContext context,
         context._initParserContext(c_ctxt)
 
 cdef void _forwardParserError(xmlparser.xmlParserCtxt* _parser_context, const xmlerror.xmlError* error) noexcept with gil:
+    """
+    Add an error created by libxml2 to the lxml-level error_log.
+    """
     (<_ParserContext>_parser_context._private)._error_log._receive(error)
 
 cdef void _receiveParserError(void* c_context, const xmlerror.xmlError* error) noexcept nogil:
@@ -687,6 +699,8 @@ cdef xmlDoc* _handleParseResult(_ParserContext context,
                                 xmlparser.xmlParserCtxt* c_ctxt,
                                 xmlDoc* result, filename,
                                 bint recover, bint free_doc) except NULL:
+    # The C-level argument xmlDoc* result is passed in as NULL if the parser was not able
+    # to parse the document.
     cdef bint well_formed
     if result is not NULL:
         __GLOBAL_PARSER_CONTEXT.initDocDict(result)
@@ -698,6 +712,9 @@ cdef xmlDoc* _handleParseResult(_ParserContext context,
         c_ctxt.myDoc = NULL
 
     if result is not NULL:
+        # "wellFormed" in libxml2 is 0 if the parser found fatal errors. It still returns a
+        # parse result document if 'recover=True'. Here, we determine if we can present
+        # the document to the user or consider it incorrect or broken enough to raise an error.
         if (context._validator is not None and
                 not context._validator.isvalid()):
             well_formed = 0  # actually not 'valid', but anyway ...
@@ -901,6 +918,9 @@ cdef class _BaseParser:
         return self._push_parser_context
 
     cdef _ParserContext _createContext(self, target, events_to_collect):
+        """
+        This method creates and configures the lxml-level parser.
+        """
         cdef _SaxParserContext sax_context
         if target is not None:
             sax_context = _TargetParserContext(self)
@@ -947,6 +967,9 @@ cdef class _BaseParser:
         return 0
 
     cdef xmlparser.xmlParserCtxt* _newParserCtxt(self) except NULL:
+        """
+        Create and initialise a libxml2-level parser context.
+        """
         cdef xmlparser.xmlParserCtxt* c_ctxt
         if self._for_html:
             c_ctxt = htmlparser.htmlCreateMemoryParserCtxt('dummy', 5)
@@ -1106,8 +1129,7 @@ cdef class _BaseParser:
         finally:
             context.cleanup()
 
-    cdef xmlDoc* _parseDoc(self, char* c_text, int c_len,
-                           char* c_filename) except NULL:
+    cdef xmlDoc* _parseDoc(self, const char* c_text, int c_len, char* c_filename) except NULL:
         """Parse document, share dictionary if possible.
         """
         cdef _ParserContext context
@@ -1440,7 +1462,7 @@ cdef class _FeedParser(_BaseParser):
                 else:
                     error = 0
 
-        if not pctxt.wellFormed and pctxt.disableSAX and context._has_raised():
+        if not pctxt.wellFormed and xmlparser.xmlCtxtIsStopped(pctxt) and context._has_raised():
             # propagate Python exceptions immediately
             recover = 0
             error = 1
@@ -1477,7 +1499,7 @@ cdef class _FeedParser(_BaseParser):
         else:
             xmlparser.xmlParseChunk(pctxt, NULL, 0, 1)
 
-        if (pctxt.recovery and not pctxt.disableSAX and
+        if (pctxt.recovery and not xmlparser.xmlCtxtIsStopped(pctxt) and
                 isinstance(context, _SaxParserContext)):
             # apply any left-over 'end' events
             (<_SaxParserContext>context).flushEvents()
@@ -1529,7 +1551,8 @@ cdef int _htmlCtxtResetPush(xmlparser.xmlParserCtxt* c_ctxt,
         return error
 
     # fix libxml2 setup for HTML
-    c_ctxt.progressive = 1
+    if tree.LIBXML_VERSION < 21400:
+        c_ctxt.progressive = 1  # TODO: remove
     c_ctxt.html = 1
     htmlparser.htmlCtxtUseOptions(c_ctxt, parse_options)
 
@@ -1547,10 +1570,15 @@ _XML_DEFAULT_PARSE_OPTIONS = (
     xmlparser.XML_PARSE_NONET   |
     xmlparser.XML_PARSE_COMPACT |
     xmlparser.XML_PARSE_BIG_LINES
-    )
+)
 
 cdef class XMLParser(_FeedParser):
-    """XMLParser(self, encoding=None, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, schema: XMLSchema =None, huge_tree=False, remove_blank_text=False, resolve_entities=True, remove_comments=False, remove_pis=False, strip_cdata=True, collect_ids=True, target=None, compact=True)
+    """XMLParser(self, encoding=None, attribute_defaults=False, dtd_validation=False, \
+                 load_dtd=False, no_network=True, decompress=False, ns_clean=False, \
+                 recover=False, schema: XMLSchema =None, huge_tree=False, \
+                 remove_blank_text=False, resolve_entities=True, \
+                 remove_comments=False, remove_pis=False, strip_cdata=True, \
+                 collect_ids=True, target=None, compact=True)
 
     The XML parser.
 
@@ -1572,6 +1600,8 @@ cdef class XMLParser(_FeedParser):
     - dtd_validation     - validate against a DTD referenced by the document
     - load_dtd           - use DTD for parsing
     - no_network         - prevent network access for related files (default: True)
+    - decompress         - automatically decompress gzip input
+                           (default: False, changed in lxml 6.0, disabling only affects libxml2 2.15+)
     - ns_clean           - clean up redundant namespace declarations
     - recover            - try hard to parse through broken XML
     - remove_blank_text  - discard blank text nodes that appear ignorable
@@ -1579,9 +1609,10 @@ cdef class XMLParser(_FeedParser):
     - remove_pis         - discard processing instructions
     - strip_cdata        - replace CDATA sections by normal text content (default: True)
     - compact            - save memory for short text content (default: True)
-    - collect_ids        - use a hash table of XML IDs for fast access (default: True, always True with DTD validation)
+    - collect_ids        - use a hash table of XML IDs for fast access
+                           (default: True, always True with DTD validation)
     - huge_tree          - disable security restrictions and support very deep trees
-                           and very long text content (only affects libxml2 2.7+)
+                           and very long text content
 
     Other keyword arguments:
 
@@ -1598,7 +1629,7 @@ cdef class XMLParser(_FeedParser):
     apply to the default parser.
     """
     def __init__(self, *, encoding=None, attribute_defaults=False,
-                 dtd_validation=False, load_dtd=False, no_network=True,
+                 dtd_validation=False, load_dtd=False, no_network=True, decompress=False,
                  ns_clean=False, recover=False, XMLSchema schema=None,
                  huge_tree=False, remove_blank_text=False, resolve_entities='internal',
                  remove_comments=False, remove_pis=False, strip_cdata=True,
@@ -1638,6 +1669,10 @@ cdef class XMLParser(_FeedParser):
                              remove_comments, remove_pis, strip_cdata,
                              collect_ids, target, encoding, resolve_external)
 
+    # Allow subscripting XMLParser in type annotions (PEP 560)
+    def __class_getitem__(cls, item):
+        return _GenericAlias(cls, item)
+
 
 cdef class XMLPullParser(XMLParser):
     """XMLPullParser(self, events=None, *, tag=None, **kwargs)
@@ -1670,7 +1705,7 @@ cdef class XMLPullParser(XMLParser):
 
 cdef class ETCompatXMLParser(XMLParser):
     """ETCompatXMLParser(self, encoding=None, attribute_defaults=False, \
-                 dtd_validation=False, load_dtd=False, no_network=True, \
+                 dtd_validation=False, load_dtd=False, no_network=True, decompress=False, \
                  ns_clean=False, recover=False, schema=None, \
                  huge_tree=False, remove_blank_text=False, resolve_entities=True, \
                  remove_comments=True, remove_pis=True, strip_cdata=True, \
@@ -1684,7 +1719,7 @@ cdef class ETCompatXMLParser(XMLParser):
     and thus ignores comments and processing instructions.
     """
     def __init__(self, *, encoding=None, attribute_defaults=False,
-                 dtd_validation=False, load_dtd=False, no_network=True,
+                 dtd_validation=False, load_dtd=False, no_network=True, decompress=False,
                  ns_clean=False, recover=False, schema=None,
                  huge_tree=False, remove_blank_text=False, resolve_entities=True,
                  remove_comments=True, remove_pis=True, strip_cdata=True,
@@ -1694,6 +1729,7 @@ cdef class ETCompatXMLParser(XMLParser):
                            dtd_validation=dtd_validation,
                            load_dtd=load_dtd,
                            no_network=no_network,
+                           decompress=decompress,
                            ns_clean=ns_clean,
                            recover=recover,
                            remove_blank_text=remove_blank_text,
@@ -1705,7 +1741,8 @@ cdef class ETCompatXMLParser(XMLParser):
                            strip_cdata=strip_cdata,
                            target=target,
                            encoding=encoding,
-                           schema=schema)
+                           schema=schema,
+                           )
 
 # ET 1.2 compatible name
 XMLTreeBuilder = ETCompatXMLParser
@@ -1752,7 +1789,7 @@ cdef object _UNUSED = object()
 cdef class HTMLParser(_FeedParser):
     """HTMLParser(self, encoding=None, remove_blank_text=False, \
                    remove_comments=False, remove_pis=False, \
-                   no_network=True, target=None, schema: XMLSchema =None, \
+                   no_network=True, decompress=False, target=None, schema: XMLSchema =None, \
                    recover=True, compact=True, collect_ids=True, huge_tree=False)
 
     The HTML parser.
@@ -1766,6 +1803,8 @@ cdef class HTMLParser(_FeedParser):
 
     - recover            - try hard to parse through broken HTML (default: True)
     - no_network         - prevent network access for related files (default: True)
+    - decompress         - automatically decompress gzip input
+                           (default: False, changed in lxml 6.0, disabling only affects libxml2 2.15+)
     - remove_blank_text  - discard empty text nodes that are ignorable (i.e. not actual text content)
     - remove_comments    - discard comments
     - remove_pis         - discard processing instructions
@@ -1773,7 +1812,7 @@ cdef class HTMLParser(_FeedParser):
     - default_doctype    - add a default doctype even if it is not found in the HTML (default: True)
     - collect_ids        - use a hash table of XML IDs for fast access (default: True)
     - huge_tree          - disable security restrictions and support very deep trees
-                           and very long text content (only affects libxml2 2.7+)
+                           and very long text content
 
     Other keyword arguments:
 
@@ -1786,7 +1825,7 @@ cdef class HTMLParser(_FeedParser):
     """
     def __init__(self, *, encoding=None, remove_blank_text=False,
                  remove_comments=False, remove_pis=False, strip_cdata=_UNUSED,
-                 no_network=True, target=None, XMLSchema schema=None,
+                 no_network=True, decompress=False, target=None, XMLSchema schema=None,
                  recover=True, compact=True, default_doctype=True,
                  collect_ids=True, huge_tree=False):
         cdef int parse_options
@@ -1813,6 +1852,10 @@ cdef class HTMLParser(_FeedParser):
                              remove_comments, remove_pis, strip_cdata,
                              collect_ids, target, encoding)
 
+    # Allow subscripting HTMLParser in type annotions (PEP 560)
+    def __class_getitem__(cls, item):
+        return _GenericAlias(cls, item)
+
 
 cdef HTMLParser __DEFAULT_HTML_PARSER
 __DEFAULT_HTML_PARSER = HTMLParser()
@@ -1853,8 +1896,6 @@ cdef class HTMLPullParser(HTMLParser):
 
 cdef xmlDoc* _parseDoc(text, filename, _BaseParser parser) except NULL:
     cdef char* c_filename
-    cdef char* c_text
-    cdef Py_ssize_t c_len
     if parser is None:
         parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
     if not filename:
@@ -1862,36 +1903,56 @@ cdef xmlDoc* _parseDoc(text, filename, _BaseParser parser) except NULL:
     else:
         filename_utf = _encodeFilenameUTF8(filename)
         c_filename = _cstr(filename_utf)
-    if isinstance(text, unicode):
-        if python.PyUnicode_IS_READY(text):
-            # PEP-393 Unicode string
-            c_len = python.PyUnicode_GET_LENGTH(text) * python.PyUnicode_KIND(text)
-        else:
-            # old Py_UNICODE string
-            c_len = python.PyUnicode_GET_DATA_SIZE(text)
-        if c_len > limits.INT_MAX:
-            return (<_BaseParser>parser)._parseDocFromFilelike(
-                StringIO(text), filename, None)
-        return (<_BaseParser>parser)._parseUnicodeDoc(text, c_filename)
+    if isinstance(text, bytes):
+        return _parseDoc_bytes(<bytes> text, filename, c_filename, parser)
+    elif isinstance(text, unicode):
+        return _parseDoc_unicode(<unicode> text, filename, c_filename, parser)
+    else:
+        return _parseDoc_charbuffer(text, filename, c_filename, parser)
+
+
+cdef xmlDoc* _parseDoc_unicode(unicode text, filename, char* c_filename, _BaseParser parser) except NULL:
+    cdef Py_ssize_t c_len
+    if python.PyUnicode_IS_READY(text):
+        # PEP-393 Unicode string
+        c_len = python.PyUnicode_GET_LENGTH(text) * python.PyUnicode_KIND(text)
     else:
-        c_len = python.PyBytes_GET_SIZE(text)
-        if c_len > limits.INT_MAX:
-            return (<_BaseParser>parser)._parseDocFromFilelike(
-                BytesIO(text), filename, None)
-        c_text = _cstr(text)
-        return (<_BaseParser>parser)._parseDoc(c_text, c_len, c_filename)
+        # old Py_UNICODE string
+        c_len = python.PyUnicode_GET_DATA_SIZE(text)
+    if c_len > limits.INT_MAX:
+        return parser._parseDocFromFilelike(
+            StringIO(text), filename, None)
+    return parser._parseUnicodeDoc(text, c_filename)
+
+
+cdef xmlDoc* _parseDoc_bytes(bytes text, filename, char* c_filename, _BaseParser parser) except NULL:
+    cdef Py_ssize_t c_len = len(text)
+    if c_len > limits.INT_MAX:
+        return parser._parseDocFromFilelike(BytesIO(text), filename, None)
+    return parser._parseDoc(text, c_len, c_filename)
+
+
+cdef xmlDoc* _parseDoc_charbuffer(text, filename, char* c_filename, _BaseParser parser) except NULL:
+    cdef const unsigned char[::1] data = memoryview(text).cast('B')  # cast to 'unsigned char' buffer
+    cdef Py_ssize_t c_len = len(data)
+    if c_len > limits.INT_MAX:
+        return parser._parseDocFromFilelike(BytesIO(text), filename, None)
+    return parser._parseDoc(<const char*>&data[0], c_len, c_filename)
+
 
 cdef xmlDoc* _parseDocFromFile(filename8, _BaseParser parser) except NULL:
     if parser is None:
         parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
     return (<_BaseParser>parser)._parseDocFromFile(_cstr(filename8))
 
+
 cdef xmlDoc* _parseDocFromFilelike(source, filename,
                                    _BaseParser parser) except NULL:
     if parser is None:
         parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
     return (<_BaseParser>parser)._parseDocFromFilelike(source, filename, None)
 
+
 cdef xmlDoc* _newXMLDoc() except NULL:
     cdef xmlDoc* result
     result = tree.xmlNewDoc(NULL)
@@ -1990,8 +2051,6 @@ cdef _Document _parseMemoryDocument(text, url, _BaseParser parser):
             raise ValueError(
                 "Unicode strings with encoding declaration are not supported. "
                 "Please use bytes input or XML fragments without declaration.")
-    elif not isinstance(text, bytes):
-        raise ValueError, "can only parse strings"
     c_doc = _parseDoc(text, url, parser)
     return _documentFactory(c_doc, parser)
 

lxml/sax.py

@@ -18,6 +18,13 @@ from lxml import etree
 from lxml.etree import ElementTree, SubElement
 from lxml.etree import Comment, ProcessingInstruction
 
+try:
+    from types import GenericAlias as _GenericAlias
+except ImportError:
+    # Python 3.8 - we only need this as return value from "__class_getitem__"
+    def _GenericAlias(cls, item):
+        return f"{cls.__name__}[{item.__name__}]"
+
 
 class SaxError(etree.LxmlError):
     """General SAX error.
@@ -152,6 +159,10 @@ class ElementTreeContentHandler(ContentHandler):
 
     ignorableWhitespace = characters
 
+    # Allow subscripting sax.ElementTreeContentHandler in type annotions (PEP 560)
+    def __class_getitem__(cls, item):
+        return _GenericAlias(cls, item)
+
 
 class ElementTreeProducer:
     """Produces SAX events for an element and children.

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)