selectolax 0.3.34__cp310-cp310-win_arm64.whl → 0.4.0__cp310-cp310-win_arm64.whl

selectolax/__init__.py

@@ -3,6 +3,6 @@
 
 __author__ = """Artem Golubin"""
 __email__ = "me@rushter.com"
-__version__ = "0.3.34"
+__version__ = "0.4.0"
 
 from . import lexbor, modest, parser

selectolax/lexbor/node.pxi

@@ -1,8 +1,12 @@
 cimport cython
 from cpython.exc cimport PyErr_SetNone
 
+import logging
+
+logger = logging.getLogger("selectolax")
+
 _TAG_TO_NAME = {
-    0x0005: "- doctype",
+    0x0005: "-doctype",
     0x0002: "-text",
     0x0004: "-comment",
 }
@@ -11,6 +15,10 @@ ctypedef fused str_or_LexborNode:
     bytes
     LexborNode
 
+ctypedef fused str_or_bytes:
+    str
+    bytes
+
 cdef inline bytes to_bytes(str_or_LexborNode value):
     cdef bytes bytes_val
     if isinstance(value, unicode):
@@ -37,7 +45,10 @@ cdef class LexborNode:
 
     @property
     def child(self):
-        """Alias for the `first_child` property."""
+        """Alias for the `first_child` property.
+
+        **Deprecated**. Please use `first_child` instead.
+        """
         return self.first_child
 
     @property
@@ -200,13 +211,15 @@ cdef class LexborNode:
     def css_first(self, str query, default=None, bool strict=False):
         """Same as `css` but returns only the first match.
 
+        When `strict=False` stops at the first match. Works faster.
+
         Parameters
         ----------
 
         query : str
-        default : bool, default None
+        default : Any, default None
             Default value to return if there is no match.
-        strict: bool, default True
+        strict: bool, default False
             Set to True if you want to check if there is strictly only one match in the document.
 
 
@@ -214,8 +227,10 @@ cdef class LexborNode:
         -------
         selector : `LexborNode` object
         """
-        # TODO: This can be improved.
-        results = self.css(query)
+        if strict:
+            results = self.parser.selector.find(query, self)
+        else:
+            results = self.parser.selector.find_first(query, self)
         n_results = len(results)
         if n_results > 0:
             if strict and n_results > 1:
@@ -232,7 +247,7 @@ cdef class LexborNode:
 
     def css_matches(self, str selector):
         """Returns True if CSS selector matches a node."""
-        return self.parser.selector.any_matches(selector, self)
+        return bool(self.parser.selector.any_matches(selector, self))
 
     def __repr__(self):
         return '<LexborNode %s>' % self.tag
@@ -246,6 +261,14 @@ cdef class LexborNode:
     def tag(self):
         """Return the name of the current tag (e.g. div, p, img).
 
+        For for non-tag nodes, returns the following names:
+
+         * `-text` - text node
+         * `-document` - document node
+         * `-comment` - comment node
+
+        This
+
         Returns
         -------
         text : str
@@ -281,9 +304,9 @@ cdef class LexborNode:
             raise SelectolaxError("Decomposing the root node is not allowed.")
 
         if recursive:
-            lxb_dom_node_destroy_deep(<lxb_dom_node_t *> self.node)
+            node_remove_deep(<lxb_dom_node_t *> self.node)
         else:
-            lxb_dom_node_destroy(<lxb_dom_node_t *> self.node)
+            lxb_dom_node_remove(<lxb_dom_node_t *> self.node)
 
     def strip_tags(self, list tags, bool recursive = False):
         """Remove specified tags from the HTML tree.
@@ -332,6 +355,9 @@ cdef class LexborNode:
         cdef size_t str_len = 0
         attributes = dict()
 
+        if self.node.type != LXB_DOM_NODE_TYPE_ELEMENT:
+            return attributes
+
         while attr != NULL:
             key = lxb_dom_attr_local_name_noi(attr, &str_len)
             value = lxb_dom_attr_value_noi(attr, &str_len)
@@ -424,6 +450,8 @@ cdef class LexborNode:
     def unwrap(self, bint delete_empty=False):
         """Replace node with whatever is inside this node.
 
+        Does nothing if you perform unwrapping second time on the same node.
+
         Parameters
         ----------
         delete_empty : bool, default False
@@ -439,9 +467,14 @@ cdef class LexborNode:
 
         Note: by default, empty tags are ignored, use "delete_empty" to change this.
         """
+
+        if node_is_removed(<lxb_dom_node_t *> self.node) == 1:
+            logger.error("Attempt to unwrap removed node. Does nothing.")
+            return
+
         if self.node.first_child == NULL:
             if delete_empty:
-                lxb_dom_node_destroy(<lxb_dom_node_t *> self.node)
+                lxb_dom_node_remove(<lxb_dom_node_t *> self.node)
             return
         cdef lxb_dom_node_t* next_node
         cdef lxb_dom_node_t* current_node
@@ -456,7 +489,7 @@ cdef class LexborNode:
                 current_node = next_node
         else:
             lxb_dom_node_insert_before(self.node, self.node.first_child)
