Add non-Linux CI jobs. (#154)

Author: wRAR

.github/workflows/tests-macos.yml

@@ -0,0 +1,27 @@
+name: macOS
+on: [push, pull_request]
+
+jobs:
+  tests:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Run tests
+      run: |
+        pip install -U pip
+        pip install -U tox
+        tox -e py
+
+    - name: Upload coverage report
+      uses: codecov/codecov-action@v5

.github/workflows/tests.yml .github/workflows/tests-ubuntu.yml.github/workflows/tests.yml renamed to .github/workflows/tests-ubuntu.yml

@@ -1,4 +1,4 @@
-name: Tests
+name: Ubuntu
 on: [push, pull_request]
 
 jobs:

.github/workflows/tests-windows.yml

@@ -0,0 +1,27 @@
+name: Windows
+on: [push, pull_request]
+
+jobs:
+  tests:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Run tests
+      run: |
+        pip install -U pip
+        pip install -U tox
+        tox -e py
+
+    - name: Upload coverage report
+      uses: codecov/codecov-action@v5

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.9.10
+  rev: v0.11.2
   hooks:
     - id: ruff
       args: [ --fix ]

cssselect/parser.py

@@ -562,7 +562,7 @@ def parse_selector(stream: TokenStream) -> tuple[Tree, PseudoElement | None]:
             )
         if peek.is_delim("+", ">", "~"):
             # A combinator
-            combinator = cast(str, stream.next().value)
+            combinator = cast("str", stream.next().value)
             stream.skip_whitespace()
         else:
             # By exclusion, the last parse_simple_selector() ended
@@ -608,7 +608,7 @@ def parse_simple_selector(
                 f"Got pseudo-element ::{pseudo_element} not at the end of a selector"
             )
         if peek.type == "HASH":
-            result = Hash(result, cast(str, stream.next().value))
+            result = Hash(result, cast("str", stream.next().value))
         elif peek == ("DELIM", "."):
             stream.next()
             result = Class(result, stream.next_ident())
@@ -720,7 +720,7 @@ def parse_relative_selector(stream: TokenStream) -> tuple[Token, Selector]:
             ("DELIM", "."),
             ("DELIM", "*"),
         ]:
-            subselector += cast(str, next.value)
+            subselector += cast("str", next.value)
         elif next == ("DELIM", ")"):
             result = parse(subselector)
             return combinator, result[0]
@@ -774,13 +774,13 @@ def parse_attrib(selector: Tree, stream: TokenStream) -> Attrib:
         stream.skip_whitespace()
         next = stream.next()
         if next == ("DELIM", "]"):
-            return Attrib(selector, namespace, cast(str, attrib), "exists", None)
+            return Attrib(selector, namespace, cast("str", attrib), "exists", None)
         if next == ("DELIM", "="):
             op = "="
         elif next.is_delim("^", "$", "*", "~", "|", "!") and (
             stream.peek() == ("DELIM", "=")
         ):
-            op = cast(str, next.value) + "="
+            op = cast("str", next.value) + "="
             stream.next()
         else:
             raise SelectorSyntaxError(f"Operator expected, got {next}")
@@ -792,7 +792,7 @@ def parse_attrib(selector: Tree, stream: TokenStream) -> Attrib:
     next = stream.next()
     if next != ("DELIM", "]"):
         raise SelectorSyntaxError(f"Expected ']', got {next}")
-    return Attrib(selector, namespace, cast(str, attrib), op, value)
+    return Attrib(selector, namespace, cast("str", attrib), op, value)
 
 
 def parse_series(tokens: Iterable[Token]) -> tuple[int, int]:
@@ -806,7 +806,7 @@ def parse_series(tokens: Iterable[Token]) -> tuple[int, int]:
     for token in tokens:
         if token.type == "STRING":
             raise ValueError("String tokens not allowed in series.")
-    s = "".join(cast(str, token.value) for token in tokens).strip()
+    s = "".join(cast("str", token.value) for token in tokens).strip()
     if s == "odd":
         return 2, 1
     if s == "even":
@@ -867,7 +867,7 @@ def value(self) -> str | None:
     def css(self) -> str:
         if self.type == "STRING":
             return repr(self.value)
