| # 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 |
| |