-        lxb_dom_node_destroy(<lxb_dom_node_t *> self.node)
+        lxb_dom_node_remove(<lxb_dom_node_t *> self.node)
 
     def unwrap_tags(self, list tags, bint delete_empty = False):
         """Unwraps specified tags from the HTML tree.
@@ -518,6 +551,12 @@ cdef class LexborNode:
                     combined = (<bytes>left_text[:left_length]) + (<bytes>right_text[:right_length])
                     lxb_dom_node_text_content_set(node, combined, len(combined))
                     lxb_dom_node_remove(node.prev)
+
+                if left_text is not NULL:
+                    lxb_dom_document_destroy_text_noi(self.node.owner_document, left_text)
+                if right_text is not NULL:
+                    lxb_dom_document_destroy_text_noi(self.node.owner_document, right_text)
+
             if node.first_child:
                 LexborNode.new(node, self.parser).merge_text_nodes()
             node = next_node
@@ -590,7 +629,7 @@ cdef class LexborNode:
             if new_node == NULL:
                 raise SelectolaxError("Can't create a new node")
             lxb_dom_node_insert_before(self.node,  new_node)
-            lxb_dom_node_destroy(<lxb_dom_node_t *> self.node)
+            lxb_dom_node_remove(<lxb_dom_node_t *> self.node)
         elif isinstance(value, LexborNode):
             new_node = lxb_dom_document_import_node(
                 &self.parser.document.dom_document,
@@ -600,7 +639,7 @@ cdef class LexborNode:
             if new_node == NULL:
                 raise SelectolaxError("Can't create a new node")
             lxb_dom_node_insert_before(self.node, <lxb_dom_node_t *> new_node)
-            lxb_dom_node_destroy(<lxb_dom_node_t *> self.node)
+            lxb_dom_node_remove(<lxb_dom_node_t *> self.node)
         else:
             raise SelectolaxError("Expected a string or LexborNode instance, but %s found" % type(value).__name__)
 
@@ -883,6 +922,61 @@ cdef class LexborNode:
             container.append(py_text)
             return container.text
 
+    @property
+    def inner_html(self) -> str:
+        """Return HTML representation of the child nodes.
+
+        Works similar to innerHTML in JavaScript.
+        Unlike the `.html` property, does not include the current node.
+        Can be used to set HTML as well. See the setter docstring.
+
+        Returns
+        -------
+        text : str | None
+        """
+
+        cdef lexbor_str_t *lxb_str
+        cdef lxb_status_t status
+
+        lxb_str = lexbor_str_create()
+        status = lxb_html_serialize_deep_str(self.node, lxb_str)
+        if status == 0 and lxb_str.data:
+            html = lxb_str.data.decode(_ENCODING).replace('<-undef>', '')
+            lexbor_str_destroy(lxb_str,  self.node.owner_document.text, True)
+            return html
+        return None
+
+    @inner_html.setter
+    def inner_html(self, str html):
+        """Set inner HTML to the specified HTML.
+
+        Replaces existing data inside the node.
+        Works similar to innerHTML in JavaScript.
+
+        Parameters
+        ----------
+        html : str | None
+
+        """
+        cdef bytes bytes_val
+        bytes_val = <bytes>html.encode("utf-8")
+        lxb_html_element_inner_html_set(
+                <lxb_html_element_t  *>self.node,
+                <lxb_char_t *> bytes_val, len(bytes_val)
+        )
+
+    def clone(self) -> LexborNode:
+        """Clone the current node.
+
+        You can use to do temporary modifications without affecting the original HTML tree.
+
+        It is tied to the current parser instance.
+        Gets destroyed when parser instance is destroyed.
+        """
+        cdef lxb_dom_node_t* node
+        node = lxb_dom_node_clone(<lxb_dom_node_t *> self.node, 1)
+        return LexborNode.new(node, self.parser)
+
 
 @cython.internal
 @cython.final
@@ -928,7 +1022,7 @@ cdef lexbor_action_t text_callback(lxb_dom_node_t *node, void *ctx):
         return LEXBOR_ACTION_OK
 
     try:
-        py_str = text.decode(_ENCODING)
+        py_str = text.decode(_ENCODING, "replace")
 
     except Exception as e:
         PyErr_SetNone(e)

selectolax/lexbor/node_remove.pxi

@@ -0,0 +1,29 @@
+
+cdef lxb_dom_node_t * node_remove_deep(lxb_dom_node_t* root):
+    cdef lxb_dom_node_t *tmp
+    cdef lxb_dom_node_t *node = root
+
+    while node != NULL:
+        if node.first_child != NULL:
+            node = node.first_child
+        else:
+            while node != root and node.next == NULL:
+                tmp = node.parent
+                lxb_dom_node_remove(node)
+                node = tmp
+
+            if node == root:
+                lxb_dom_node_remove(node)
+                break
+
+            tmp = node.next
+            lxb_dom_node_remove(node)
+            node = tmp
+
+    return NULL
+
+cdef bint node_is_removed(lxb_dom_node_t* node):
+    if node.parent == NULL and node.next == NULL \
+       and node.prev == NULL:
+        return 1
+    return 0

selectolax/lexbor/selection.pxi

@@ -39,6 +39,12 @@ cdef class LexborCSSSelector:
         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 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
@@ -54,8 +60,12 @@ 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
@@ -76,6 +86,7 @@ cdef class LexborCSSSelector:
 
         if selectors_list == NULL:
             PyErr_SetObject(SelectolaxError, "Can't parse CSS selector.")
+            return -1
 
         self.results = []
         status = lxb_selectors_find(self.selectors, node.node, selectors_list,
@@ -83,6 +94,8 @@ cdef class LexborCSSSelector:
         if status != LXB_STATUS_OK:
             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)
@@ -185,6 +198,15 @@ cdef lxb_status_t css_finder_callback(lxb_dom_node_t *node, lxb_css_selector_spe
     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 LexborCSSSelector cls