selectolax 0.3.29__cp39-cp39-musllinux_1_2_aarch64.whl → 0.4.0__cp39-cp39-musllinux_1_2_aarch64.whl

selectolax/lexbor/selection.pxi

@@ -1,4 +1,7 @@
 cimport cython
+from cpython.exc cimport PyErr_SetObject
+from cpython.list cimport PyList_GET_SIZE
+
 
 @cython.final
 cdef class LexborCSSSelector:
@@ -8,21 +11,22 @@ cdef class LexborCSSSelector:
         self.results = []
         self.current_node = None
 
-    cdef _create_css_parser(self):
+    cdef int _create_css_parser(self) except -1:
         cdef lxb_status_t status
 
-
         self.parser = lxb_css_parser_create()
         status = lxb_css_parser_init(self.parser, NULL)
 
         if status != LXB_STATUS_OK:
-            raise SelectolaxError("Can't initialize CSS parser.")
+            PyErr_SetObject(SelectolaxError, "Can't initialize CSS parser.")
+            return -1
 
         self.css_selectors = lxb_css_selectors_create()
         status = lxb_css_selectors_init(self.css_selectors)
 
         if status != LXB_STATUS_OK:
-            raise SelectolaxError("Can't initialize CSS selector.")
+            PyErr_SetObject(SelectolaxError, "Can't initialize CSS selector.")
+            return -1
 
         lxb_css_parser_selectors_set(self.parser, self.css_selectors)
 
@@ -30,14 +34,24 @@ cdef class LexborCSSSelector:
         status = lxb_selectors_init(self.selectors)
         lxb_selectors_opt_set(self.selectors, LXB_SELECTORS_OPT_MATCH_ROOT)
         if status != LXB_STATUS_OK:
-            raise SelectolaxError("Can't initialize CSS selector.")
+            PyErr_SetObject(SelectolaxError, "Can't initialize CSS selector.")
+            return -1
+        return 0
+
+    cpdef list find(self, str query, LexborNode node):
+        return self._find(query, node, 0)
 
+    cpdef list find_first(self, str query, LexborNode node):
+        return self._find(query, node, 1)
 
-    cpdef find(self, str query, LexborNode node):
+    cpdef list _find(self, str query, LexborNode node, bint only_first):
         cdef lxb_css_selector_list_t* selectors
         cdef lxb_char_t* c_selector
         cdef lxb_css_selector_list_t * selectors_list
 
+        if not isinstance(query, str):
+            raise TypeError("Query must be a string.")
+
         bytes_query = query.encode(_ENCODING)
         selectors_list = lxb_css_selectors_parse(self.parser, <lxb_char_t *> bytes_query, <size_t>len(query))
 
@@ -46,36 +60,47 @@ cdef class LexborCSSSelector:
 
         self.current_node = node
         self.results = []
-        status = lxb_selectors_find(self.selectors, node.node, selectors_list,
-                                    <lxb_selectors_cb_f>css_finder_callback, <void*>self)
+        if only_first:
+            status = lxb_selectors_find(self.selectors, node.node, selectors_list,
+                                        <lxb_selectors_cb_f>css_finder_callback_first, <void*>self)
+        else:
+            status = lxb_selectors_find(self.selectors, node.node, selectors_list,
+                                        <lxb_selectors_cb_f>css_finder_callback, <void*>self)
         results = list(self.results)
         self.results = []
         self.current_node = None
         lxb_css_selector_list_destroy_memory(selectors_list)
         return results
 
-    cpdef any_matches(self, str query, LexborNode node):
+    cpdef int any_matches(self, str query, LexborNode node) except -1:
         cdef lxb_css_selector_list_t * selectors
         cdef lxb_char_t * c_selector
         cdef lxb_css_selector_list_t * selectors_list
+        cdef int result
+
+        if not isinstance(query, str):
+            raise TypeError("Query must be a string.")
 
         bytes_query = query.encode(_ENCODING)
         selectors_list = lxb_css_selectors_parse(self.parser, <lxb_char_t *> bytes_query, <size_t> len(query))
 
         if selectors_list == NULL:
