selectolax 0.3.31__cp311-cp311-win_amd64.whl → 0.3.33__cp311-cp311-win_amd64.whl

selectolax/modest/node.pxi

@@ -1,4 +1,5 @@
 cimport cython
+from cpython.exc cimport PyErr_NoMemory
 
 from libc.stdlib cimport free
 from libc.stdlib cimport malloc
@@ -8,6 +9,7 @@ from libc.string cimport memcpy
 DEF _STACK_SIZE = 100
 DEF _ENCODING = 'UTF-8'
 
+
 @cython.final
 cdef class Stack:
     def __cinit__(self, size_t capacity=25):
@@ -23,9 +25,10 @@ cdef class Stack:
     cdef bint is_empty(self):
         return self.top <= 0
 
-    cdef push(self, myhtml_tree_node_t* res):
+    cdef int push(self, myhtml_tree_node_t* res) except -1:
         if self.top >= self.capacity:
-            self.resize()
+            if self.resize() < 0:
+                return -1
         self._stack[self.top] = res
         self.top += 1
 
@@ -33,10 +36,13 @@ cdef class Stack:
         self.top = self.top - 1
         return self._stack[self.top]
 
-    cdef resize(self):
+    cdef int resize(self) except -1:
         self.capacity *= 2
         self._stack = <myhtml_tree_node_t**> realloc(<void*> self._stack, self.capacity * sizeof(myhtml_tree_node_t))
-
+        if self._stack == NULL:
+            PyErr_NoMemory()
+            return -1
+        return 0
 
 cdef class _Attributes:
     """A dict-like object that represents attributes."""
@@ -130,25 +136,24 @@ cdef class _Attributes:
         tag_name = c_text.decode(_ENCODING, 'ignore') if c_text != NULL else 'unknown'
         return "<%s attributes, %s items>" % (tag_name, len(self))
 
-
-
 ctypedef fused str_or_Node:
     str
     bytes
     Node
 
-
 cdef class Node:
     """A class that represents HTML node (element)."""
     cdef myhtml_tree_node_t *node
     cdef public HTMLParser parser
 
-
-    cdef _init(self, myhtml_tree_node_t *node, HTMLParser parser):
-        # custom init, because __cinit__ doesn't accept C types
-        self.node = node
+    @staticmethod
+    cdef Node new(myhtml_tree_node_t *node, HTMLParser parser):
+        # custom __init__ for C, because __cinit__ doesn't accept C types
+        cdef Node cls = Node.__new__(Node)
+        cls.node = node
         # Keep reference to the selector object, so myhtml structures will not be garbage collected prematurely
-        self.parser = parser
+        cls.parser = parser
+        return cls
 
     @property
     def attributes(self):
@@ -288,7 +293,7 @@ cdef class Node:
     cdef inline _text_deep(self, myhtml_tree_node_t *node, separator='', strip=False):
         text = ""
         cdef Stack stack = Stack(_STACK_SIZE)
-        cdef myhtml_tree_node_t* current_node = NULL;
+        cdef myhtml_tree_node_t* current_node = NULL
 
         if node.tag_id == MyHTML_TAG__TEXT:
             c_text = myhtml_node_text(node, NULL)
@@ -341,12 +346,10 @@ cdef class Node:
                 node = node.next
                 continue
 
-            next_node = Node()
-            next_node._init(node, self.parser)
+            next_node = Node.new(node, self.parser)
             yield next_node
             node = node.next
 
-
     def traverse(self, include_text=False):
         """Iterate over all child and next nodes starting from the current level.
 
@@ -360,16 +363,15 @@ cdef class Node:
         node
         """
         cdef Stack stack = Stack(_STACK_SIZE)
-        cdef myhtml_tree_node_t* current_node = NULL;
-        cdef Node next_node;
+        cdef myhtml_tree_node_t* current_node = NULL
+        cdef Node next_node
 
         stack.push(self.node)
 
         while not stack.is_empty():
             current_node = stack.pop()
             if current_node != NULL and not (current_node.tag_id == MyHTML_TAG__TEXT and not include_text):
-                next_node = Node()
-                next_node._init(current_node, self.parser)
+                next_node = Node.new(current_node, self.parser)
                 yield next_node
 
             if current_node.next is not NULL:
