selectolax 0.3.25__tar.gz → 0.3.26__tar.gz

{selectolax-0.3.25 → selectolax-0.3.26}/CHANGES.rst

@@ -1,6 +1,17 @@
 selectolax Changelog
 ====================
 
+
+Version 0.3.26
+-------------
+
+Released
+
+- Improve type hints
+
+
+
+
 Version 0.3.25
 -------------
 

{selectolax-0.3.25/selectolax.egg-info → selectolax-0.3.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: selectolax
-Version: 0.3.25
+Version: 0.3.26
 Summary: Fast HTML5 parser with CSS selectors.
 Home-page: https://github.com/rushter/selectolax
 Author: Artem Golubin

{selectolax-0.3.25 → selectolax-0.3.26}/docs/conf.py

@@ -49,6 +49,8 @@ extensions = [
     'sphinx.ext.autodoc',
     'sphinx.ext.viewcode',
     'numpydoc',
+    'sphinxext.opengraph',
+    'sphinx_copybutton'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -65,7 +67,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'selectolax'
-copyright = u"2018-2023, Artem Golubin"
+copyright = u"2018-2024, Artem Golubin"
 
 # The version info for the project you're documenting, acts as replacement
 # for |version| and |release|, also used in various other places throughout
@@ -121,12 +123,16 @@ pygments_style = 'sphinx'
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 # html_theme = 'default'
-html_theme = 'sphinx_rtd_theme'
+html_theme = 'furo'
 
 # Theme options are theme-specific and customize the look and feel of a
 # theme further.  For a list of options available for each theme, see the
 # documentation.
-# html_theme_options = {}
+html_theme_options = {
+    "source_repository": "https://github.com/rushter/selectolax",
+    "source_branch": "master",
+    "source_directory": "docs/",
+}
 
 # Add any paths that contain custom themes here, relative to this directory.
 # html_theme_path = []
@@ -141,7 +147,7 @@ html_theme = 'sphinx_rtd_theme'
 
 # The name of an image file (relative to this directory) to place at the
 # top of the sidebar.
-# html_logo = None
+html_logo = "logo.png"
 
 # The name of an image file (within the static path) to use as favicon
 # of the docs.  This file should be a Windows icon file (.ico) being

{selectolax-0.3.25 → selectolax-0.3.26}/selectolax/__init__.py

@@ -3,7 +3,7 @@
 
 __author__ = """Artem Golubin"""
 __email__ = 'me@rushter.com'
-__version__ = '0.3.25'
+__version__ = '0.3.26'
 
 from . import parser
 from . import lexbor

selectolax-0.3.26/selectolax/lexbor.pyi

@@ -0,0 +1,172 @@
+from typing import Any, Iterator, Literal, TypeVar, NoReturn, overload
+
+DefaultT = TypeVar("DefaultT")
+
+class LexborAttributes:
+    @staticmethod
+    def create(node: LexborAttributes) -> LexborAttributes: ...
+    def keys(self) -> Iterator[str]: ...
+    def items(self) -> Iterator[tuple[str, str | None]]: ...
+    def values(self) -> Iterator[str | None]: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: str) -> str | None: ...
+    def __setitem__(self, key: str, value: str) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __repr__(self) -> str: ...
+    @overload
+    def get(self, key: str, default: DefaultT) -> DefaultT | str | None: ...
+    @overload
+    def get(self, key: str, default: None = ...) -> str | None: ...
+    @overload
+    def sget(self, key: str, default: str | DefaultT) -> str | DefaultT: ...
+    @overload
+    def sget(self, key: str, default: str = "") -> str: ...
+
+class LexborSelector:
+    def __init__(self, node: LexborNode, query: str): ...
+    def css(self, query: str) -> NoReturn: ...
+    @property
+    def matches(self) -> list[LexborNode]: ...
+    @property
+    def any_matches(self) -> bool: ...
+    def text_contains(
+        self, text: str, deep: bool = True, separator: str = "", strip: bool = False
+    ) -> LexborSelector: ...
+    def any_text_contains(
+        self, text: str, deep: bool = True, separator: str = "", strip: bool = False
+    ) -> bool: ...
+    def attribute_longer_than(
+        self, attribute: str, length: int, start: str | None = None
+    ) -> LexborSelector: ...
+    def any_attribute_longer_than(
+        self, attribute: str, length: int, start: str | None = None
+    ) -> bool: ...
+
+class LexborCSSSelector:
+    def __init__(self): ...
+    def find(self, query: str, node: LexborNode) -> list[LexborNode]: ...
+    def any_matches(self, query: str, node: LexborNode) -> bool: ...
+
+class LexborNode:
+    parser: LexborHTMLParser
+    @property
+    def mem_id(self) -> int: ...
+    @property
+    def child(self) -> LexborNode | None: ...
+    @property
+    def first_child(self) -> LexborNode | None: ...
+    @property
+    def parent(self) -> LexborNode | None: ...
+    @property
+    def next(self) -> LexborNode | None: ...
+    @property
+    def prev(self) -> LexborNode | None: ...
+    @property
+    def last_child(self) -> LexborNode | None: ...
+    @property
+    def html(self) -> str | None: ...
+    def __hash__(self) -> int: ...
+    def text_lexbor(self) -> str: ...
+    def text(
+        self, deep: bool = True, separator: str = "", strip: bool = False
+    ) -> str: ...
+    def css(self, query: str) -> list[LexborNode]: ...
+    @overload
+    def css_first(
+        self, query: str, default: Any = ..., strict: Literal[True] = ...
+    ) -> LexborNode: ...
+    @overload
+    def css_first(
+        self, query: str, default: DefaultT, strict: bool = False
+    ) -> LexborNode | DefaultT: ...
+    @overload
+    def css_first(
+        self, query: str, default: None = ..., strict: bool = False
+    ) -> LexborNode | None: ...
+    def any_css_matches(self, selectors: tuple[str]) -> bool: ...
+    def css_matches(self, selector: str) -> bool: ...
+    @property
+    def tag_id(self) -> int: ...
+    @property
+    def tag(self) -> str | None: ...
+    def decompose(self, recursive: bool = True) -> None: ...
+    def strip_tags(self, tags: list[str], recursive: bool = False) -> None: ...
+    @property
+    def attributes(self) -> dict[str, str | None]: ...
+    @property
+    def attrs(self) -> LexborAttributes: ...
+    @property
+    def id(self) -> str | None: ...
+    def iter(self, include_text: bool = False) -> Iterator[LexborNode]: ...
+    def unwrap(self) -> None: ...
+    def unwrap_tags(self, tags: list[str]) -> None: ...
+    def traverse(self, include_text: bool = False) -> Iterator[LexborNode]: ...
+    def replace_with(self, value: bytes | str | LexborNode) -> None: ...
+    def insert_before(self, value: bytes | str | LexborNode) -> None: ...
+    def insert_after(self, value: bytes | str | LexborNode) -> None: ...
+    def insert_child(self, value: bytes | str | LexborNode) -> None: ...
+    @property
+    def raw_value(self) -> NoReturn: ...
+    def scripts_contain(self, query: str) -> bool: ...
+    def scripts_srcs_contain(self, queries: tuple[str]) -> bool: ...
+    def remove(self, recursive: bool = True) -> None: ...
+    def select(self, query: str | None = None) -> LexborSelector: ...
+    @property
+    def text_content(self) -> str | None: ...
+
+class LexborHTMLParser:
+    def __init__(self, html: str): ...
+    @property
+    def selector(self) -> "LexborCSSSelector": ...
+    @property
+    def root(self) -> LexborNode | None: ...
+    @property
+    def body(self) -> LexborNode | None: ...
+    @property
+    def head(self) -> LexborNode | None: ...
+    def tags(self, name: str) -> list[LexborNode]: ...
+    def text(
+        self, deep: bool = True, separator: str = "", strip: bool = False
+    ) -> str: ...
+    @property
+    def html(self) -> str | None: ...
+    def css(self, query: str) -> list[LexborNode]: ...
+    @overload
+    def css_first(
+        self, query: str, default: Any = ..., strict: Literal[True] = ...
+    ) -> LexborNode: ...
+    @overload
+    def css_first(
+        self, query: str, default: DefaultT, strict: bool = False
+    ) -> LexborNode | DefaultT: ...
+    @overload
+    def css_first(
+        self, query: str, default: None = ..., strict: bool = False
+    ) -> LexborNode | None: ...
+    def strip_tags(self, tags: list[str], recursive: bool = False) -> None: ...
+    def select(self, query: str | None = None) -> LexborSelector | None: ...
+    def any_css_matches(self, selectors: tuple[str]) -> bool: ...
+    def scripts_contain(self, query: str) -> bool: ...
+    def scripts_srcs_contain(self, queries: tuple[str]) -> bool: ...
+    def css_matches(self, selector: str) -> bool: ...
+    def clone(self) -> LexborHTMLParser: ...
+    def unwrap_tags(self, tags: list[str]) -> None: ...
+
+def create_tag(tag: str) -> LexborNode:
+    """
+    Given an HTML tag name, e.g. `"div"`, create a single empty node for that tag,
+    e.g. `"<div></div>"`.
+    """
+    ...
+
+def parse_fragment(html: str) -> list[LexborNode]:
+    """
+    Given HTML, parse it into a list of Nodes, such that the nodes
+    correspond to the given HTML.
+
+    For contrast, HTMLParser adds `<html>`, `<head>`, and `<body>` tags
+    if they are missing. This function does not add these tags.
+    """
+    ...

{selectolax-0.3.25 → selectolax-0.3.26}/selectolax/parser.pyi

@@ -1,15 +1,28 @@
-from typing import Iterator, TypeVar, Literal
+from typing import Any, Iterator, TypeVar, Literal, overload
 
 DefaultT = TypeVar("DefaultT")
 
 class _Attributes:
     @staticmethod
-    def create(node: "Node", decode_errors: str) -> "_Attributes": ...
+    def create(node: Node, decode_errors: str) -> _Attributes: ...
     def keys(self) -> Iterator[str]: ...
-    def items(self) -> Iterator[tuple[str, str]]: ...
-    def values(self) -> Iterator[str]: ...
-    def get(self, key, default: DefaultT | None = None) -> str | DefaultT: ...
-    def sget(self, key, default: str = "") -> str | DefaultT: ...
+    def items(self) -> Iterator[tuple[str, str | None]]: ...
+    def values(self) -> Iterator[str | None]: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: str) -> str | None: ...
+    def __setitem__(self, key: str, value: str) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __repr__(self) -> str: ...
+    @overload
+    def get(self, key: str, default: DefaultT) -> DefaultT | str | None: ...
+    @overload
+    def get(self, key: str, default: None = ...) -> str | None: ...
+    @overload
+    def sget(self, key: str, default: str | DefaultT) -> str | DefaultT: ...
+    @overload
+    def sget(self, key: str, default: str = "") -> str: ...
 
 class Selector:
     """An advanced CSS selector that supports additional operations.
@@ -18,12 +31,12 @@ class Selector:
 
     Please note, this is an experimental feature that can change in the future."""
 
