debt: Extend Python linting rules

Author: kieran-ryan

python/.pre-commit-config.yaml

@@ -1,7 +1,14 @@
 repos:
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.0
+    rev: v0.14.0
     hooks:
       - id: ruff-check
         args: [--fix]
       - id: ruff-format
+-   repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.9.1
+    hooks:
+      # Ensure the uv lock file is up to date
+      - id: uv-lock
+        files: pyproject.toml
+        args: [--project, python]

python/pyproject.toml

@@ -22,11 +22,12 @@ classifiers = [
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Topic :: Software Development :: Testing",
@@ -43,7 +44,24 @@ Changelog = "https://github.com/cucumber/cucumber-expressions/releases"
 
 [tool.ruff.lint]
 extend-select = [
+  "B",
+  "C4",
+  "COM",
+  "FURB",
   "I",
+  "ISC",
+  "N",
+  "PERF",
+  "PIE",
+  "RET",
+  "TID",
+  "UP",
+]
+ignore = [
+    "B023",
+    "COM812",
+    "N818",
+    "PERF401",
 ]
 
 [dependency-groups]

python/src/cucumber_expressions/argument.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List, Optional
-
 from cucumber_expressions.errors import CucumberExpressionError
 from cucumber_expressions.group import Group
 from cucumber_expressions.parameter_type import ParameterType
@@ -15,8 +13,10 @@ def __init__(self, group, parameter_type):
 
     @staticmethod
     def build(
-        tree_regexp: TreeRegexp, text: str, parameter_types: List
-    ) -> Optional[List[Argument]]:
+        tree_regexp: TreeRegexp,
+        text: str,
+        parameter_types: list,
+    ) -> list[Argument] | None:
         match_group = tree_regexp.match(text)
         if not match_group:
             return None
@@ -25,7 +25,7 @@ def build(
 
         if len(arg_groups) != len(parameter_types):
             raise CucumberExpressionError(
-                f"Group has {len(arg_groups)} capture groups, but there were {len(parameter_types)} parameter types"
+                f"Group has {len(arg_groups)} capture groups, but there were {len(parameter_types)} parameter types",
             )
 
         return [

python/src/cucumber_expressions/ast.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import List, Optional
 
 
 class NodeType(Enum):
@@ -41,8 +40,8 @@ class Node:
     def __init__(
         self,
         ast_type: NodeType,
-        nodes: Optional[List[Node]],
-        token: Optional[str],
+        nodes: [list[Node]] | None,
+        token: str | None,
         start: int,
         end: int,
     ):
@@ -59,7 +58,7 @@ def ast_type(self) -> NodeType:
         return self._ast_type
 
     @property
-    def nodes(self) -> List[Node]:
+    def nodes(self) -> list[Node]:
         return self._nodes
 
     @property

python/src/cucumber_expressions/combinatorial_generated_expression_factory.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from cucumber_expressions.generated_expression import GeneratedExpression
 from cucumber_expressions.parameter_type import ParameterType
 
@@ -12,22 +10,22 @@ def __init__(self, expression_template, parameter_type_combinations):
         self.expression_template = expression_template
         self.parameter_type_combinations = parameter_type_combinations
 
-    def generate_expressions(self) -> List[GeneratedExpression]:
+    def generate_expressions(self) -> list[GeneratedExpression]:
         generated_expressions = []
         self.generate_permutations(generated_expressions, 0, [])
         return generated_expressions
 
     def generate_permutations(
         self,
-        generated_expressions: List[GeneratedExpression],
+        generated_expressions: list[GeneratedExpression],
         depth: int,
-        current_parameter_types: List[ParameterType],
+        current_parameter_types: list[ParameterType],
     ):
         if len(generated_expressions) >= MAX_EXPRESSIONS:
             return
         if depth == len(self.parameter_type_combinations):
             generated_expressions.append(
-                GeneratedExpression(self.expression_template, current_parameter_types)
+                GeneratedExpression(self.expression_template, current_parameter_types),
             )
             return
         for parameter_type_combination in self.parameter_type_combinations[depth]:
@@ -36,5 +34,7 @@ def generate_permutations(
             new_current_parameter_types = current_parameter_types.copy()
             new_current_parameter_types.append(parameter_type_combination)
             self.generate_permutations(
-                generated_expressions, depth + 1, new_current_parameter_types
+                generated_expressions,
+                depth + 1,
+                new_current_parameter_types,
             )

python/src/cucumber_expressions/errors.py

@@ -2,7 +2,11 @@
 
 
 def generate_message(
-    index: int, expression: str, pointer: str, problem: str, solution: str
+    index: int,
+    expression: str,
+    pointer: str,
+    problem: str,
+    solution: str,
 ):
     return "\n".join(
         [
@@ -12,7 +16,7 @@ def generate_message(
             pointer,
             problem + ".",
             solution,
-        ]
+        ],
     )
 
 
@@ -43,7 +47,7 @@ def __init__(self, node, expression: str):
                 pointer=point_at_located(node),
                 problem="An alternative may not exclusively contain optionals",
                 solution="If you did not mean to use an optional you can use '\\(' to escape the '('",
-            )
+            ),
         )
 
 
@@ -56,7 +60,7 @@ def __init__(self, node, expression: str):
                 pointer=point_at_located(node),
                 problem="Alternative may not be empty",
                 solution="If you did not mean to use an alternative you can use '\\/' to escape the '/'",
-            )
+            ),
         )
 
 
@@ -69,7 +73,7 @@ def __init__(self, expression: str, index: int):
                 pointer=point_at(index),
                 problem="Only the characters '{', '}', '(', ')', '\\', '/' and whitespace can be escaped",
                 solution="If you did mean to use an '\\' you can use '\\\\' to escape it",
