From 24c5e0916f946844b1f71098e4e334119678dca6 Mon Sep 17 00:00:00 2001
From: Andrey Rakhmatullin <wrar@wrar.name>
Date: Sun, 2 Feb 2025 19:42:20 +0500
Subject: [PATCH] Upgrade string formatting.

---
 cssselect/parser.py     | 169 +++++++++++++++-------------------------
 cssselect/xpath.py      |  96 ++++++++++-------------
 pyproject.toml          |   3 -
 tests/test_cssselect.py |  17 ++--
 4 files changed, 113 insertions(+), 172 deletions(-)

diff --git a/cssselect/parser.py b/cssselect/parser.py
index d16751f..13ae959 100644
--- a/cssselect/parser.py
+++ b/cssselect/parser.py
@@ -105,20 +105,20 @@ def __repr__(self) -> str:
         if isinstance(self.pseudo_element, FunctionalPseudoElement):
             pseudo_element = repr(self.pseudo_element)
         elif self.pseudo_element:
-            pseudo_element = "::%s" % self.pseudo_element
+            pseudo_element = f"::{self.pseudo_element}"
         else:
             pseudo_element = ""
-        return "%s[%r%s]" % (self.__class__.__name__, self.parsed_tree, pseudo_element)
+        return f"{self.__class__.__name__}[{self.parsed_tree!r}{pseudo_element}]"
 
     def canonical(self) -> str:
         """Return a CSS representation for this selector (a string)"""
         if isinstance(self.pseudo_element, FunctionalPseudoElement):
-            pseudo_element = "::%s" % self.pseudo_element.canonical()
+            pseudo_element = f"::{self.pseudo_element.canonical()}"
         elif self.pseudo_element:
-            pseudo_element = "::%s" % self.pseudo_element
+            pseudo_element = f"::{self.pseudo_element}"
         else:
             pseudo_element = ""
-        res = "%s%s" % (self.parsed_tree.canonical(), pseudo_element)
+        res = f"{self.parsed_tree.canonical()}{pseudo_element}"
         if len(res) > 1:
             res = res.lstrip("*")
         return res
@@ -145,10 +145,10 @@ def __init__(self, selector: Tree, class_name: str) -> None:
         self.class_name = class_name
 
     def __repr__(self) -> str:
-        return "%s[%r.%s]" % (self.__class__.__name__, self.selector, self.class_name)
+        return f"{self.__class__.__name__}[{self.selector!r}.{self.class_name}]"
 
     def canonical(self) -> str:
-        return "%s.%s" % (self.selector.canonical(), self.class_name)
+        return f"{self.selector.canonical()}.{self.class_name}"
 
     def specificity(self) -> tuple[int, int, int]:
         a, b, c = self.selector.specificity()
@@ -179,18 +179,15 @@ def __init__(self, name: str, arguments: Sequence[Token]):
         self.arguments = arguments
 
     def __repr__(self) -> str:
-        return "%s[::%s(%r)]" % (
-            self.__class__.__name__,
-            self.name,
-            [token.value for token in self.arguments],
-        )
+        token_values = [token.value for token in self.arguments]
+        return f"{self.__class__.__name__}[::{self.name}({token_values!r})]"
 
     def argument_types(self) -> list[str]:
         return [token.type for token in self.arguments]
 
     def canonical(self) -> str:
         args = "".join(token.css() for token in self.arguments)
-        return "%s(%s)" % (self.name, args)
+        return f"{self.name}({args})"
 
 
 class Function:
@@ -204,19 +201,15 @@ def __init__(self, selector: Tree, name: str, arguments: Sequence[Token]) -> Non
         self.arguments = arguments
 
     def __repr__(self) -> str:
-        return "%s[%r:%s(%r)]" % (
-            self.__class__.__name__,
-            self.selector,
-            self.name,
-            [token.value for token in self.arguments],
-        )
+        token_values = [token.value for token in self.arguments]
+        return f"{self.__class__.__name__}[{self.selector!r}:{self.name}({token_values!r})]"
 
     def argument_types(self) -> list[str]:
         return [token.type for token in self.arguments]
 
     def canonical(self) -> str:
         args = "".join(token.css() for token in self.arguments)
-        return "%s:%s(%s)" % (self.selector.canonical(), self.name, args)
+        return f"{self.selector.canonical()}:{self.name}({args})"
 
     def specificity(self) -> tuple[int, int, int]:
         a, b, c = self.selector.specificity()
@@ -234,10 +227,10 @@ def __init__(self, selector: Tree, ident: str) -> None:
         self.ident = ascii_lower(ident)
 
     def __repr__(self) -> str:
-        return "%s[%r:%s]" % (self.__class__.__name__, self.selector, self.ident)
+        return f"{self.__class__.__name__}[{self.selector!r}:{self.ident}]"
 
     def canonical(self) -> str:
-        return "%s:%s" % (self.selector.canonical(), self.ident)
+        return f"{self.selector.canonical()}:{self.ident}"
 
     def specificity(self) -> tuple[int, int, int]:
         a, b, c = self.selector.specificity()