@@ -398,8 +400,7 @@ cdef class Node:
         """Return the child node."""
         cdef Node node
         if self.node.child:
-            node = Node()
-            node._init(self.node.child, self.parser)
+            node = Node.new(self.node.child, self.parser)
             return node
         return None
 
@@ -408,8 +409,7 @@ cdef class Node:
         """Return the parent node."""
         cdef Node node
         if self.node.parent:
-            node = Node()
-            node._init(self.node.parent, self.parser)
+            node = Node.new(self.node.parent, self.parser)
             return node
         return None
 
@@ -418,8 +418,7 @@ cdef class Node:
         """Return next node."""
         cdef Node node
         if self.node.next:
-            node = Node()
-            node._init(self.node.next, self.parser)
+            node = Node.new(self.node.next, self.parser)
             return node
         return None
 
@@ -428,8 +427,7 @@ cdef class Node:
         """Return previous node."""
         cdef Node node
         if self.node.prev:
-            node = Node()
-            node._init(self.node.prev, self.parser)
+            node = Node.new(self.node.prev, self.parser)
             return node
         return None
 
@@ -438,8 +436,7 @@ cdef class Node:
         """Return last child node."""
         cdef Node node
         if self.node.last_child:
-            node = Node()
-            node._init(self.node.last_child, self.parser)
+            node = Node.new(self.node.last_child, self.parser)
             return node
         return None
 
@@ -539,8 +536,8 @@ cdef class Node:
             if delete_empty:
                 myhtml_node_delete(self.node)
             return
-        cdef myhtml_tree_node_t* next_node;
-        cdef myhtml_tree_node_t* current_node;
+        cdef myhtml_tree_node_t* next_node
+        cdef myhtml_tree_node_t* current_node
 
         if self.node.child.next != NULL:
             current_node = self.node.child
@@ -574,6 +571,8 @@ cdef class Node:
         '<html><body><div>Hello world!</div></body></html>'
 
         """
+        # ensure cython can recast element to a Node so that decompose will be called sooner.
+        cdef Node element
         for tag in tags:
             for element in self.css(tag):
                 element.decompose(recursive=recursive)
@@ -600,7 +599,7 @@ cdef class Node:
 
         Note: by default, empty tags are ignored, set "delete_empty" to "True" to change this.
         """
-
+        cdef Node element
         for tag in tags:
             for element in self.css(tag):
                 element.unwrap(delete_empty)
@@ -788,7 +787,7 @@ cdef class Node:
 
         Note: by default, empty tags are ignored, set "delete_empty" to "True" to change this.
         """
-
+        cdef Node element
         for tag in tags:
             for element in self.css(tag):
                 element.unwrap(delete_empty)
@@ -847,6 +846,7 @@ cdef class Node:
             The query to check.
 
         """
+        cdef Node node
         if self.parser.cached_script_texts is None:
             nodes = find_nodes(self.parser, self.node, 'script')
             text_nodes = []
@@ -895,6 +895,7 @@ cdef class Node:
         if not isinstance(other, Node):
             return False
         return self.html == other.html