-    def __init__(self, node: "Node", query: str): ...
-    def css(self, query: str) -> "Node":
+    def __init__(self, node: Node, query: str): ...
+    def css(self, query: str) -> Node:
         """Evaluate CSS selector against current scope."""
         ...
     @property
-    def matches(self) -> list["Node"]:
+    def matches(self) -> list[Node]:
         """Returns all possible selector matches"""
         ...
     @property
@@ -32,7 +45,7 @@ class Selector:
         ...
     def text_contains(
         self, text: str, deep: bool = True, separator: str = "", strip: bool = False
-    ) -> "Selector":
+    ) -> Selector:
         """Filter all current matches given text."""
         ...
     def any_text_contains(
@@ -42,7 +55,7 @@ class Selector:
         ...
     def attribute_long_than(
         self, text: str, length: int, start: str | None = None
-    ) -> "Selector":
+    ) -> Selector:
         """Filter all current matches by attribute length.
 
         Similar to string-length in XPath."""
@@ -56,15 +69,15 @@ class Selector:
         ...
 
 class Node:
-    parser: "HTMLParser"
+    parser: HTMLParser
     @property
-    def attributes(self) -> dict[str, None | str]:
+    def attributes(self) -> dict[str, str | None]:
         """Get all attributes that belong to the current node.
 
         The value of empty attributes is None."""
         ...
     @property