-            )
+            ),
         )
 
 
@@ -82,7 +86,7 @@ def __init__(self, node, expression: str):
                 pointer=point_at_located(node),
                 problem="An optional must contain some text",
                 solution="If you did not mean to use an optional you can use '\\(' to escape the '('",
-            )
+            ),
         )
 
 
@@ -95,7 +99,7 @@ def __init__(self, node, expression: str):
                 pointer=point_at_located(node),
                 problem="An optional may not contain a parameter type",
                 solution="If you did not mean to use an parameter type you can use '\\{' to escape the '{'",
-            )
+            ),
         )
 
 
@@ -111,7 +115,7 @@ def __init__(self, node, expression: str):
                     "If you did not mean to use an optional type you can use '\\(' to escape the '('. "
                     "For more complicated expressions consider using a regular expression instead."
                 ),
-            )
+            ),
         )
 
 
@@ -128,7 +132,7 @@ def __init__(self, expression: str, begin_token, end_token, current):
                 pointer=point_at_located(current),
                 problem=f"The '{begin_symbol}' does not have a matching '{end_symbol}'",
                 solution=f"If you did not intend to use {purpose} you can use '\\{begin_symbol}' to escape the {purpose}",
-            )
+            ),
         )
 
 
@@ -144,7 +148,7 @@ def __init__(self, expression: str, current):
                     "If you did not mean to use an alternation you can use '\\/' to escape the '/'. "
                     "Otherwise rephrase your expression or consider using a regular expression instead."
                 ),
-            )
+            ),
         )
 
 
@@ -154,7 +158,7 @@ def __init__(self, type_name: str):
             "Illegal character in parameter name {"
             + type_name
             + "}. "
-            + "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'"
+            + "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
         )
 
 
@@ -167,7 +171,7 @@ def __init__(self, expression: str, token):
                 pointer=point_at_located(token),
                 problem="Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
                 solution="Did you mean to use a regular expression?",
-            )
+            ),
         )
 
 
@@ -180,7 +184,7 @@ def __init__(self, node, expression: str, undefined_parameter_type_name: str):
                 pointer=point_at_located(node),
                 problem=f"Undefined parameter type '{undefined_parameter_type_name}'",
                 solution=f"Please register a ParameterType for '{undefined_parameter_type_name}'",
-            )
+            ),
         )
 
 
@@ -224,5 +228,5 @@ def __init__(self, expression: str):
                 pointer=point_at(index),
                 problem="The end of line can not be escaped",
                 solution="You can use '\\\\' to escape the '\\'",
-            )
+            ),
         )

python/src/cucumber_expressions/expression.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 from cucumber_expressions.argument import Argument
 from cucumber_expressions.ast import Node, NodeType
 from cucumber_expressions.errors import (
@@ -21,12 +19,12 @@ class CucumberExpression:
     def __init__(self, expression, parameter_type_registry):
         self.expression = expression
         self.parameter_type_registry = parameter_type_registry
-        self.parameter_types: List[ParameterType] = []
+        self.parameter_types: list[ParameterType] = []
         self.tree_regexp = TreeRegexp(
-            self.rewrite_to_regex(CucumberExpressionParser().parse(self.expression))
+            self.rewrite_to_regex(CucumberExpressionParser().parse(self.expression)),
         )
 
-    def match(self, text: str) -> Optional[List[Argument]]:
+    def match(self, text: str) -> list[Argument] | None:
         return Argument.build(self.tree_regexp, text, self.parameter_types)
 
     @property
@@ -61,12 +59,14 @@ def rewrite_optional(self, node: Node):
         _possible_node_with_params = self.get_possible_node_with_parameters(node)
         if _possible_node_with_params:
             raise ParameterIsNotAllowedInOptional(
-                _possible_node_with_params, self.expression
+                _possible_node_with_params,
+                self.expression,
             )
         _possible_node_with_optionals = self.get_possible_node_with_optionals(node)
         if _possible_node_with_optionals:
             raise OptionalIsNotAllowedInOptional(
-                _possible_node_with_optionals, self.expression
+                _possible_node_with_optionals,
+                self.expression,
             )
         if self.are_nodes_empty(node):
             raise OptionalMayNotBeEmpty(node, self.expression)
@@ -79,7 +79,8 @@ def rewrite_alternation(self, node: Node):
                 raise AlternativeMayNotBeEmpty(alternative, self.expression)
             if self.are_nodes_empty(alternative):
                 raise AlternativeMayNotExclusivelyContainOptionals(
-                    alternative, self.expression
+                    alternative,
+                    self.expression,
                 )
         regex = "|".join([self.rewrite_to_regex(_node) for _node in node.nodes])
         return f"(?:{regex})"
@@ -108,14 +109,14 @@ def rewrite_expression(self, node: Node):
     def are_nodes_empty(self, node: Node) -> bool:
         return not any(self.get_nodes_with_ast_type(node, NodeType.TEXT))
 
-    def get_possible_node_with_parameters(self, node: Node) -> Optional[Node]:
+    def get_possible_node_with_parameters(self, node: Node) -> Node | None:
         results = self.get_nodes_with_ast_type(node, NodeType.PARAMETER)
         return results[0] if results else None
 
-    def get_possible_node_with_optionals(self, node: Node) -> Optional[Node]:
+    def get_possible_node_with_optionals(self, node: Node) -> Node | None:
         results = self.get_nodes_with_ast_type(node, NodeType.OPTIONAL)
         return results[0] if results else None
 
     @staticmethod
-    def get_nodes_with_ast_type(node: Node, ast_type: NodeType) -> List[Node]:
+    def get_nodes_with_ast_type(node: Node, ast_type: NodeType) -> list[Node]:
         return [ast_node for ast_node in node.nodes if ast_node.ast_type == ast_type]