@@ -255,17 +248,13 @@ def __init__(self, selector: Tree, subselector: Tree) -> None:
         self.subselector = subselector
 
     def __repr__(self) -> str:
-        return "%s[%r:not(%r)]" % (
-            self.__class__.__name__,
-            self.selector,
-            self.subselector,
-        )
+        return f"{self.__class__.__name__}[{self.selector!r}:not({self.subselector!r})]"
 
     def canonical(self) -> str:
         subsel = self.subselector.canonical()
         if len(subsel) > 1:
             subsel = subsel.lstrip("*")
-        return "%s:not(%s)" % (self.selector.canonical(), subsel)
+        return f"{self.selector.canonical()}:not({subsel})"
 
     def specificity(self) -> tuple[int, int, int]:
         a1, b1, c1 = self.selector.specificity()
@@ -284,11 +273,7 @@ def __init__(self, selector: Tree, combinator: Token, subselector: Selector):
         self.subselector = subselector
 
     def __repr__(self) -> str:
-        return "%s[%r:has(%r)]" % (
-            self.__class__.__name__,
-            self.selector,
-            self.subselector,
-        )
+        return f"{self.__class__.__name__}[{self.selector!r}:has({self.subselector!r})]"
 
     def canonical(self) -> str:
         try:
@@ -297,7 +282,7 @@ def canonical(self) -> str:
             subsel = self.subselector.canonical()
         if len(subsel) > 1:
             subsel = subsel.lstrip("*")
-        return "%s:has(%s)" % (self.selector.canonical(), subsel)
+        return f"{self.selector.canonical()}:has({subsel})"
 
     def specificity(self) -> tuple[int, int, int]:
         a1, b1, c1 = self.selector.specificity()
@@ -318,21 +303,16 @@ def __init__(self, selector: Tree, selector_list: Iterable[Tree]):
         self.selector_list = selector_list
 
     def __repr__(self) -> str:
-        return "%s[%r:is(%s)]" % (
-            self.__class__.__name__,
-            self.selector,
-            ", ".join(map(repr, self.selector_list)),
-        )
+        args_str = ", ".join(repr(s) for s in self.selector_list)
+        return f"{self.__class__.__name__}[{self.selector!r}:is({args_str})]"
 
     def canonical(self) -> str:
         selector_arguments = []
         for s in self.selector_list:
             selarg = s.canonical()
             selector_arguments.append(selarg.lstrip("*"))
-        return "%s:is(%s)" % (
-            self.selector.canonical(),
-            ", ".join(map(str, selector_arguments)),
-        )
+        args_str = ", ".join(str(s) for s in selector_arguments)
+        return f"{self.selector.canonical()}:is({args_str})"
 
     def specificity(self) -> tuple[int, int, int]:
         return max(x.specificity() for x in self.selector_list)
@@ -349,21 +329,16 @@ def __init__(self, selector: Tree, selector_list: list[Tree]):
         self.selector_list = selector_list
 
     def __repr__(self) -> str:
-        return "%s[%r:where(%s)]" % (
-            self.__class__.__name__,
-            self.selector,
-            ", ".join(map(repr, self.selector_list)),
-        )
+        args_str = ", ".join(repr(s) for s in self.selector_list)
+        return f"{self.__class__.__name__}[{self.selector!r}:where({args_str})]"
 
     def canonical(self) -> str:
         selector_arguments = []
         for s in self.selector_list:
             selarg = s.canonical()
             selector_arguments.append(selarg.lstrip("*"))
-        return "%s:where(%s)" % (
-            self.selector.canonical(),
-            ", ".join(map(str, selector_arguments)),
-        )
+        args_str = ", ".join(str(s) for s in selector_arguments)
+        return f"{self.selector.canonical()}:where({args_str})"
 
     def specificity(self) -> tuple[int, int, int]:
         return 0, 0, 0