-    def attrs(self) -> "_Attributes":
+    def attrs(self) -> _Attributes:
         """A dict-like object that is similar to the attributes property, but operates directly on the Node data."""
         ...
     @property
@@ -88,10 +101,10 @@ class Node:
     def text(self, deep: bool = True, separator: str = "", strip: bool = False) -> str:
         """Returns the text of the node including text of all its child nodes."""
         ...
-    def iter(self, include_text: bool = False) -> Iterator["Node"]:
+    def iter(self, include_text: bool = False) -> Iterator[Node]:
         """Iterate over nodes on the current level."""
         ...
-    def traverse(self, include_text: bool = False) -> Iterator["Node"]:
+    def traverse(self, include_text: bool = False) -> Iterator[Node]:
         """Iterate over all child and next nodes starting from the current level."""
         ...
     @property
@@ -99,30 +112,30 @@ class Node:
         """Return the name of the current tag (e.g. div, p, img)."""
         ...
     @property
-    def child(self) -> None | "Node":
+    def child(self) -> Node | None:
         """Return the child node."""
         ...
     @property
-    def parent(self) -> None | "Node":
+    def parent(self) -> Node | None:
         """Return the parent node."""
         ...
     @property
-    def next(self) -> None | "Node":
+    def next(self) -> Node | None:
         """Return next node."""
         ...
     @property
