selectolax 0.3.30__cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

selectolax/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+__author__ = """Artem Golubin"""
+__email__ = 'me@rushter.com'
+__version__ = '0.3.30'
+
+from . import parser
+from . import lexbor
+from . import modest

selectolax/base.pxi

@@ -0,0 +1,4 @@
+
+class SelectolaxError(Exception):
+    """An exception that indicates error."""
+    pass

selectolax/lexbor/attrs.pxi

@@ -0,0 +1,103 @@
+cimport cython
+
+@cython.final
+cdef class LexborAttributes:
+    """A dict-like object that represents attributes."""
+    cdef lxb_dom_node_t *node
+    cdef unicode decode_errors
+
+    @staticmethod
+    cdef LexborAttributes create(lxb_dom_node_t *node):
+        obj = <LexborAttributes> LexborAttributes.__new__(LexborAttributes)
+        obj.node = node
+        return obj
+
+    def __iter__(self):
+        cdef lxb_dom_attr_t *attr = lxb_dom_element_first_attribute_noi(<lxb_dom_element_t *> self.node)
+        cdef size_t str_len = 0
+        attributes = dict()
+
+        while attr != NULL:
+            key = lxb_dom_attr_local_name_noi(attr, &str_len)
+            if key is not NULL:
+                yield key.decode(_ENCODING)
+            attr = attr.next
+
+    def __setitem__(self, str key, value):
+        value = str(value)
+        bytes_key = key.encode(_ENCODING)
+        bytes_value = value.encode(_ENCODING)
+
+        lxb_dom_element_set_attribute(
+            <lxb_dom_element_t *> self.node,
+            <lxb_char_t *> bytes_key, len(bytes_key),
+            <lxb_char_t *> bytes_value, len(bytes_value),
+        )
+
+    def __delitem__(self, key):
+        try:
+            self.__getitem__(key)
+        except KeyError:
+            raise KeyError(key)
+        bytes_key = key.encode(_ENCODING)
+        lxb_dom_element_remove_attribute(
+            <lxb_dom_element_t *> self.node,
+            <lxb_char_t *> bytes_key, len(bytes_key),
+        )
+
+    def __getitem__(self, str key):
+        bytes_key = key.encode(_ENCODING)
+        cdef lxb_dom_attr_t * attr = lxb_dom_element_attr_by_name(
+            <lxb_dom_element_t *> self.node,
+            <lxb_char_t *> bytes_key, len(bytes_key)
+        )
+        cdef size_t str_len = 0
+        if attr != NULL:
+            value = lxb_dom_attr_value_noi(attr, &str_len)
+            return value.decode(_ENCODING) if value else None
+        raise KeyError(key)
+
+    def __len__(self):
+        return len(list(self.__iter__()))
+
+    def keys(self):
+        return self.__iter__()
+
+    def items(self):
+        for key in self.__iter__():
+            yield key, self[key]
+
+    def values(self):
+        for key in self.__iter__():
+            yield self[key]
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def sget(self, key, default=""):
+        """Same as get, but returns empty strings instead of None values for empty attributes."""
+        try:
+            val = self[key]
+            if val is None:
+                val = ""
+            return val
+        except KeyError:
+            return default
+
+    def __contains__(self, key):
+        try:
+            self[key]
+        except KeyError:
+            return False
+        else:
+            return True
+
+    def __repr__(self):
+        cdef lxb_char_t *c_text
+        cdef size_t str_len = 0
+        c_text = lxb_dom_element_qualified_name(<lxb_dom_element_t *> self.node, &str_len)
+        tag_name = c_text.decode(_ENCODING, 'ignore') if c_text != NULL else 'unknown'
+        return "<%s attributes, %s items>" % (tag_name, len(self))