-        return cast(str, self.value)
+        return cast("str", self.value)
 
 
 class EOFToken(Token):
@@ -1030,7 +1030,7 @@ def next_ident(self) -> str:
         next = self.next()
         if next.type != "IDENT":
             raise SelectorSyntaxError(f"Expected ident, got {next}")
-        return cast(str, next.value)
+        return cast("str", next.value)
 
     def next_ident_or_star(self) -> str | None:
         next = self.next()

cssselect/xpath.py

@@ -14,8 +14,7 @@
 from __future__ import annotations
 
 import re
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, cast
 
 from cssselect.parser import (
     Attrib,
@@ -38,6 +37,8 @@
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     # typing.Self requires Python 3.11
     from typing_extensions import Self
 
@@ -289,7 +290,7 @@ def xpath(self, parsed_selector: Tree) -> XPathExpr:
         """Translate any parsed selector object."""
         type_name = type(parsed_selector).__name__
         method = cast(
-            Optional[Callable[[Tree], XPathExpr]],
+            "Callable[[Tree], XPathExpr] | None",
             getattr(self, f"xpath_{type_name.lower()}", None),
         )
         if method is None:
@@ -302,7 +303,7 @@ def xpath_combinedselector(self, combined: CombinedSelector) -> XPathExpr:
         """Translate a combined selector."""
         combinator = self.combinator_mapping[combined.combinator]
         method = cast(
-            Callable[[XPathExpr, XPathExpr], XPathExpr],
+            "Callable[[XPathExpr, XPathExpr], XPathExpr]",
             getattr(self, f"xpath_{combinator}_combinator"),
         )
         return method(self.xpath(combined.selector), self.xpath(combined.subselector))
@@ -321,10 +322,10 @@ def xpath_relation(self, relation: Relation) -> XPathExpr:
         subselector = relation.subselector
         right = self.xpath(subselector.parsed_tree)
         method = cast(
-            Callable[[XPathExpr, XPathExpr], XPathExpr],
+            "Callable[[XPathExpr, XPathExpr], XPathExpr]",
             getattr(
                 self,
-                f"xpath_relation_{self.combinator_mapping[cast(str, combinator.value)]}_combinator",
+                f"xpath_relation_{self.combinator_mapping[cast('str', combinator.value)]}_combinator",
             ),
         )
         return method(xpath, right)
@@ -351,7 +352,7 @@ def xpath_function(self, function: Function) -> XPathExpr:
         """Translate a functional pseudo-class."""
         method_name = "xpath_{}_function".format(function.name.replace("-", "_"))
         method = cast(
-            Optional[Callable[[XPathExpr, Function], XPathExpr]],
+            "Callable[[XPathExpr, Function], XPathExpr] | None",
             getattr(self, method_name, None),
         )
         if not method:
@@ -362,7 +363,8 @@ def xpath_pseudo(self, pseudo: Pseudo) -> XPathExpr:
         """Translate a pseudo-class."""
         method_name = "xpath_{}_pseudo".format(pseudo.ident.replace("-", "_"))
         method = cast(
-            Optional[Callable[[XPathExpr], XPathExpr]], getattr(self, method_name, None)
+            "Callable[[XPathExpr], XPathExpr] | None",
+            getattr(self, method_name, None),
         )
         if not method:
             # TODO: better error message for pseudo-elements?
@@ -373,7 +375,7 @@ def xpath_attrib(self, selector: Attrib) -> XPathExpr:
         """Translate an attribute selector."""
         operator = self.attribute_operator_mapping[selector.operator]
         method = cast(
-            Callable[[XPathExpr, str, Optional[str]], XPathExpr],
+            "Callable[[XPathExpr, str, str | None], XPathExpr]",
             getattr(self, f"xpath_attrib_{operator}"),
         )
         if self.lower_case_attribute_names:
@@ -391,7 +393,7 @@ def xpath_attrib(self, selector: Attrib) -> XPathExpr:
         if selector.value is None:
             value = None
         elif self.lower_case_attribute_values:
-            value = cast(str, selector.value.value).lower()
+            value = cast("str", selector.value.value).lower()
         else:
             value = selector.value.value
         return method(self.xpath(selector.selector), attrib, value)
@@ -645,15 +647,15 @@ def xpath_contains_function(
             raise ExpressionError(
                 f"Expected a single string or ident for :contains(), got {function.arguments!r}"
             )
-        value = cast(str, function.arguments[0].value)
+        value = cast("str", function.arguments[0].value)
         return xpath.add_condition(f"contains(., {self.xpath_literal(value)})")
 
     def xpath_lang_function(self, xpath: XPathExpr, function: Function) -> XPathExpr:
         if function.argument_types() not in (["STRING"], ["IDENT"]):
             raise ExpressionError(
                 f"Expected a single string or ident for :lang(), got {function.arguments!r}"
             )
-        value = cast(str, function.arguments[0].value)
+        value = cast("str", function.arguments[0].value)
         return xpath.add_condition(f"lang({self.xpath_literal(value)})")
 
     # Pseudo: dispatch by pseudo-class name

tests/test_cssselect.py

@@ -728,7 +728,7 @@ def xpath(css: str) -> str:
 
         def operator_id(selector: str) -> list[str]:
             xpath = CustomTranslator().css_to_xpath(selector)
-            items = typing.cast(list["etree._Element"], document.xpath(xpath))
+            items = typing.cast("list[etree._Element]", document.xpath(xpath))
             items.sort(key=sort_key)
             return [element.get("id", "nil") for element in items]
 
@@ -739,7 +739,9 @@ def operator_id(selector: str) -> list[str]:
     def test_series(self) -> None:
         def series(css: str) -> tuple[int, int] | None:
             (selector,) = parse(f":nth-child({css})")
-            args = typing.cast(FunctionalPseudoElement, selector.parsed_tree).arguments
+            args = typing.cast(
+                "FunctionalPseudoElement", selector.parsed_tree
+            ).arguments
             try:
                 return parse_series(args)
             except ValueError:
@@ -771,7 +773,7 @@ def test_lang(self) -> None:
 
         def langid(selector: str) -> list[str]:
             xpath = css_to_xpath(selector)
-            items = typing.cast(list["etree._Element"], document.xpath(xpath))
+            items = typing.cast("list[etree._Element]", document.xpath(xpath))
             items.sort(key=sort_key)
             return [element.get("id", "nil") for element in items]
 
@@ -800,7 +802,7 @@ def xpath_pseudo_element(
                 self, xpath: XPathExpr, pseudo_element: PseudoElement
             ) -> XPathExpr:
                 self.argument_types += typing.cast(
-                    FunctionalPseudoElement, pseudo_element
+                    "FunctionalPseudoElement", pseudo_element
                 ).argument_types()
                 return xpath
 
@@ -827,11 +829,11 @@ def test_select(self) -> None:
 
         def select_ids(selector: str, html_only: bool) -> list[str]:
             xpath = css_to_xpath(selector)
-            items = typing.cast(list["etree._Element"], document.xpath(xpath))
+            items = typing.cast("list[etree._Element]", document.xpath(xpath))
             if html_only:
                 assert items == []
                 xpath = html_css_to_xpath(selector)
-                items = typing.cast(list["etree._Element"], document.xpath(xpath))
+                items = typing.cast("list[etree._Element]", document.xpath(xpath))
             items.sort(key=sort_key)
             return [element.get("id", "nil") for element in items]
 
@@ -1065,14 +1067,14 @@ def pcss(main: str, *selectors: str, **kwargs: bool) -> list[str]:
 
     def test_select_shakespeare(self) -> None:
         document = html.document_fromstring(HTML_SHAKESPEARE)
-        body = typing.cast(list["etree._Element"], document.xpath("//body"))[0]
+        body = typing.cast("list[etree._Element]", document.xpath("//body"))[0]
         css_to_xpath = GenericTranslator().css_to_xpath
 
         basestring_ = (str, bytes)
 
         def count(selector: str) -> int:
             xpath = css_to_xpath(selector)
-            results = typing.cast(list["etree._Element"], body.xpath(xpath))
+            results = typing.cast("list[etree._Element]", body.xpath(xpath))
             assert not isinstance(results, basestring_)
             found = set()
             for item in results: