lxml 5.2.0__cp310-cp310-win32.whl → 5.2.2__cp310-cp310-win32.whl

lxml/xmlschema.pxi

@@ -1,215 +1,215 @@
-#  support for XMLSchema validation
-from lxml.includes cimport xmlschema
-
-
-cdef class XMLSchemaError(LxmlError):
-    """Base class of all XML Schema errors
-    """
-
-cdef class XMLSchemaParseError(XMLSchemaError):
-    """Error while parsing an XML document as XML Schema.
-    """
-
-cdef class XMLSchemaValidateError(XMLSchemaError):
-    """Error while validating an XML document with an XML Schema.
-    """
-
-
-################################################################################
-# XMLSchema
-
-cdef XPath _check_for_default_attributes = XPath(
-    "boolean(//xs:attribute[@default or @fixed][1])",
-    namespaces={'xs': 'http://www.w3.org/2001/XMLSchema'})
-
-
-cdef class XMLSchema(_Validator):
-    """XMLSchema(self, etree=None, file=None)
-    Turn a document into an XML Schema validator.
-
-    Either pass a schema as Element or ElementTree, or pass a file or
-    filename through the ``file`` keyword argument.
-
-    Passing the ``attribute_defaults`` boolean option will make the
-    schema insert default/fixed attributes into validated documents.
-    """
-    cdef xmlschema.xmlSchema* _c_schema
-    cdef _Document _doc
-    cdef bint _has_default_attributes
-    cdef bint _add_attribute_defaults
-
-    def __cinit__(self):
-        self._has_default_attributes = True # play it safe
-        self._add_attribute_defaults = False
-
-    def __init__(self, etree=None, *, file=None, bint attribute_defaults=False):
-        cdef xmlschema.xmlSchemaParserCtxt* parser_ctxt
-        cdef xmlDoc* c_doc
-
-        self._add_attribute_defaults = attribute_defaults
-        _Validator.__init__(self)
-        c_doc = NULL
-        if etree is not None:
-            doc = _documentOrRaise(etree)
-            root_node = _rootNodeOrRaise(etree)
-            c_doc = _copyDocRoot(doc._c_doc, root_node._c_node)
-            self._doc = _documentFactory(c_doc, doc._parser)
-            parser_ctxt = xmlschema.xmlSchemaNewDocParserCtxt(c_doc)
-        elif file is not None:
-            file = _getFSPathOrObject(file)
-            if _isString(file):
-                filename = _encodeFilename(file)
-                parser_ctxt = xmlschema.xmlSchemaNewParserCtxt(_cstr(filename))
-            else:
-                self._doc = _parseDocument(file, None, None)
-                parser_ctxt = xmlschema.xmlSchemaNewDocParserCtxt(self._doc._c_doc)
-        else:
-            raise XMLSchemaParseError, "No tree or file given"
-
-        if parser_ctxt is NULL:
-            raise MemoryError()
-
-        # Need a cast here because older libxml2 releases do not use 'const' in the functype.
-        xmlschema.xmlSchemaSetParserStructuredErrors(
-            parser_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>self._error_log)
-        if self._doc is not None:
-            # calling xmlSchemaParse on a schema with imports or
-            # includes will cause libxml2 to create an internal
-            # context for parsing, so push an implied context to route
-            # resolve requests to the document's parser
-            __GLOBAL_PARSER_CONTEXT.pushImpliedContextFromParser(self._doc._parser)
-        with nogil:
-            orig_loader = _register_document_loader()
-            self._c_schema = xmlschema.xmlSchemaParse(parser_ctxt)
-            _reset_document_loader(orig_loader)
-        if self._doc is not None:
-            __GLOBAL_PARSER_CONTEXT.popImpliedContext()
-        xmlschema.xmlSchemaFreeParserCtxt(parser_ctxt)
-
-        if self._c_schema is NULL:
-            raise XMLSchemaParseError(
-                self._error_log._buildExceptionMessage(
-                    "Document is not valid XML Schema"),
-                self._error_log)
-
-        if self._doc is not None:
-            self._has_default_attributes = _check_for_default_attributes(self._doc)
-        self._add_attribute_defaults = attribute_defaults and self._has_default_attributes
-
-    def __dealloc__(self):
-        xmlschema.xmlSchemaFree(self._c_schema)
-
-    def __call__(self, etree):
-        """__call__(self, etree)
-
-        Validate doc using XML Schema.
-
-        Returns true if document is valid, false if not.
-        """
-        cdef xmlschema.xmlSchemaValidCtxt* valid_ctxt
-        cdef _Document doc
-        cdef _Element root_node
-        cdef xmlDoc* c_doc
-        cdef int ret
-
-        assert self._c_schema is not NULL, "Schema instance not initialised"
-        doc = _documentOrRaise(etree)
-        root_node = _rootNodeOrRaise(etree)
-
-        valid_ctxt = xmlschema.xmlSchemaNewValidCtxt(self._c_schema)
-        if valid_ctxt is NULL:
-            raise MemoryError()
-
-        try:
-            if self._add_attribute_defaults:
-                xmlschema.xmlSchemaSetValidOptions(
-                    valid_ctxt, xmlschema.XML_SCHEMA_VAL_VC_I_CREATE)
-
-            self._error_log.clear()
-            # Need a cast here because older libxml2 releases do not use 'const' in the functype.
-            xmlschema.xmlSchemaSetValidStructuredErrors(
-                valid_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>self._error_log)
-
-            c_doc = _fakeRootDoc(doc._c_doc, root_node._c_node)
-            with nogil:
-                ret = xmlschema.xmlSchemaValidateDoc(valid_ctxt, c_doc)
-            _destroyFakeDoc(doc._c_doc, c_doc)
-        finally:
-            xmlschema.xmlSchemaFreeValidCtxt(valid_ctxt)
-
-        if ret == -1:
-            raise XMLSchemaValidateError(
-                "Internal error in XML Schema validation.",
-                self._error_log)
-        if ret == 0:
-            return True
-        else:
-            return False
-
-    cdef _ParserSchemaValidationContext _newSaxValidator(
-            self, bint add_default_attributes):
-        cdef _ParserSchemaValidationContext context
-        context = _ParserSchemaValidationContext.__new__(_ParserSchemaValidationContext)
-        context._schema = self
-        context._add_default_attributes = (self._has_default_attributes and (
-            add_default_attributes or self._add_attribute_defaults))
-        return context
-
-@cython.final
-@cython.internal
-cdef class _ParserSchemaValidationContext:
-    cdef XMLSchema _schema
-    cdef xmlschema.xmlSchemaValidCtxt* _valid_ctxt
-    cdef xmlschema.xmlSchemaSAXPlugStruct* _sax_plug
-    cdef bint _add_default_attributes
-    def __cinit__(self):
-        self._valid_ctxt = NULL
-        self._sax_plug = NULL
-        self._add_default_attributes = False
-
-    def __dealloc__(self):
-        self.disconnect()
-        if self._valid_ctxt:
-            xmlschema.xmlSchemaFreeValidCtxt(self._valid_ctxt)
-
-    cdef _ParserSchemaValidationContext copy(self):
-        assert self._schema is not None, "_ParserSchemaValidationContext not initialised"
-        return self._schema._newSaxValidator(
-            self._add_default_attributes)
-
-    cdef void inject_default_attributes(self, xmlDoc* c_doc) noexcept:
-        # we currently need to insert default attributes manually
-        # after parsing, as libxml2 does not support this at parse
-        # time
-        if self._add_default_attributes:
-            with nogil:
-                xmlschema.xmlSchemaValidateDoc(self._valid_ctxt, c_doc)
-
-    cdef int connect(self, xmlparser.xmlParserCtxt* c_ctxt, _BaseErrorLog error_log) except -1:
-        if self._valid_ctxt is NULL:
-            self._valid_ctxt = xmlschema.xmlSchemaNewValidCtxt(
-                self._schema._c_schema)
-            if self._valid_ctxt is NULL:
-                raise MemoryError()
-            if self._add_default_attributes:
-                xmlschema.xmlSchemaSetValidOptions(
-                    self._valid_ctxt, xmlschema.XML_SCHEMA_VAL_VC_I_CREATE)
-        if error_log is not None:
-            # Need a cast here because older libxml2 releases do not use 'const' in the functype.
-            xmlschema.xmlSchemaSetValidStructuredErrors(
-                self._valid_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>error_log)
-        self._sax_plug = xmlschema.xmlSchemaSAXPlug(
-            self._valid_ctxt, &c_ctxt.sax, &c_ctxt.userData)
-
-    cdef void disconnect(self) noexcept:
-        if self._sax_plug is not NULL:
-            xmlschema.xmlSchemaSAXUnplug(self._sax_plug)
-            self._sax_plug = NULL
-        if self._valid_ctxt is not NULL:
-            xmlschema.xmlSchemaSetValidStructuredErrors(
-                self._valid_ctxt, NULL, NULL)
-
-    cdef bint isvalid(self) noexcept:
-        if self._valid_ctxt is NULL:
-            return 1 # valid
-        return xmlschema.xmlSchemaIsValid(self._valid_ctxt)
+#  support for XMLSchema validation
+from lxml.includes cimport xmlschema
+
+
+cdef class XMLSchemaError(LxmlError):
+    """Base class of all XML Schema errors
+    """
+
+cdef class XMLSchemaParseError(XMLSchemaError):
+    """Error while parsing an XML document as XML Schema.
+    """
+
+cdef class XMLSchemaValidateError(XMLSchemaError):
+    """Error while validating an XML document with an XML Schema.
+    """
+
+
+################################################################################
+# XMLSchema
+
+cdef XPath _check_for_default_attributes = XPath(
+    "boolean(//xs:attribute[@default or @fixed][1])",
+    namespaces={'xs': 'http://www.w3.org/2001/XMLSchema'})
+
+
+cdef class XMLSchema(_Validator):
+    """XMLSchema(self, etree=None, file=None)
+    Turn a document into an XML Schema validator.
+
+    Either pass a schema as Element or ElementTree, or pass a file or
+    filename through the ``file`` keyword argument.
+
+    Passing the ``attribute_defaults`` boolean option will make the
+    schema insert default/fixed attributes into validated documents.
+    """
+    cdef xmlschema.xmlSchema* _c_schema
+    cdef _Document _doc
+    cdef bint _has_default_attributes
+    cdef bint _add_attribute_defaults
+
+    def __cinit__(self):
+        self._has_default_attributes = True # play it safe
+        self._add_attribute_defaults = False
+
+    def __init__(self, etree=None, *, file=None, bint attribute_defaults=False):
+        cdef xmlschema.xmlSchemaParserCtxt* parser_ctxt
+        cdef xmlDoc* c_doc
+
+        self._add_attribute_defaults = attribute_defaults
+        _Validator.__init__(self)
+        c_doc = NULL
+        if etree is not None:
+            doc = _documentOrRaise(etree)
+            root_node = _rootNodeOrRaise(etree)
+            c_doc = _copyDocRoot(doc._c_doc, root_node._c_node)
+            self._doc = _documentFactory(c_doc, doc._parser)
+            parser_ctxt = xmlschema.xmlSchemaNewDocParserCtxt(c_doc)
+        elif file is not None:
+            file = _getFSPathOrObject(file)
+            if _isString(file):
+                filename = _encodeFilename(file)
+                parser_ctxt = xmlschema.xmlSchemaNewParserCtxt(_cstr(filename))
+            else:
+                self._doc = _parseDocument(file, None, None)
+                parser_ctxt = xmlschema.xmlSchemaNewDocParserCtxt(self._doc._c_doc)
+        else:
+            raise XMLSchemaParseError, "No tree or file given"
+
+        if parser_ctxt is NULL:
+            raise MemoryError()
+
+        # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+        xmlschema.xmlSchemaSetParserStructuredErrors(
+            parser_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>self._error_log)
+        if self._doc is not None:
+            # calling xmlSchemaParse on a schema with imports or
+            # includes will cause libxml2 to create an internal
+            # context for parsing, so push an implied context to route
+            # resolve requests to the document's parser
+            __GLOBAL_PARSER_CONTEXT.pushImpliedContextFromParser(self._doc._parser)
+        with nogil:
+            orig_loader = _register_document_loader()
+            self._c_schema = xmlschema.xmlSchemaParse(parser_ctxt)
+            _reset_document_loader(orig_loader)
+        if self._doc is not None:
+            __GLOBAL_PARSER_CONTEXT.popImpliedContext()
+        xmlschema.xmlSchemaFreeParserCtxt(parser_ctxt)
+
+        if self._c_schema is NULL:
+            raise XMLSchemaParseError(
+                self._error_log._buildExceptionMessage(
+                    "Document is not valid XML Schema"),
+                self._error_log)
+
+        if self._doc is not None:
+            self._has_default_attributes = _check_for_default_attributes(self._doc)
+        self._add_attribute_defaults = attribute_defaults and self._has_default_attributes
+
+    def __dealloc__(self):
+        xmlschema.xmlSchemaFree(self._c_schema)
+
+    def __call__(self, etree):
+        """__call__(self, etree)
+
+        Validate doc using XML Schema.
+
+        Returns true if document is valid, false if not.
+        """
+        cdef xmlschema.xmlSchemaValidCtxt* valid_ctxt
+        cdef _Document doc
+        cdef _Element root_node
+        cdef xmlDoc* c_doc
+        cdef int ret
+
+        assert self._c_schema is not NULL, "Schema instance not initialised"
+        doc = _documentOrRaise(etree)
+        root_node = _rootNodeOrRaise(etree)
+
+        valid_ctxt = xmlschema.xmlSchemaNewValidCtxt(self._c_schema)
+        if valid_ctxt is NULL:
+            raise MemoryError()
+
+        try:
+            if self._add_attribute_defaults:
+                xmlschema.xmlSchemaSetValidOptions(
+                    valid_ctxt, xmlschema.XML_SCHEMA_VAL_VC_I_CREATE)
+
+            self._error_log.clear()
+            # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+            xmlschema.xmlSchemaSetValidStructuredErrors(
+                valid_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>self._error_log)
+
+            c_doc = _fakeRootDoc(doc._c_doc, root_node._c_node)
+            with nogil:
+                ret = xmlschema.xmlSchemaValidateDoc(valid_ctxt, c_doc)
+            _destroyFakeDoc(doc._c_doc, c_doc)
+        finally:
+            xmlschema.xmlSchemaFreeValidCtxt(valid_ctxt)
+
+        if ret == -1:
+            raise XMLSchemaValidateError(
+                "Internal error in XML Schema validation.",
+                self._error_log)
+        if ret == 0:
+            return True
+        else:
+            return False
+
+    cdef _ParserSchemaValidationContext _newSaxValidator(
+            self, bint add_default_attributes):
+        cdef _ParserSchemaValidationContext context
+        context = _ParserSchemaValidationContext.__new__(_ParserSchemaValidationContext)
+        context._schema = self
+        context._add_default_attributes = (self._has_default_attributes and (
+            add_default_attributes or self._add_attribute_defaults))
+        return context
+
+@cython.final
+@cython.internal
+cdef class _ParserSchemaValidationContext:
+    cdef XMLSchema _schema
+    cdef xmlschema.xmlSchemaValidCtxt* _valid_ctxt
+    cdef xmlschema.xmlSchemaSAXPlugStruct* _sax_plug
+    cdef bint _add_default_attributes
+    def __cinit__(self):
+        self._valid_ctxt = NULL
+        self._sax_plug = NULL
+        self._add_default_attributes = False
+
+    def __dealloc__(self):
+        self.disconnect()
+        if self._valid_ctxt:
+            xmlschema.xmlSchemaFreeValidCtxt(self._valid_ctxt)
+
+    cdef _ParserSchemaValidationContext copy(self):
+        assert self._schema is not None, "_ParserSchemaValidationContext not initialised"
+        return self._schema._newSaxValidator(
+            self._add_default_attributes)
+
+    cdef void inject_default_attributes(self, xmlDoc* c_doc) noexcept:
+        # we currently need to insert default attributes manually
+        # after parsing, as libxml2 does not support this at parse
+        # time
+        if self._add_default_attributes:
+            with nogil:
+                xmlschema.xmlSchemaValidateDoc(self._valid_ctxt, c_doc)
+
+    cdef int connect(self, xmlparser.xmlParserCtxt* c_ctxt, _BaseErrorLog error_log) except -1:
+        if self._valid_ctxt is NULL:
+            self._valid_ctxt = xmlschema.xmlSchemaNewValidCtxt(
+                self._schema._c_schema)
+            if self._valid_ctxt is NULL:
+                raise MemoryError()
+            if self._add_default_attributes:
+                xmlschema.xmlSchemaSetValidOptions(
+                    self._valid_ctxt, xmlschema.XML_SCHEMA_VAL_VC_I_CREATE)
+        if error_log is not None:
+            # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+            xmlschema.xmlSchemaSetValidStructuredErrors(
+                self._valid_ctxt, <xmlerror.xmlStructuredErrorFunc> _receiveError, <void*>error_log)
+        self._sax_plug = xmlschema.xmlSchemaSAXPlug(
+            self._valid_ctxt, &c_ctxt.sax, &c_ctxt.userData)
+
+    cdef void disconnect(self) noexcept:
+        if self._sax_plug is not NULL:
+            xmlschema.xmlSchemaSAXUnplug(self._sax_plug)
+            self._sax_plug = NULL
+        if self._valid_ctxt is not NULL:
+            xmlschema.xmlSchemaSetValidStructuredErrors(
+                self._valid_ctxt, NULL, NULL)
+
+    cdef bint isvalid(self) noexcept:
+        if self._valid_ctxt is NULL:
+            return 1 # valid
+        return xmlschema.xmlSchemaIsValid(self._valid_ctxt)