-            raise SelectolaxError("Can't parse CSS selector.")
+            PyErr_SetObject(SelectolaxError, "Can't parse CSS selector.")
+            return -1
 
         self.results = []
         status = lxb_selectors_find(self.selectors, node.node, selectors_list,
                                     <lxb_selectors_cb_f> css_matcher_callback, <void *> self)
         if status != LXB_STATUS_OK:
-            raise SelectolaxError("Can't parse CSS selector.")
-        result = bool(self.results)
+            lxb_css_selector_list_destroy_memory(selectors_list)
+            PyErr_SetObject(SelectolaxError, "Can't parse CSS selector.")
+            return -1
+
+        result = PyList_GET_SIZE(self.results) > 0
         self.results = []
         lxb_css_selector_list_destroy_memory(selectors_list)
         return result
 
-
     def __dealloc__(self):
         if self.selectors != NULL:
             lxb_selectors_destroy(self.selectors, True)
@@ -85,7 +110,6 @@ cdef class LexborCSSSelector:
             lxb_css_selectors_destroy(self.css_selectors, True)
 
 
-
 cdef class LexborSelector:
     """An advanced CSS selector that supports additional operations.
 
@@ -100,10 +124,9 @@ cdef class LexborSelector:
         self.node = node
         self.nodes = self.node.parser.selector.find(query, self.node) if query else [node, ]
 
-
     cpdef css(self, str query):
         """Evaluate CSS selector against current scope."""
-        raise SelectolaxError("This features is not supported by the lexbor backend. Please use Modest backend.")
+        raise NotImplementedError("This features is not supported by the lexbor backend. Please use Modest backend.")
 
     @property
     def matches(self) -> list:
@@ -117,7 +140,7 @@ cdef class LexborSelector:
 
     def text_contains(self, str text, bool deep=True, str separator='', bool strip=False) -> LexborSelector:
         """Filter all current matches given text."""
-        nodes = []
+        cdef list nodes = []
         for node in self.nodes:
             node_text = node.text(deep=deep, separator=separator, strip=strip)
             if node_text and text in node_text:
@@ -127,7 +150,7 @@ cdef class LexborSelector:
 
     def any_text_contains(self, str text, bool deep=True, str separator='', bool strip=False) -> bool:
         """Returns True if any node in the current search scope contains specified text"""
-        nodes = []
+        cdef LexborNode node
         for node in self.nodes:
             node_text = node.text(deep=deep, separator=separator, strip=strip)
             if node_text and text in node_text:
@@ -139,7 +162,7 @@ cdef class LexborSelector:
 
         Similar to `string-length` in XPath.
         """
-        nodes = []
+        cdef list nodes = []
         for node in self.nodes:
             attr = node.attributes.get(attribute)
             if attr and start and start in attr:
@@ -154,7 +177,7 @@ cdef class LexborSelector:
 
         Similar to `string-length` in XPath.
         """
-        nodes = []
+        cdef LexborNode node
         for node in self.nodes:
             attr = node.attributes.get(attribute)
             if attr and start and start in attr:
@@ -169,16 +192,24 @@ cdef class LexborSelector:
 
 cdef lxb_status_t css_finder_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
     cdef LexborNode lxb_node
-    cdef object cls
-    cls = <object> ctx
-    lxb_node = LexborNode()
-    lxb_node._cinit(<lxb_dom_node_t *> node, cls.current_node.parser)
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
+    lxb_node = LexborNode.new(<lxb_dom_node_t *> node, cls.current_node.parser)
     cls.results.append(lxb_node)
     return LXB_STATUS_OK
 
+cdef lxb_status_t css_finder_callback_first(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
+    cdef LexborNode lxb_node
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
+    lxb_node = LexborNode.new(<lxb_dom_node_t *> node, cls.current_node.parser)
+    cls.results.append(lxb_node)
+    return LXB_STATUS_STOP
+
+
 cdef lxb_status_t css_matcher_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
     cdef LexborNode lxb_node
-    cdef object cls
-    cls = <object> ctx
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
     cls.results.append(True)
     return LXB_STATUS_STOP

selectolax/lexbor/util.pxi

@@ -1,5 +1,6 @@
 include "../utils.pxi"
 
+
 def create_tag(tag: str):
     """
     Given an HTML tag name, e.g. `"div"`, create a single empty node for that tag,