@@ -409,38 +384,22 @@ def __init__(
         self.value = value
 
     def __repr__(self) -> str:
-        if self.namespace:
-            attrib = "%s|%s" % (self.namespace, self.attrib)
-        else:
-            attrib = self.attrib
+        attrib = f"{self.namespace}|{self.attrib}" if self.namespace else self.attrib
         if self.operator == "exists":
-            return "%s[%r[%s]]" % (self.__class__.__name__, self.selector, attrib)
+            return f"{self.__class__.__name__}[{self.selector!r}[{attrib}]]"
         assert self.value is not None
-        return "%s[%r[%s %s %r]]" % (
-            self.__class__.__name__,
-            self.selector,
-            attrib,
-            self.operator,
-            self.value.value,
-        )
+        return f"{self.__class__.__name__}[{self.selector!r}[{attrib} {self.operator} {self.value.value!r}]]"
 
     def canonical(self) -> str:
-        if self.namespace:
-            attrib = "%s|%s" % (self.namespace, self.attrib)
-        else:
-            attrib = self.attrib
+        attrib = f"{self.namespace}|{self.attrib}" if self.namespace else self.attrib
 
         if self.operator == "exists":
             op = attrib
         else:
             assert self.value is not None
-            op = "%s%s%s" % (
-                attrib,
-                self.operator,
-                self.value.css(),
-            )
+            op = f"{attrib}{self.operator}{self.value.css()}"
 
-        return "%s[%s]" % (self.selector.canonical(), op)
+        return f"{self.selector.canonical()}[{op}]"
 
     def specificity(self) -> tuple[int, int, int]:
         a, b, c = self.selector.specificity()
@@ -463,12 +422,12 @@ def __init__(
         self.element = element
 
     def __repr__(self) -> str:
-        return "%s[%s]" % (self.__class__.__name__, self.canonical())
+        return f"{self.__class__.__name__}[{self.canonical()}]"
 
     def canonical(self) -> str:
         element = self.element or "*"
         if self.namespace:
-            element = "%s|%s" % (self.namespace, element)
+            element = f"{self.namespace}|{element}"
         return element
 
     def specificity(self) -> tuple[int, int, int]:
@@ -487,10 +446,10 @@ def __init__(self, selector: Tree, id: str) -> None:
         self.id = id
 
     def __repr__(self) -> str:
-        return "%s[%r#%s]" % (self.__class__.__name__, self.selector, self.id)
+        return f"{self.__class__.__name__}[{self.selector!r}#{self.id}]"
 
     def canonical(self) -> str:
-        return "%s#%s" % (self.selector.canonical(), self.id)
+        return f"{self.selector.canonical()}#{self.id}"
 
     def specificity(self) -> tuple[int, int, int]:
         a, b, c = self.selector.specificity()
@@ -507,18 +466,15 @@ def __init__(self, selector: Tree, combinator: str, subselector: Tree) -> None:
 
     def __repr__(self) -> str:
         comb = "<followed>" if self.combinator == " " else self.combinator
-        return "%s[%r %s %r]" % (
-            self.__class__.__name__,
-            self.selector,
-            comb,
-            self.subselector,
+        return (
+            f"{self.__class__.__name__}[{self.selector!r} {comb} {self.subselector!r}]"
         )
 
     def canonical(self) -> str:
         subsel = self.subselector.canonical()
         if len(subsel) > 1:
             subsel = subsel.lstrip("*")
-        return "%s %s %s" % (self.selector.canonical(), self.combinator, subsel)
+        return f"{self.selector.canonical()} {self.combinator} {subsel}"
 
     def specificity(self) -> tuple[int, int, int]:
         a1, b1, c1 = self.selector.specificity()
@@ -602,7 +558,7 @@ def parse_selector(stream: TokenStream) -> tuple[Tree, PseudoElement | None]:
             break
         if pseudo_element:
             raise SelectorSyntaxError(
-                "Got pseudo-element ::%s not at the end of a selector" % pseudo_element
+                f"Got pseudo-element ::{pseudo_element} not at the end of a selector"
             )
         if peek.is_delim("+", ">", "~"):
             # A combinator
@@ -649,7 +605,7 @@ def parse_simple_selector(
             break
         if pseudo_element:
             raise SelectorSyntaxError(
-                "Got pseudo-element ::%s not at the end of a selector" % pseudo_element
+                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))
@@ -707,11 +663,10 @@ def parse_simple_selector(
                 next = stream.next()
                 if argument_pseudo_element:
                     raise SelectorSyntaxError(
-                        "Got pseudo-element ::%s inside :not() at %s"
-                        % (argument_pseudo_element, next.pos)
+                        f"Got pseudo-element ::{argument_pseudo_element} inside :not() at {next.pos}"
                     )
                 if next != ("DELIM", ")"):
-                    raise SelectorSyntaxError("Expected ')', got %s" % (next,))
+                    raise SelectorSyntaxError(f"Expected ')', got {next}")
                 result = Negation(result, argument)
             elif ident.lower() == "has":
                 combinator, arguments = parse_relative_selector(stream)
@@ -726,9 +681,9 @@ def parse_simple_selector(
             else:
                 result = Function(result, ident, parse_arguments(stream))
         else:
-            raise SelectorSyntaxError("Expected selector, got %s" % (peek,))
+            raise SelectorSyntaxError(f"Expected selector, got {peek}")
     if len(stream.used) == selector_start:
-        raise SelectorSyntaxError("Expected selector, got %s" % (stream.peek(),))
+        raise SelectorSyntaxError(f"Expected selector, got {stream.peek()}")
     return result, pseudo_element
 
 
@@ -745,7 +700,7 @@ def parse_arguments(stream: TokenStream) -> list[Token]:
         elif next == ("DELIM", ")"):
             return arguments
         else:
-            raise SelectorSyntaxError("Expected an argument, got %s" % (next,))
+            raise SelectorSyntaxError(f"Expected an argument, got {next}")
 
 
 def parse_relative_selector(stream: TokenStream) -> tuple[Token, Selector]:
@@ -770,7 +725,7 @@ def parse_relative_selector(stream: TokenStream) -> tuple[Token, Selector]:
             result = parse(subselector)
             return combinator, result[0]
         else:
-            raise SelectorSyntaxError("Expected an argument, got %s" % (next,))
+            raise SelectorSyntaxError(f"Expected an argument, got {next}")
         next = stream.next()
 
 
@@ -780,7 +735,7 @@ def parse_simple_selector_arguments(stream: TokenStream) -> list[Tree]:
         result, pseudo_element = parse_simple_selector(stream, True)
         if pseudo_element:
             raise SelectorSyntaxError(
-                "Got pseudo-element ::%s inside function" % (pseudo_element,)
+                f"Got pseudo-element ::{pseudo_element} inside function"
             )
         stream.skip_whitespace()
         next = stream.next()
@@ -792,7 +747,7 @@ def parse_simple_selector_arguments(stream: TokenStream) -> list[Tree]:
             arguments.append(result)
             break
         else:
-            raise SelectorSyntaxError("Expected an argument, got %s" % (next,))
+            raise SelectorSyntaxError(f"Expected an argument, got {next}")
     return arguments
 
 
@@ -800,7 +755,7 @@ def parse_attrib(selector: Tree, stream: TokenStream) -> Attrib:
     stream.skip_whitespace()
     attrib = stream.next_ident_or_star()
     if attrib is None and stream.peek() != ("DELIM", "|"):
-        raise SelectorSyntaxError("Expected '|', got %s" % (stream.peek(),))
+        raise SelectorSyntaxError(f"Expected '|', got {stream.peek()}")
     namespace: str | None
     op: str | None
     if stream.peek() == ("DELIM", "|"):
@@ -828,15 +783,15 @@ def parse_attrib(selector: Tree, stream: TokenStream) -> Attrib:
             op = cast(str, next.value) + "="
             stream.next()
         else:
-            raise SelectorSyntaxError("Operator expected, got %s" % (next,))
+            raise SelectorSyntaxError(f"Operator expected, got {next}")
     stream.skip_whitespace()
     value = stream.next()
     if value.type not in ("IDENT", "STRING"):
-        raise SelectorSyntaxError("Expected string or ident, got %s" % (value,))
+        raise SelectorSyntaxError(f"Expected string or ident, got {value}")
     stream.skip_whitespace()
     next = stream.next()
     if next != ("DELIM", "]"):
-        raise SelectorSyntaxError("Expected ']', got %s" % (next,))
+        raise SelectorSyntaxError(f"Expected ']', got {next}")
     return Attrib(selector, namespace, cast(str, attrib), op, value)
 
 
@@ -894,7 +849,7 @@ def __new__(cls, type_: str, value: str | None, pos: int) -> Self:
         return obj
 
     def __repr__(self) -> str:
-        return "<%s '%s' at %i>" % (self.type, self.value, self.pos)
+        return f"<{self.type} '{self.value}' at {self.pos}>"
 
     def is_delim(self, *values: str) -> bool:
         return self.type == "DELIM" and self.value in values
@@ -920,7 +875,7 @@ def __new__(cls, pos: int) -> Self:
         return Token.__new__(cls, "EOF", None, pos)
 
     def __repr__(self) -> str:
-        return "<%s at %i>" % (self.type, self.pos)
+        return f"<{self.type} at {self.pos}>"
 
 
 #### Tokenizer
@@ -931,8 +886,8 @@ class TokenMacros:
     escape = unicode_escape + r"|\\[^\n\r\f0-9a-f]"
     string_escape = r"\\(?:\n|\r\n|\r|\f)|" + escape
     nonascii = r"[^\0-\177]"
-    nmchar = "[_a-z0-9-]|%s|%s" % (escape, nonascii)
-    nmstart = "[_a-z]|%s|%s" % (escape, nonascii)
+    nmchar = f"[_a-z0-9-]|{escape}|{nonascii}"
+    nmstart = f"[_a-z]|{escape}|{nonascii}"
 
 
 class MatchFunc(Protocol):
@@ -1009,9 +964,9 @@ def tokenize(s: str) -> Iterator[Token]:
             assert match, "Should have found at least an empty match"
             end_pos = match.end()
             if end_pos == len_s:
-                raise SelectorSyntaxError("Unclosed string at %s" % pos)
+                raise SelectorSyntaxError(f"Unclosed string at {pos}")
             if s[end_pos] != quote:
-                raise SelectorSyntaxError("Invalid string at %s" % pos)
+                raise SelectorSyntaxError(f"Invalid string at {pos}")
             value = _sub_simple_escape(
                 _replace_simple,
                 _sub_unicode_escape(
@@ -1074,7 +1029,7 @@ def peek(self) -> Token:
     def next_ident(self) -> str:
         next = self.next()
         if next.type != "IDENT":
-            raise SelectorSyntaxError("Expected ident, got %s" % (next,))
+            raise SelectorSyntaxError(f"Expected ident, got {next}")
         return cast(str, next.value)
 
     def next_ident_or_star(self) -> str | None:
@@ -1083,7 +1038,7 @@ def next_ident_or_star(self) -> str | None:
             return next.value
         if next == ("DELIM", "*"):
             return None
-        raise SelectorSyntaxError("Expected ident or '*', got %s" % (next,))
+        raise SelectorSyntaxError(f"Expected ident or '*', got {next}")
 
     def skip_whitespace(self) -> None:
         peek = self.peek()
diff --git a/cssselect/xpath.py b/cssselect/xpath.py
index e9d1065..4018bcf 100644
--- a/cssselect/xpath.py
+++ b/cssselect/xpath.py
@@ -64,15 +64,15 @@ def __init__(
     def __str__(self) -> str:
         path = str(self.path) + str(self.element)
         if self.condition:
-            path += "[%s]" % self.condition
+            path += f"[{self.condition}]"
         return path
 
     def __repr__(self) -> str:
-        return "%s[%s]" % (self.__class__.__name__, self)
+        return f"{self.__class__.__name__}[{self}]"
 
     def add_condition(self, condition: str, conjuction: str = "and") -> Self:
         if self.condition:
-            self.condition = "(%s) %s (%s)" % (self.condition, conjuction, condition)
+            self.condition = f"({self.condition}) {conjuction} ({condition})"
         else:
             self.condition = condition
         return self
@@ -81,9 +81,7 @@ def add_name_test(self) -> None:
         if self.element == "*":
             # We weren't doing a test anyway
             return
-        self.add_condition(
-            "name() = %s" % GenericTranslator.xpath_literal(self.element)
-        )
+        self.add_condition(f"name() = {GenericTranslator.xpath_literal(self.element)}")
         self.element = "*"
 
     def add_star_prefix(self) -> None:
@@ -253,7 +251,7 @@ def selector_to_xpath(
         """
         tree = getattr(selector, "parsed_tree", None)
         if not tree:
-            raise TypeError("Expected a parsed selector, got %r" % (selector,))
+            raise TypeError(f"Expected a parsed selector, got {selector!r}")
         xpath = self.xpath(tree)
         assert isinstance(xpath, self.xpathexpr_cls)  # help debug a missing 'return'
         if translate_pseudo_elements and selector.pseudo_element:
@@ -275,9 +273,9 @@ def xpath_pseudo_element(
     def xpath_literal(s: str) -> str:
         s = str(s)
         if "'" not in s:
-            s = "'%s'" % s
+            s = f"'{s}'"
         elif '"' not in s:
-            s = '"%s"' % s
+            s = f'"{s}"'
         else:
             parts_quoted = [
                 f'"{part}"' if "'" in part else f"'{part}'"
@@ -292,10 +290,10 @@ def xpath(self, parsed_selector: Tree) -> XPathExpr:
         type_name = type(parsed_selector).__name__
         method = cast(
             Optional[Callable[[Tree], XPathExpr]],
-            getattr(self, "xpath_%s" % type_name.lower(), None),
+            getattr(self, f"xpath_{type_name.lower()}", None),
         )
         if method is None:
-            raise ExpressionError("%s is not supported." % type_name)
+            raise ExpressionError(f"{type_name} is not supported.")
         return method(parsed_selector)
 
     # Dispatched by parsed object type
@@ -305,7 +303,7 @@ def xpath_combinedselector(self, combined: CombinedSelector) -> XPathExpr:
         combinator = self.combinator_mapping[combined.combinator]
         method = cast(
             Callable[[XPathExpr, XPathExpr], XPathExpr],
-            getattr(self, "xpath_%s_combinator" % combinator),
+            getattr(self, f"xpath_{combinator}_combinator"),
         )
         return method(self.xpath(combined.selector), self.xpath(combined.subselector))
 
@@ -314,7 +312,7 @@ def xpath_negation(self, negation: Negation) -> XPathExpr:
         sub_xpath = self.xpath(negation.subselector)
         sub_xpath.add_name_test()
         if sub_xpath.condition:
-            return xpath.add_condition("not(%s)" % sub_xpath.condition)
+            return xpath.add_condition(f"not({sub_xpath.condition})")
         return xpath.add_condition("0")
 
     def xpath_relation(self, relation: Relation) -> XPathExpr:
@@ -326,8 +324,7 @@ def xpath_relation(self, relation: Relation) -> XPathExpr:
             Callable[[XPathExpr, XPathExpr], XPathExpr],
             getattr(
                 self,
-                "xpath_relation_%s_combinator"
-                % self.combinator_mapping[cast(str, combinator.value)],
+                f"xpath_relation_{self.combinator_mapping[cast(str, combinator.value)]}_combinator",
             ),
         )
         return method(xpath, right)
@@ -352,24 +349,24 @@ def xpath_specificityadjustment(self, matching: SpecificityAdjustment) -> XPathE
 
     def xpath_function(self, function: Function) -> XPathExpr:
         """Translate a functional pseudo-class."""
-        method_name = "xpath_%s_function" % function.name.replace("-", "_")
+        method_name = "xpath_{}_function".format(function.name.replace("-", "_"))
         method = cast(
             Optional[Callable[[XPathExpr, Function], XPathExpr]],
             getattr(self, method_name, None),
         )
         if not method:
-            raise ExpressionError("The pseudo-class :%s() is unknown" % function.name)
+            raise ExpressionError(f"The pseudo-class :{function.name}() is unknown")
         return method(self.xpath(function.selector), function)
 
     def xpath_pseudo(self, pseudo: Pseudo) -> XPathExpr:
         """Translate a pseudo-class."""
-        method_name = "xpath_%s_pseudo" % pseudo.ident.replace("-", "_")
+        method_name = "xpath_{}_pseudo".format(pseudo.ident.replace("-", "_"))
         method = cast(
             Optional[Callable[[XPathExpr], XPathExpr]], getattr(self, method_name, None)
         )
         if not method:
             # TODO: better error message for pseudo-elements?
-            raise ExpressionError("The pseudo-class :%s is unknown" % pseudo.ident)
+            raise ExpressionError(f"The pseudo-class :{pseudo.ident} is unknown")
         return method(self.xpath(pseudo.selector))
 
     def xpath_attrib(self, selector: Attrib) -> XPathExpr:
@@ -377,7 +374,7 @@ def xpath_attrib(self, selector: Attrib) -> XPathExpr:
         operator = self.attribute_operator_mapping[selector.operator]
         method = cast(
             Callable[[XPathExpr, str, Optional[str]], XPathExpr],
-            getattr(self, "xpath_attrib_%s" % operator),
+            getattr(self, f"xpath_attrib_{operator}"),
         )
         if self.lower_case_attribute_names:
             name = selector.attrib.lower()
@@ -385,12 +382,12 @@ def xpath_attrib(self, selector: Attrib) -> XPathExpr:
             name = selector.attrib
         safe = is_safe_name(name)
         if selector.namespace:
-            name = "%s:%s" % (selector.namespace, name)
+            name = f"{selector.namespace}:{name}"
             safe = safe and is_safe_name(selector.namespace)
         if safe:
             attrib = "@" + name
         else:
-            attrib = "attribute::*[name() = %s]" % self.xpath_literal(name)
+            attrib = f"attribute::*[name() = {self.xpath_literal(name)}]"
         if selector.value is None:
             value = None
         elif self.lower_case_attribute_values:
@@ -423,7 +420,7 @@ def xpath_element(self, selector: Element) -> XPathExpr:
         if selector.namespace:
             # Namespace prefixes are case-sensitive.
             # http://www.w3.org/TR/css3-namespace/#prefixes
-            element = "%s:%s" % (selector.namespace, element)
+            element = f"{selector.namespace}:{element}"
             safe = safe and bool(is_safe_name(selector.namespace))
         xpath = self.xpathexpr_cls(element=element)
         if not safe:
@@ -496,7 +493,7 @@ def xpath_nth_child_function(
         try:
             a, b = parse_series(function.arguments)
         except ValueError as ex:
-            raise ExpressionError("Invalid series: '%r'" % function.arguments) from ex
+            raise ExpressionError(f"Invalid series: '{function.arguments!r}'") from ex
 
         # From https://www.w3.org/TR/css3-selectors/#structural-pseudos:
         #
@@ -558,20 +555,20 @@ def xpath_nth_child_function(
         # `add_name_test` boolean is inverted and somewhat counter-intuitive:
         #
         # nth_of_type() calls nth_child(add_name_test=False)
-        nodetest = "*" if add_name_test else "%s" % xpath.element
+        nodetest = "*" if add_name_test else f"{xpath.element}"
 
         # count siblings before or after the element
         if not last:
-            siblings_count = "count(preceding-sibling::%s)" % nodetest
+            siblings_count = f"count(preceding-sibling::{nodetest})"
         else:
-            siblings_count = "count(following-sibling::%s)" % nodetest
+            siblings_count = f"count(following-sibling::{nodetest})"
 
         # special case of fixed position: nth-*(0n+b)
         # if a == 0:
         # ~~~~~~~~~~
         #    count(***-sibling::***) = b-1
         if a == 0:
-            return xpath.add_condition("%s = %s" % (siblings_count, b_min_1))
+            return xpath.add_condition(f"{siblings_count} = {b_min_1}")
 
         expressions = []
 
@@ -580,12 +577,12 @@ def xpath_nth_child_function(
             # so if a>0, and (b-1)<=0, an "n" exists to satisfy this,
             # therefore, the predicate is only interesting if (b-1)>0
             if b_min_1 > 0:
-                expressions.append("%s >= %s" % (siblings_count, b_min_1))
+                expressions.append(f"{siblings_count} >= {b_min_1}")
         else:
             # if a<0, and (b-1)<0, no "n" satisfies this,
             # this is tested above as an early exist condition
             # otherwise,
-            expressions.append("%s <= %s" % (siblings_count, b_min_1))
+            expressions.append(f"{siblings_count} <= {b_min_1}")
 
         # operations modulo 1 or -1 are simpler, one only needs to verify:
         #
@@ -608,10 +605,9 @@ def xpath_nth_child_function(
             b_neg = (-b_min_1) % abs(a)
 
             if b_neg != 0:
-                b_neg_as_str = "+%s" % b_neg
-                left = "(%s %s)" % (left, b_neg_as_str)
+                left = f"({left} +{b_neg})"
 
-            expressions.append("%s mod %s = 0" % (left, a))
+            expressions.append(f"{left} mod {a} = 0")
 
         template = "(%s)" if len(expressions) > 1 else "%s"
         xpath.add_condition(
@@ -647,20 +643,18 @@ def xpath_contains_function(
         # http://www.w3.org/TR/2001/CR-css3-selectors-20011113/#content-selectors
         if function.argument_types() not in (["STRING"], ["IDENT"]):
             raise ExpressionError(
-                "Expected a single string or ident for :contains(), got %r"
-                % function.arguments
+                f"Expected a single string or ident for :contains(), got {function.arguments!r}"
             )
         value = cast(str, function.arguments[0].value)
-        return xpath.add_condition("contains(., %s)" % self.xpath_literal(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(
-                "Expected a single string or ident for :lang(), got %r"
-                % function.arguments
+                f"Expected a single string or ident for :lang(), got {function.arguments!r}"
             )
         value = cast(str, function.arguments[0].value)
-        return xpath.add_condition("lang(%s)" % (self.xpath_literal(value)))
+        return xpath.add_condition(f"lang({self.xpath_literal(value)})")
 
     # Pseudo: dispatch by pseudo-class name
 
@@ -684,12 +678,12 @@ def xpath_last_child_pseudo(self, xpath: XPathExpr) -> XPathExpr:
     def xpath_first_of_type_pseudo(self, xpath: XPathExpr) -> XPathExpr:
         if xpath.element == "*":
             raise ExpressionError("*:first-of-type is not implemented")
-        return xpath.add_condition("count(preceding-sibling::%s) = 0" % xpath.element)
+        return xpath.add_condition(f"count(preceding-sibling::{xpath.element}) = 0")
 
     def xpath_last_of_type_pseudo(self, xpath: XPathExpr) -> XPathExpr:
         if xpath.element == "*":
             raise ExpressionError("*:last-of-type is not implemented")
-        return xpath.add_condition("count(following-sibling::%s) = 0" % xpath.element)
+        return xpath.add_condition(f"count(following-sibling::{xpath.element}) = 0")
 
     def xpath_only_child_pseudo(self, xpath: XPathExpr) -> XPathExpr:
         return xpath.add_condition("count(parent::*/child::*) = 1")
@@ -697,7 +691,7 @@ def xpath_only_child_pseudo(self, xpath: XPathExpr) -> XPathExpr:
     def xpath_only_of_type_pseudo(self, xpath: XPathExpr) -> XPathExpr:
         if xpath.element == "*":
             raise ExpressionError("*:only-of-type is not implemented")
-        return xpath.add_condition("count(parent::*/child::%s) = 1" % xpath.element)
+        return xpath.add_condition(f"count(parent::*/child::{xpath.element}) = 1")
 
     def xpath_empty_pseudo(self, xpath: XPathExpr) -> XPathExpr:
         return xpath.add_condition("not(*) and not(string-length())")
@@ -729,7 +723,7 @@ def xpath_attrib_equals(
         self, xpath: XPathExpr, name: str, value: str | None
     ) -> XPathExpr:
         assert value is not None
-        xpath.add_condition("%s = %s" % (name, self.xpath_literal(value)))
+        xpath.add_condition(f"{name} = {self.xpath_literal(value)}")
         return xpath
 
     def xpath_attrib_different(
@@ -738,11 +732,9 @@ def xpath_attrib_different(
         assert value is not None
         # FIXME: this seems like a weird hack...
         if value:
-            xpath.add_condition(
-                "not(%s) or %s != %s" % (name, name, self.xpath_literal(value))
-            )
+            xpath.add_condition(f"not({name}) or {name} != {self.xpath_literal(value)}")
         else:
-            xpath.add_condition("%s != %s" % (name, self.xpath_literal(value)))
+            xpath.add_condition(f"{name} != {self.xpath_literal(value)}")
         return xpath
 
     def xpath_attrib_includes(
@@ -774,7 +766,7 @@ def xpath_attrib_prefixmatch(
     ) -> XPathExpr:
         if value:
             xpath.add_condition(
-                "%s and starts-with(%s, %s)" % (name, name, self.xpath_literal(value))
+                f"{name} and starts-with({name}, {self.xpath_literal(value)})"
             )
         else:
             xpath.add_condition("0")
@@ -786,8 +778,7 @@ def xpath_attrib_suffixmatch(
         if value:
             # Oddly there is a starts-with in XPath 1.0, but not ends-with
             xpath.add_condition(
-                "%s and substring(%s, string-length(%s)-%s) = %s"
-                % (name, name, name, len(value) - 1, self.xpath_literal(value))
+                f"{name} and substring({name}, string-length({name})-{len(value) - 1}) = {self.xpath_literal(value)}"
             )
         else:
             xpath.add_condition("0")
@@ -799,7 +790,7 @@ def xpath_attrib_substringmatch(
         if value:
             # Attribute selectors are case sensitive
             xpath.add_condition(
-                "%s and contains(%s, %s)" % (name, name, self.xpath_literal(value))
+                f"{name} and contains({name}, {self.xpath_literal(value)})"
             )
         else:
             xpath.add_condition("0")
@@ -844,8 +835,7 @@ def xpath_checked_pseudo(self, xpath: XPathExpr) -> XPathExpr:  # type: ignore[o
     def xpath_lang_function(self, xpath: XPathExpr, function: Function) -> XPathExpr:
         if function.argument_types() not in (["STRING"], ["IDENT"]):
             raise ExpressionError(
-                "Expected a single string or ident for :lang(), got %r"
-                % function.arguments
+                f"Expected a single string or ident for :lang(), got {function.arguments!r}"
             )
         value = function.arguments[0].value
         assert value
diff --git a/pyproject.toml b/pyproject.toml
index 5ddbeb6..7e43445 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -170,9 +170,6 @@ ignore = [
     "S101",
     # Using lxml to parse untrusted data is known to be vulnerable to XML attacks
     "S320",
-
-    # TODO: Use format specifiers instead of percent format
-    "UP031",
 ]
 
 [tool.ruff.lint.pydocstyle]
diff --git a/tests/test_cssselect.py b/tests/test_cssselect.py
index 0a95f92..e2e3ba5 100644
--- a/tests/test_cssselect.py
+++ b/tests/test_cssselect.py
@@ -258,7 +258,7 @@ def test_pseudo_repr(css: str) -> str:
 
         # Special cases for CSS 2.1 pseudo-elements are ignored by default
         for pseudo in ("after", "before", "first-line", "first-letter"):
-            (selector,) = parse("e:%s" % pseudo)
+            (selector,) = parse(f"e:{pseudo}")
             assert selector.pseudo_element == pseudo
             assert GenericTranslator().selector_to_xpath(selector, prefix="") == "e"
 
@@ -631,24 +631,23 @@ def xpath_pseudo_element(
                 self, xpath: XPathExpr, pseudo_element: PseudoElement
             ) -> XPathExpr:
                 if isinstance(pseudo_element, FunctionalPseudoElement):
-                    method_name = "xpath_%s_functional_pseudo_element" % (
+                    method_name = "xpath_{}_functional_pseudo_element".format(
                         pseudo_element.name.replace("-", "_")
                     )
                     method = getattr(self, method_name, None)
                     if not method:
                         raise ExpressionError(
-                            "The functional pseudo-element ::%s() is unknown"
-                            % pseudo_element.name
+                            f"The functional pseudo-element ::{pseudo_element.name}() is unknown"
                         )
                     xpath = method(xpath, pseudo_element.arguments)
                 else:
-                    method_name = "xpath_%s_simple_pseudo_element" % (
+                    method_name = "xpath_{}_simple_pseudo_element".format(
                         pseudo_element.replace("-", "_")
                     )
                     method = getattr(self, method_name, None)
                     if not method:
                         raise ExpressionError(
-                            "The pseudo-element ::%s is unknown" % pseudo_element
+                            f"The pseudo-element ::{pseudo_element} is unknown"
                         )
                     xpath = method(xpath)
                 return xpath
@@ -660,7 +659,7 @@ def xpath_nb_attr_function(
             ) -> XPathExpr:
                 assert function.arguments[0].value
                 nb_attributes = int(function.arguments[0].value)
-                return xpath.add_condition("count(@*)=%d" % nb_attributes)
+                return xpath.add_condition(f"count(@*)={nb_attributes}")
 
             # pseudo-class:
             # elements that have 5 attributes
@@ -674,7 +673,7 @@ def xpath_attr_functional_pseudo_element(
             ) -> XPathExpr:
                 attribute_name = arguments[0].value
                 other = XPathExpr(
-                    "@%s" % attribute_name,
+                    f"@{attribute_name}",
                     "",
                 )
                 return xpath.join("/", other)
@@ -739,7 +738,7 @@ def operator_id(selector: str) -> list[str]:
 
     def test_series(self) -> None:
         def series(css: str) -> tuple[int, int] | None:
-            (selector,) = parse(":nth-child(%s)" % css)
+            (selector,) = parse(f":nth-child({css})")
             args = typing.cast(FunctionalPseudoElement, selector.parsed_tree).arguments
             try:
                 return parse_series(args)