| # XPath evaluation | |
| class XPathSyntaxError(LxmlSyntaxError, XPathError): | |
| pass | |
| ################################################################################ | |
| # XPath | |
| cdef object _XPATH_SYNTAX_ERRORS = ( | |
| xmlerror.XML_XPATH_NUMBER_ERROR, | |
| xmlerror.XML_XPATH_UNFINISHED_LITERAL_ERROR, | |
| xmlerror.XML_XPATH_VARIABLE_REF_ERROR, | |
| xmlerror.XML_XPATH_INVALID_PREDICATE_ERROR, | |
| xmlerror.XML_XPATH_UNCLOSED_ERROR, | |
| xmlerror.XML_XPATH_INVALID_CHAR_ERROR | |
| ) | |
| cdef object _XPATH_EVAL_ERRORS = ( | |
| xmlerror.XML_XPATH_UNDEF_VARIABLE_ERROR, | |
| xmlerror.XML_XPATH_UNDEF_PREFIX_ERROR, | |
| xmlerror.XML_XPATH_UNKNOWN_FUNC_ERROR, | |
| xmlerror.XML_XPATH_INVALID_OPERAND, | |
| xmlerror.XML_XPATH_INVALID_TYPE, | |
| xmlerror.XML_XPATH_INVALID_ARITY, | |
| xmlerror.XML_XPATH_INVALID_CTXT_SIZE, | |
| xmlerror.XML_XPATH_INVALID_CTXT_POSITION | |
| ) | |
| cdef int _register_xpath_function(void* ctxt, name_utf, ns_utf) noexcept: | |
| if ns_utf is None: | |
| return xpath.xmlXPathRegisterFunc( | |
| <xpath.xmlXPathContext*>ctxt, _xcstr(name_utf), | |
| _xpath_function_call) | |
| else: | |
| return xpath.xmlXPathRegisterFuncNS( | |
| <xpath.xmlXPathContext*>ctxt, _xcstr(name_utf), _xcstr(ns_utf), | |
| _xpath_function_call) | |
| cdef int _unregister_xpath_function(void* ctxt, name_utf, ns_utf) noexcept: | |
| if ns_utf is None: | |
| return xpath.xmlXPathRegisterFunc( | |
| <xpath.xmlXPathContext*>ctxt, _xcstr(name_utf), NULL) | |
| else: | |
| return xpath.xmlXPathRegisterFuncNS( | |
| <xpath.xmlXPathContext*>ctxt, _xcstr(name_utf), _xcstr(ns_utf), NULL) | |
| @cython.final | |
| @cython.internal | |
| cdef class _XPathContext(_BaseContext): | |
| cdef object _variables | |
| def __init__(self, namespaces, extensions, error_log, enable_regexp, variables, | |
| build_smart_strings): | |
| self._variables = variables | |
| _BaseContext.__init__(self, namespaces, extensions, error_log, enable_regexp, | |
| build_smart_strings) | |
| cdef set_context(self, xpath.xmlXPathContext* xpathCtxt): | |
| self._set_xpath_context(xpathCtxt) | |
| # This would be a good place to set up the XPath parser dict, but | |
| # we cannot use the current thread dict as we do not know which | |
| # thread will execute the XPath evaluator - so, no dict for now. | |
| self.registerLocalNamespaces() | |
| self.registerLocalFunctions(xpathCtxt, _register_xpath_function) | |
| cdef register_context(self, _Document doc): | |
| self._register_context(doc) | |
| self.registerGlobalNamespaces() | |
| self.registerGlobalFunctions(self._xpathCtxt, _register_xpath_function) | |
| self.registerExsltFunctions() | |
| if self._variables is not None: | |
| self.registerVariables(self._variables) | |
| cdef unregister_context(self): | |
| self.unregisterGlobalFunctions( | |
| self._xpathCtxt, _unregister_xpath_function) | |
| self.unregisterGlobalNamespaces() | |
| xpath.xmlXPathRegisteredVariablesCleanup(self._xpathCtxt) | |
| self._cleanup_context() | |
| cdef void registerExsltFunctions(self) noexcept: | |
| if xslt.LIBXSLT_VERSION < 10125: | |
| # we'd only execute dummy functions anyway | |
| return | |
| tree.xmlHashScan( | |
| self._xpathCtxt.nsHash, _registerExsltFunctionsForNamespaces, | |
| self._xpathCtxt) | |
| cdef registerVariables(self, variable_dict): | |
| for name, value in variable_dict.items(): | |
| name_utf = self._to_utf(name) | |
| xpath.xmlXPathRegisterVariable( | |
| self._xpathCtxt, _xcstr(name_utf), _wrapXPathObject(value, None, None)) | |
| cdef registerVariable(self, name, value): | |
| name_utf = self._to_utf(name) | |
| xpath.xmlXPathRegisterVariable( | |
| self._xpathCtxt, _xcstr(name_utf), _wrapXPathObject(value, None, None)) | |
| cdef void _registerExsltFunctionsForNamespaces( | |
| void* _c_href, void* _ctxt, const_xmlChar* c_prefix) noexcept: | |
| c_href = <const_xmlChar*> _c_href | |
| ctxt = <xpath.xmlXPathContext*> _ctxt | |
| if tree.xmlStrcmp(c_href, xslt.EXSLT_DATE_NAMESPACE) == 0: | |
| xslt.exsltDateXpathCtxtRegister(ctxt, c_prefix) | |
| elif tree.xmlStrcmp(c_href, xslt.EXSLT_SETS_NAMESPACE) == 0: | |
| xslt.exsltSetsXpathCtxtRegister(ctxt, c_prefix) | |
| elif tree.xmlStrcmp(c_href, xslt.EXSLT_MATH_NAMESPACE) == 0: | |
| xslt.exsltMathXpathCtxtRegister(ctxt, c_prefix) | |
| elif tree.xmlStrcmp(c_href, xslt.EXSLT_STRINGS_NAMESPACE) == 0: | |
| xslt.exsltStrXpathCtxtRegister(ctxt, c_prefix) | |
| cdef class _XPathEvaluatorBase: | |
| cdef xpath.xmlXPathContext* _xpathCtxt | |
| cdef _XPathContext _context | |
| cdef python.PyThread_type_lock _eval_lock | |
| cdef _ErrorLog _error_log | |
| def __cinit__(self): | |
| self._xpathCtxt = NULL | |
| if config.ENABLE_THREADING: | |
| self._eval_lock = python.PyThread_allocate_lock() | |
| if self._eval_lock is NULL: | |
| raise MemoryError() | |
| self._error_log = _ErrorLog() | |
| def __init__(self, namespaces, extensions, enable_regexp, | |
| smart_strings): | |
| self._context = _XPathContext(namespaces, extensions, self._error_log, | |
| enable_regexp, None, smart_strings) | |
| @property | |
| def error_log(self): | |
| assert self._error_log is not None, "XPath evaluator not initialised" | |
| return self._error_log.copy() | |
| def __dealloc__(self): | |
| if self._xpathCtxt is not NULL: | |
| xpath.xmlXPathFreeContext(self._xpathCtxt) | |
| if config.ENABLE_THREADING: | |
| if self._eval_lock is not NULL: | |
| python.PyThread_free_lock(self._eval_lock) | |
| cdef set_context(self, xpath.xmlXPathContext* xpathCtxt): | |
| self._xpathCtxt = xpathCtxt | |
| self._context.set_context(xpathCtxt) | |
| cdef bint _checkAbsolutePath(self, char* path) noexcept: | |
| cdef char c | |
| if path is NULL: | |
| return 0 | |
| c = path[0] | |
| while c == c' ' or c == c'\t': | |
| path = path + 1 | |
| c = path[0] | |
| return c == c'/' | |
| @cython.final | |
| cdef int _lock(self) except -1: | |
| cdef int result | |
| if config.ENABLE_THREADING and self._eval_lock != NULL: | |
| with nogil: | |
| result = python.PyThread_acquire_lock( | |
| self._eval_lock, python.WAIT_LOCK) | |
| if result == 0: | |
| raise XPathError, "XPath evaluator locking failed" | |
| return 0 | |
| @cython.final | |
| cdef void _unlock(self) noexcept: | |
| if config.ENABLE_THREADING and self._eval_lock != NULL: | |
| python.PyThread_release_lock(self._eval_lock) | |
| cdef _build_parse_error(self): | |
| cdef _BaseErrorLog entries | |
| entries = self._error_log.filter_types(_XPATH_SYNTAX_ERRORS) | |
| if entries: | |
| message = entries._buildExceptionMessage(None) | |
| if message is not None: | |
| return XPathSyntaxError(message, self._error_log) | |
| return XPathSyntaxError( | |
| self._error_log._buildExceptionMessage("Error in xpath expression"), | |
| self._error_log) | |
| cdef _build_eval_error(self): | |
| cdef _BaseErrorLog entries | |
| entries = self._error_log.filter_types(_XPATH_EVAL_ERRORS) | |
| if not entries: | |
| entries = self._error_log.filter_types(_XPATH_SYNTAX_ERRORS) | |
| if entries: | |
| message = entries._buildExceptionMessage(None) | |
| if message is not None: | |
| return XPathEvalError(message, self._error_log) | |
| return XPathEvalError( | |
| self._error_log._buildExceptionMessage("Error in xpath expression"), | |
| self._error_log) | |
| cdef object _handle_result(self, xpath.xmlXPathObject* xpathObj, _Document doc): | |
| if self._context._exc._has_raised(): | |
| if xpathObj is not NULL: | |
| _freeXPathObject(xpathObj) | |
| xpathObj = NULL | |
| self._context._release_temp_refs() | |
| self._context._exc._raise_if_stored() | |
| if xpathObj is NULL: | |
| self._context._release_temp_refs() | |
| raise self._build_eval_error() | |
| try: | |
| result = _unwrapXPathObject(xpathObj, doc, self._context) | |
| finally: | |
| _freeXPathObject(xpathObj) | |
| self._context._release_temp_refs() | |
| return result | |
| cdef class XPathElementEvaluator(_XPathEvaluatorBase): | |
| """XPathElementEvaluator(self, element, namespaces=None, extensions=None, regexp=True, smart_strings=True) | |
| Create an XPath evaluator for an element. | |
| Absolute XPath expressions (starting with '/') will be evaluated against | |
| the ElementTree as returned by getroottree(). | |
| Additional namespace declarations can be passed with the | |
| 'namespace' keyword argument. EXSLT regular expression support | |
| can be disabled with the 'regexp' boolean keyword (defaults to | |
| True). Smart strings will be returned for string results unless | |
| you pass ``smart_strings=False``. | |
| """ | |
| cdef _Element _element | |
| def __init__(self, _Element element not None, *, namespaces=None, | |
| extensions=None, regexp=True, smart_strings=True): | |
| cdef xpath.xmlXPathContext* xpathCtxt | |
| cdef int ns_register_status | |
| cdef _Document doc | |
| _assertValidNode(element) | |
| _assertValidDoc(element._doc) | |
| self._element = element | |
| doc = element._doc | |
| _XPathEvaluatorBase.__init__(self, namespaces, extensions, | |
| regexp, smart_strings) | |
| xpathCtxt = xpath.xmlXPathNewContext(doc._c_doc) | |
| if xpathCtxt is NULL: | |
| raise MemoryError() | |
| self.set_context(xpathCtxt) | |
| def register_namespace(self, prefix, uri): | |
| """Register a namespace with the XPath context. | |
| """ | |
| assert self._xpathCtxt is not NULL, "XPath context not initialised" | |
| self._context.addNamespace(prefix, uri) | |
| def register_namespaces(self, namespaces): | |
| """Register a prefix -> uri dict. | |
| """ | |
| assert self._xpathCtxt is not NULL, "XPath context not initialised" | |
| for prefix, uri in namespaces.items(): | |
| self._context.addNamespace(prefix, uri) | |
| def __call__(self, _path, **_variables): | |
| """__call__(self, _path, **_variables) | |
| Evaluate an XPath expression on the document. | |
| Variables may be provided as keyword arguments. Note that namespaces | |
| are currently not supported for variables. | |
| Absolute XPath expressions (starting with '/') will be evaluated | |
| against the ElementTree as returned by getroottree(). | |
| """ | |
| cdef xpath.xmlXPathObject* xpathObj | |
| cdef _Document doc | |
| assert self._xpathCtxt is not NULL, "XPath context not initialised" | |
| path = _utf8(_path) | |
| doc = self._element._doc | |
| self._lock() | |
| self._xpathCtxt.node = self._element._c_node | |
| try: | |
| self._context.register_context(doc) | |
| self._context.registerVariables(_variables) | |
| c_path = _xcstr(path) | |
| with nogil: | |
| xpathObj = xpath.xmlXPathEvalExpression( | |
| c_path, self._xpathCtxt) | |
| result = self._handle_result(xpathObj, doc) | |
| finally: | |
| self._context.unregister_context() | |
| self._unlock() | |
| return result | |
| cdef class XPathDocumentEvaluator(XPathElementEvaluator): | |
| """XPathDocumentEvaluator(self, etree, namespaces=None, extensions=None, regexp=True, smart_strings=True) | |
| Create an XPath evaluator for an ElementTree. | |
| Additional namespace declarations can be passed with the | |
| 'namespace' keyword argument. EXSLT regular expression support | |
| can be disabled with the 'regexp' boolean keyword (defaults to | |
| True). Smart strings will be returned for string results unless | |
| you pass ``smart_strings=False``. | |
| """ | |
| def __init__(self, _ElementTree etree not None, *, namespaces=None, | |
| extensions=None, regexp=True, smart_strings=True): | |
| XPathElementEvaluator.__init__( | |
| self, etree._context_node, namespaces=namespaces, | |
| extensions=extensions, regexp=regexp, | |
| smart_strings=smart_strings) | |
| def __call__(self, _path, **_variables): | |
| """__call__(self, _path, **_variables) | |
| Evaluate an XPath expression on the document. | |
| Variables may be provided as keyword arguments. Note that namespaces | |
| are currently not supported for variables. | |
| """ | |
| cdef xpath.xmlXPathObject* xpathObj | |
| cdef xmlDoc* c_doc | |
| cdef _Document doc | |
| assert self._xpathCtxt is not NULL, "XPath context not initialised" | |
| path = _utf8(_path) | |
| doc = self._element._doc | |
| self._lock() | |
| try: | |
| self._context.register_context(doc) | |
| c_doc = _fakeRootDoc(doc._c_doc, self._element._c_node) | |
| try: | |
| self._context.registerVariables(_variables) | |
| c_path = _xcstr(path) | |
| with nogil: | |
| self._xpathCtxt.doc = c_doc | |
| self._xpathCtxt.node = tree.xmlDocGetRootElement(c_doc) | |
| xpathObj = xpath.xmlXPathEvalExpression( | |
| c_path, self._xpathCtxt) | |
| result = self._handle_result(xpathObj, doc) | |
| finally: | |
| _destroyFakeDoc(doc._c_doc, c_doc) | |
| self._context.unregister_context() | |
| finally: | |
| self._unlock() | |
| return result | |
| def XPathEvaluator(etree_or_element, *, namespaces=None, extensions=None, | |
| regexp=True, smart_strings=True): | |
| """XPathEvaluator(etree_or_element, namespaces=None, extensions=None, regexp=True, smart_strings=True) | |
| Creates an XPath evaluator for an ElementTree or an Element. | |
| The resulting object can be called with an XPath expression as argument | |
| and XPath variables provided as keyword arguments. | |
| Additional namespace declarations can be passed with the | |
| 'namespace' keyword argument. EXSLT regular expression support | |
| can be disabled with the 'regexp' boolean keyword (defaults to | |
| True). Smart strings will be returned for string results unless | |
| you pass ``smart_strings=False``. | |
| """ | |
| if isinstance(etree_or_element, _ElementTree): | |
| return XPathDocumentEvaluator( | |
| etree_or_element, namespaces=namespaces, | |
| extensions=extensions, regexp=regexp, smart_strings=smart_strings) | |
| else: | |
| return XPathElementEvaluator( | |
| etree_or_element, namespaces=namespaces, | |
| extensions=extensions, regexp=regexp, smart_strings=smart_strings) | |
| cdef class XPath(_XPathEvaluatorBase): | |
| """XPath(self, path, namespaces=None, extensions=None, regexp=True, smart_strings=True) | |
| A compiled XPath expression that can be called on Elements and ElementTrees. | |
| Besides the XPath expression, you can pass prefix-namespace | |
| mappings and extension functions to the constructor through the | |
| keyword arguments ``namespaces`` and ``extensions``. EXSLT | |
| regular expression support can be disabled with the 'regexp' | |
| boolean keyword (defaults to True). Smart strings will be | |
| returned for string results unless you pass | |
| ``smart_strings=False``. | |
| """ | |
| cdef xpath.xmlXPathCompExpr* _xpath | |
| cdef bytes _path | |
| def __cinit__(self): | |
| self._xpath = NULL | |
| def __init__(self, path, *, namespaces=None, extensions=None, | |
| regexp=True, smart_strings=True): | |
| cdef xpath.xmlXPathContext* xpathCtxt | |
| _XPathEvaluatorBase.__init__(self, namespaces, extensions, | |
| regexp, smart_strings) | |
| self._path = _utf8(path) | |
| xpathCtxt = xpath.xmlXPathNewContext(NULL) | |
| if xpathCtxt is NULL: | |
| raise MemoryError() | |
| self.set_context(xpathCtxt) | |
| self._xpath = xpath.xmlXPathCtxtCompile(xpathCtxt, _xcstr(self._path)) | |
| if self._xpath is NULL: | |
| raise self._build_parse_error() | |
| def __call__(self, _etree_or_element, **_variables): | |
| "__call__(self, _etree_or_element, **_variables)" | |
| cdef xpath.xmlXPathObject* xpathObj | |
| cdef _Document document | |
| cdef _Element element | |
| assert self._xpathCtxt is not NULL, "XPath context not initialised" | |
| document = _documentOrRaise(_etree_or_element) | |
| element = _rootNodeOrRaise(_etree_or_element) | |
| self._lock() | |
| self._xpathCtxt.doc = document._c_doc | |
| self._xpathCtxt.node = element._c_node | |
| try: | |
| self._context.register_context(document) | |
| self._context.registerVariables(_variables) | |
| with nogil: | |
| xpathObj = xpath.xmlXPathCompiledEval( | |
| self._xpath, self._xpathCtxt) | |
| result = self._handle_result(xpathObj, document) | |
| finally: | |
| self._context.unregister_context() | |
| self._unlock() | |
| return result | |
| @property | |
| def path(self): | |
| """The literal XPath expression. | |
| """ | |
| return self._path.decode('UTF-8') | |
| def __dealloc__(self): | |
| if self._xpath is not NULL: | |
| xpath.xmlXPathFreeCompExpr(self._xpath) | |
| def __repr__(self): | |
| return self.path | |
| cdef object _replace_strings = re.compile(b'("[^"]*")|(\'[^\']*\')').sub | |
| cdef object _find_namespaces = re.compile(b'({[^}]+})').findall | |
| cdef class ETXPath(XPath): | |
| """ETXPath(self, path, extensions=None, regexp=True, smart_strings=True) | |
| Special XPath class that supports the ElementTree {uri} notation for namespaces. | |
| Note that this class does not accept the ``namespace`` keyword | |
| argument. All namespaces must be passed as part of the path | |
| string. Smart strings will be returned for string results unless | |
| you pass ``smart_strings=False``. | |
| """ | |
| def __init__(self, path, *, extensions=None, regexp=True, | |
| smart_strings=True): | |
| path, namespaces = self._nsextract_path(path) | |
| XPath.__init__(self, path, namespaces=namespaces, | |
| extensions=extensions, regexp=regexp, | |
| smart_strings=smart_strings) | |
| cdef _nsextract_path(self, path): | |
| # replace {namespaces} by new prefixes | |
| cdef dict namespaces = {} | |
| cdef list namespace_defs = [] | |
| cdef int i | |
| path_utf = _utf8(path) | |
| stripped_path = _replace_strings(b'', path_utf) # remove string literals | |
| i = 1 | |
| for namespace_def in _find_namespaces(stripped_path): | |
| if namespace_def not in namespace_defs: | |
| prefix = python.PyBytes_FromFormat("__xpp%02d", i) | |
| i += 1 | |
| namespace_defs.append(namespace_def) | |
| namespace = namespace_def[1:-1] # remove '{}' | |
| namespace = (<bytes>namespace).decode('utf8') | |
| namespaces[prefix.decode('utf8')] = namespace | |
| prefix_str = prefix + b':' | |
| # FIXME: this also replaces {namespaces} within strings! | |
| path_utf = path_utf.replace(namespace_def, prefix_str) | |
| path = path_utf.decode('utf8') | |
| return path, namespaces | |