-    def prev(self) -> None | "Node":
+    def prev(self) -> Node | None:
         """Return previous node."""
         ...
     @property
-    def last_child(self) -> None | "Node":
+    def last_child(self) -> Node | None:
         """Return last child node."""
         ...
     @property
-    def html(self) -> None | str:
+    def html(self) -> str | None:
         """Return HTML representation of the current node including all its child nodes."""
         ...
-    def css(self, query: str) -> list["Node"]:
+    def css(self, query: str) -> list[Node]:
         """Evaluate CSS selector against current node and its child nodes."""
         ...
     def any_css_matches(self, selectors: tuple[str]) -> bool:
@@ -131,9 +144,18 @@ class Node:
     def css_matches(self, selector: str) -> bool:
         """Returns True if CSS selector matches a node."""
         ...
+    @overload
     def css_first(
-        self, query: str, default: DefaultT | None = None, strict: bool = False
-    ) -> "Node" | DefaultT:
+        self, query: str, default: Any = ..., strict: Literal[True] = ...
+    ) -> Node: ...
+    @overload
+    def css_first(
+        self, query: str, default: DefaultT, strict: bool = False
+    ) -> Node | DefaultT: ...
+    @overload
+    def css_first(
+        self, query: str, default: None = ..., strict: bool = False
+    ) -> Node | None:
         """Evaluate CSS selector against current node and its child nodes."""
         ...
     def decompose(self, recursive: bool = True) -> None:
@@ -171,7 +193,7 @@ class Node:
 
         Currently, works on text nodes only."""
         ...
-    def select(self, query: str | None = None) -> "Selector":
+    def select(self, query: str | None = None) -> Selector:
         """Select nodes given a CSS selector.
 
         Works similarly to the css method, but supports chained filtering and extra features.
@@ -208,14 +230,23 @@ class HTMLParser:
         use_meta_tags: bool = True,
         decode_errors: Literal["strict", "ignore", "replace"] = "ignore",
     ): ...
-    def css(self, query: str) -> list["Node"]:
+    def css(self, query: str) -> list[Node]:
         """A CSS selector.
 
         Matches pattern query against HTML tree."""
         ...