+
     @property
     def text_content(self):
         """Returns the text of the node if it is a text node.
@@ -948,8 +949,8 @@ cdef class Node:
         while not stack.is_empty():
             current_node = stack.pop()
 
-            if current_node.tag_id == MyHTML_TAG__TEXT and current_node.prev and \
-                current_node.prev.tag_id == MyHTML_TAG__TEXT:
+            if (current_node.tag_id == MyHTML_TAG__TEXT and current_node.prev and
+                    current_node.prev.tag_id == MyHTML_TAG__TEXT):
                 left_text = myhtml_node_text(current_node.prev, &left_length)
                 right_text = myhtml_node_text(current_node, &right_length)
                 if left_text and right_text:

selectolax/modest/selection.pxi

@@ -1,4 +1,6 @@
 cimport cython
+from cpython.exc cimport PyErr_SetObject
+
 
 @cython.final
 cdef class CSSSelector:
@@ -28,35 +30,33 @@ cdef class CSSSelector:
 
         return collection
 
-
-    cdef _create_css_parser(self):
+    cdef int _create_css_parser(self) except -1:
         cdef mystatus_t status
 
         cdef mycss_t *mycss = mycss_create()
         status = mycss_init(mycss)
 
         if status != 0:
-            raise RuntimeError("Can't init MyCSS object.")
-            # return
+            PyErr_SetObject(RuntimeError, "Can't init MyCSS object.")
+            return -1
 
         self.css_entry = mycss_entry_create()
         status = mycss_entry_init(mycss, self.css_entry)
 
         if status != 0:
-            raise RuntimeError("Can't init MyCSS Entry object.")
-
-
+            PyErr_SetObject(RuntimeError, "Can't init MyCSS Entry object.")
+            return -1
+        return 0
 
-    cdef _prepare_selector(self, mycss_entry_t *css_entry,
-                                                   const char *selector, size_t selector_size):
-        cdef mystatus_t out_status;
-        self.selectors_list = mycss_selectors_parse(mycss_entry_selectors(css_entry),
-                                                         myencoding_t.MyENCODING_UTF_8,
-                                                         selector, selector_size,
-                                                         &out_status)
+    cdef int _prepare_selector(self, mycss_entry_t *css_entry, const char *selector, size_t selector_size) except -1:
+        cdef mystatus_t out_status
+        self.selectors_list = mycss_selectors_parse(mycss_entry_selectors(css_entry), myencoding_t.MyENCODING_UTF_8,
+                                                    selector, selector_size, &out_status)
 
         if (self.selectors_list == NULL) or (self.selectors_list.flags and MyCSS_SELECTORS_FLAGS_SELECTOR_BAD):
-            raise  ValueError("Bad CSS Selectors: %s" % self.c_selector.decode('utf-8'))
+            PyErr_SetObject(ValueError, "Bad CSS Selectors: %s" % self.c_selector.decode('utf-8'))
+            return -1
+        return 0
 
     def __dealloc__(self):
         mycss_selectors_list_destroy(mycss_entry_selectors(self.css_entry), self.selectors_list, 1)
@@ -77,12 +77,11 @@ cdef class Selector:
     cdef Node node
     cdef list nodes
 
-    def __init__(self, Node node, query):
+    def __init__(self, Node node, str query):
         """custom init, because __cinit__ doesn't accept C types"""
         self.node = node
         self.nodes = find_nodes(node.parser, node.node, query) if query else [node, ]
 
-
     cpdef css(self, str query):
         """Evaluate CSS selector against current scope."""
         cdef Node current_node
@@ -106,6 +105,7 @@ cdef class Selector:
     def text_contains(self, str text, bool deep=True, str separator='', bool strip=False):
         """Filter all current matches given text."""
         nodes = []
+        cdef Node node
         for node in self.nodes:
             node_text = node.text(deep=deep, separator=separator, strip=strip)
             if node_text and text in node_text:
@@ -116,6 +116,7 @@ cdef class Selector:
     def any_text_contains(self, str text, bool deep=True, str separator='', bool strip=False):
         """Returns True if any node in the current search scope contains specified text"""
         nodes = []
+        cdef Node node
         for node in self.nodes:
             node_text = node.text(deep=deep, separator=separator, strip=strip)
             if node_text and text in node_text:
@@ -142,7 +143,8 @@ cdef class Selector:
 
         Similar to `string-length` in XPath.
         """
-        nodes = []
+        cdef list nodes = []
+        cdef Node node
         for node in self.nodes:
             attr = node.attributes.get(attribute)
             if attr and start and start in attr:
@@ -157,16 +159,15 @@ cdef class Selector:
 cdef find_nodes(HTMLParser parser, myhtml_tree_node_t *node, str query):
     cdef myhtml_collection_t *collection
     cdef CSSSelector selector = CSSSelector(query)
-
-    result = list()
+    cdef Node n
+    cdef list result = []
     collection = selector.find(node)
 
     if collection == NULL:
         return result
 
     for i in range(collection.length):
-        n = Node()
-        n._init(collection.list[i], parser)
+        n = Node.new(collection.list[i], parser)
         result.append(n)
     myhtml_collection_destroy(collection)
     return result
@@ -176,6 +177,7 @@ cdef bool find_matches(HTMLParser parser, myhtml_tree_node_t *node, tuple select
     cdef myhtml_collection_t *collection
     cdef CSSSelector selector
     cdef int collection_size
+    cdef str query
 
     for query in selectors:
         selector = CSSSelector(query)

selectolax/modest/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,