diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/lxml/xmlschema.pxi')
| -rw-r--r-- | .venv/lib/python3.12/site-packages/lxml/xmlschema.pxi | 215 |
1 files changed, 215 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/lxml/xmlschema.pxi b/.venv/lib/python3.12/site-packages/lxml/xmlschema.pxi new file mode 100644 index 00000000..ac5f9587 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/lxml/xmlschema.pxi @@ -0,0 +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) |