+    @overload
+    def css_first(
+        self, query: str, default: Any = ..., strict: Literal[True] = ...
+    ) -> Node: ...
+    @overload
+    def css_first(
+        self, query: str, default: DefaultT, strict: bool = False
+    ) -> Node | DefaultT: ...
+    @overload
     def css_first(
-        self, query: str, default: DefaultT | None = None, strict: bool = False
-    ) -> DefaultT | "Node":
+        self, query: str, default: None = ..., strict: bool = False
+    ) -> Node | None:
         """Same as css but returns only the first match."""
         ...
     @property
@@ -225,18 +256,18 @@ class HTMLParser:
         Returns unknown in case the encoding is not determined."""
         ...
     @property
-    def root(self) -> "Node" | None:
+    def root(self) -> Node | None:
         """Returns root node."""
         ...
     @property
-    def head(self) -> "Node" | None:
+    def head(self) -> Node | None:
         """Returns head node."""
         ...
     @property
-    def body(self) -> "Node" | None:
+    def body(self) -> Node | None:
         """Returns document body."""
         ...
-    def tags(self, name: str) -> list["Node"]:
+    def tags(self, name: str) -> list[Node]:
         """Returns a list of tags that match specified name."""
         ...
     def text(self, deep: bool = True, separator: str = "", strip: bool = False) -> str:
@@ -249,10 +280,10 @@ class HTMLParser:
         Works the same as th unwrap method, but applied to a list of tags."""
         ...
     @property
-    def html(self) -> None | str:
+    def html(self) -> str | None:
         """Return HTML representation of the page."""
         ...
-    def select(self, query: str | None = None) -> "Selector" | None:
+    def select(self, query: str | None = None) -> Selector | None:
         """Select nodes given a CSS selector.
 
         Works similarly to the css method, but supports chained filtering and extra features.
@@ -272,7 +303,7 @@ class HTMLParser:
         Caches values on the first call to improve performance."""
         ...
     def css_matches(self, selector: str) -> bool: ...
-    def clone(self) -> "HTMLParser":
+    def clone(self) -> HTMLParser:
         """Clone the current tree."""
         ...
     def merge_text_nodes(self):
@@ -281,14 +312,14 @@ class HTMLParser:
         This is useful for text extraction."""
         ...
 
-def create_tag(tag: str) -> "Node":
+def create_tag(tag: str) -> Node:
     """
     Given an HTML tag name, e.g. `"div"`, create a single empty node for that tag,
     e.g. `"<div></div>"`.
     """
     ...
 
-def parse_fragment(html: str) -> list["Node"]:
+def parse_fragment(html: str) -> list[Node]:
     """
     Given HTML, parse it into a list of Nodes, such that the nodes
     correspond to the given HTML.

{selectolax-0.3.25 → selectolax-0.3.26/selectolax.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: selectolax
-Version: 0.3.25
+Version: 0.3.26
 Summary: Fast HTML5 parser with CSS selectors.
 Home-page: https://github.com/rushter/selectolax
 Author: Artem Golubin

{selectolax-0.3.25 → selectolax-0.3.26}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.3.25
+current_version = 0.3.26
 commit = True
 tag = True
 
@@ -17,12 +17,6 @@ universal = 1
 [aliases]
 test = pytest
 
-[flake8]
-exclude = docs
-max-line-length = 120
-per-file-ignores = 
-	__init__.py: F401
-
 [pycodestyle]
 max-line-length = 120
 

{selectolax-0.3.25 → selectolax-0.3.26}/setup.py

@@ -167,7 +167,7 @@ def make_extensions():
 
 setup(
     name="selectolax",
-    version='0.3.25',
+    version='0.3.26',
     description="Fast HTML5 parser with CSS selectors.",
     long_description=readme,
     author="Artem Golubin",

{selectolax-0.3.25 → selectolax-0.3.26}/tests/test_nodes.py

@@ -481,7 +481,6 @@ def test_node_comparison_fails(parser):
 
     assert node is not None
     assert node != 123
-    assert node != object
 
 
 def test_raw_value():