Fix flake8

Author: jsa34

python/cucumber_expressions/argument.py

@@ -8,14 +8,18 @@
 
 
 class Argument:
-    def __init__(self, group: Group, parameter_type: ParameterType, name: Optional[str]):
+    def __init__(
+        self, group: Group, parameter_type: ParameterType, name: Optional[str]
+    ):
         self.group = group
         self.parameter_type = parameter_type
         self.name = name
 
     @staticmethod
     def build(
-        tree_regexp: TreeRegexp, text: str, parameter_types_and_names: list[tuple[ParameterType, Optional[str]]]
+        tree_regexp: TreeRegexp,
+        text: str,
+        parameter_types_and_names: list[tuple[ParameterType, Optional[str]]],
     ) -> Optional[list[Argument]]:
         # Check if all elements in parameter_types_and_names are tuples
         for item in parameter_types_and_names:
@@ -31,13 +35,16 @@ def build(
         arg_groups = match_group.children
 
         if len(arg_groups) != len(parameter_types_and_names):
+            param_count = len(parameter_types_and_names)
             raise CucumberExpressionError(
-                f"Group has {len(arg_groups)} capture groups, but there were {len(parameter_types_and_names)} parameter types/names"
+                f"Group has {len(arg_groups)} capture groups, but there were {param_count} parameter types/names"
             )
 
         return [
             Argument(arg_group, parameter_type, parameter_name)
-            for (parameter_type, parameter_name), arg_group in zip(parameter_types_and_names, arg_groups)
+            for (parameter_type, parameter_name), arg_group in zip(
+                parameter_types_and_names, arg_groups
+            )
         ]
 
     @property

python/cucumber_expressions/expression.py

@@ -11,7 +11,8 @@
     OptionalIsNotAllowedInOptional,
     OptionalMayNotBeEmpty,
     AlternativeMayNotBeEmpty,
-    AlternativeMayNotExclusivelyContainOptionals, UndefinedParameterTypeError,
+    AlternativeMayNotExclusivelyContainOptionals,
+    UndefinedParameterTypeError,
 )
 
 ESCAPE_PATTERN = rb"([\\^\[({$.|?*+})\]])"
@@ -59,9 +60,13 @@ def escape_regex(expression) -> str:
 
     def rewrite_optional(self, node: Node) -> str:
         if self.get_possible_node_with_parameters(node):
-            raise ParameterIsNotAllowedInOptional(self.get_possible_node_with_parameters(node), self.expression)
+            raise ParameterIsNotAllowedInOptional(
+                self.get_possible_node_with_parameters(node), self.expression
+            )
         if self.get_possible_node_with_optionals(node):
-            raise OptionalIsNotAllowedInOptional(self.get_possible_node_with_optionals(node), self.expression)
+            raise OptionalIsNotAllowedInOptional(
+                self.get_possible_node_with_optionals(node), self.expression
+            )
         if self.are_nodes_empty(node):
             raise OptionalMayNotBeEmpty(node, self.expression)
         regex = "".join([self.rewrite_to_regex(_node) for _node in node.nodes])
@@ -95,11 +100,15 @@ def rewrite_parameter(self, node: Node) -> str:
             return rf"({regexps[0]})"
         return rf"((?:{')|(?:'.join(regexps)}))"
 
-    def parse_parameter_name(self, name: str) -> tuple[Optional[str], Optional[ParameterType]]:
+    def parse_parameter_name(
+        self, name: str
+    ) -> tuple[Optional[str], Optional[ParameterType]]:
         """Helper function to parse the parameter name and return group_name and parameter_type."""
         if ":" in name:
             group_name, parameter_type_name = name.split(":")
-            parameter_type = self.parameter_type_registry.lookup_by_type_name(parameter_type_name)
+            parameter_type = self.parameter_type_registry.lookup_by_type_name(
+                parameter_type_name
+            )
         else:
             group_name = None
             parameter_type = self.parameter_type_registry.lookup_by_type_name(name)

python/cucumber_expressions/expression_factory.py

@@ -9,7 +9,9 @@
 
 
 class ExpressionFactory:
-    def __init__(self, parameter_type_registry: ParameterTypeRegistry = ParameterTypeRegistry()):
+    def __init__(
+        self, parameter_type_registry: ParameterTypeRegistry = ParameterTypeRegistry()
+    ):
         self.parameter_type_registry = parameter_type_registry
 
     @staticmethod
@@ -31,7 +33,6 @@ def is_cucumber_expression(self, expression_string: str):
                 return False  # Found a form of curly bracket
         return True  # All curly brackets are valid
 
-
     def create_expression(self, expression_string: str):
         if self.is_cucumber_expression(expression_string):
             return CucumberExpression(expression_string, self.parameter_type_registry)

python/cucumber_expressions/group.py

@@ -1,5 +1,12 @@
 class Group:
-    def __init__(self, value: str, start: int, end: int, children: list["Group"], name: str | None = None):
+    def __init__(
+        self,
+        value: str,
+        start: int,
+        end: int,
+        children: list["Group"],
+        name: str | None = None,
+    ):
         self.children = children
         self.name = name
         self.value = value

python/cucumber_expressions/parameter_type.py

@@ -8,11 +8,12 @@
 ILLEGAL_PARAMETER_NAME_PATTERN = re.compile(r"([\[\]()$.|?*+])")
 
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class ParameterType:
     """Creates a new Parameter Type"""
+
     def __init__(
         self,
         name: str | None,
@@ -90,7 +91,9 @@ def _get_regexp_source(regexp_pattern: Pattern) -> str:
                 )
         return regexp_pattern.pattern
 
-    def to_array(self, regexps: Union[list[str], str, list[Pattern], Pattern]) -> list[str]:
+    def to_array(
+        self, regexps: Union[list[str], str, list[Pattern], Pattern]
+    ) -> list[str]:
         """Make a list of regexps if not already"""
         array: list = regexps if isinstance(regexps, list) else [regexps]
         return [

python/cucumber_expressions/parameter_type_registry.py

@@ -83,7 +83,12 @@ def parameter_types(self) -> list:
     def lookup_by_type_name(self, name: str) -> Optional[ParameterType]:
         return self.parameter_type_by_name.get(name)
 
-    def lookup_by_regexp(self, parameter_type_regexp: str, expression_regexp: Union[str, re.Pattern], text: str):
+    def lookup_by_regexp(
+        self,
+        parameter_type_regexp: str,
+        expression_regexp: Union[str, re.Pattern],
+        text: str,
+    ):
         """
         Lookup and match the text using parameter types, then transform the results.
         Supports both named and unnamed capture groups.
@@ -92,8 +97,13 @@ def lookup_by_regexp(self, parameter_type_regexp: str, expression_regexp: Union[
         if not parameter_types:
             return None
         if len(parameter_types) > 1 and not parameter_types[0].prefer_for_regexp_match:
-            from cucumber_expressions.expression_generator import CucumberExpressionGenerator
-            generated_expressions = CucumberExpressionGenerator(self).generate_expressions(text)
+            from cucumber_expressions.expression_generator import (
+                CucumberExpressionGenerator,
+            )
+
+            generated_expressions = CucumberExpressionGenerator(
+                self
+            ).generate_expressions(text)
             raise AmbiguousParameterTypeError(
                 parameter_type_regexp,
                 expression_regexp,

python/cucumber_expressions/regular_expression.py

@@ -16,7 +16,9 @@ class RegularExpression:
     dynamically typed languages."""
 
     def __init__(
-        self, expression_regexp: Union[re.Pattern, str], parameter_type_registry: ParameterTypeRegistry
+        self,
+        expression_regexp: Union[re.Pattern, str],
+        parameter_type_registry: ParameterTypeRegistry,
     ):
         """Creates a new instance. Use this when the transform types are not known in advance,
         and should be determined by the regular expression's capture groups. Use this with
@@ -63,13 +65,17 @@ def _process_capture_group(self, group_source: str):
             # No named group, just return the original pattern
             return None, group_source
 
-    def generate_parameter_types(self, text) -> Generator[tuple[ParameterType, Optional[str]]]:
+    def generate_parameter_types(
+        self, text
+    ) -> Generator[tuple[ParameterType, Optional[str]]]:
         for group_builder in self.tree_regexp.group_builder.children:
             # Extract the raw source for the group
             parameter_type_regexp = group_builder.source
 
             # Process the capture group (check if it's named and clean the pattern)
-            capture_name, cleaned_pattern = self._process_capture_group(parameter_type_regexp)
+            capture_name, cleaned_pattern = self._process_capture_group(
+                parameter_type_regexp
+            )
 
             # Lookup the parameter type using the stripped capture group
             possible_regexp = self.parameter_type_registry.lookup_by_regexp(

python/cucumber_expressions/tree_regexp.py

@@ -49,7 +49,7 @@ def create_group_builder(self, regexp):
                 group_start = group_start_stack.pop()
                 group_start = group_start or 0
                 if group_builder.capturing:
-                    group_builder.source = source[(group_start + 1): index]
+                    group_builder.source = source[(group_start + 1) : index]
                     stack[-1].add(group_builder)
                 else:
                     group_builder.move_children_to(stack[-1])
@@ -61,7 +61,7 @@ def is_named_group(source: str, index: int) -> bool:
         """
         Check if the group at the given index is a named capturing group, e.g. (?P<name>...).
         """
-        return source[index + 1: index + 3] == "P<" and source[index + 3] != "?"
+        return source[index + 1 : index + 3] == "P<" and source[index + 3] != "?"
 
     @staticmethod
     def extract_named_group_name(source: str, index: int) -> str:

python/tests/test_expression.py

@@ -33,6 +33,7 @@ def transform_value(value):
 
     return matches and [(transform_value(arg.value), arg.name) for arg in matches]
 
+
 class TestCucumberExpression:
     @pytest.mark.parametrize("load_test_yamls", get_expectation_yamls(), indirect=True)
     def test_cucumber_expression_matches(self, load_test_yamls: dict):
@@ -115,5 +116,11 @@ def test_unmatched_optional_groups_have_undefined_values(self):
             )
         )
 
-        assert match("{textAndOrNumber}", "TLA", parameter_type_registry)[0] == (["TLA", None], None)
-        assert match("{textAndOrNumber}", "123", parameter_type_registry)[0] == ([None, "123"], None)
+        assert match("{textAndOrNumber}", "TLA", parameter_type_registry)[0] == (
+            ["TLA", None],
+            None,
+        )
+        assert match("{textAndOrNumber}", "123", parameter_type_registry)[0] == (
+            [None, "123"],
+            None,
+        )

python/tests/test_expression_factory.py

@@ -7,7 +7,7 @@ def test_expression_factory_regex():
     input_str = r"I have (?P<cuke_count>\d+) cukes? in my (?P<word>\w+) now"
     expression = ExpressionFactory().create_expression(input_str)
     assert isinstance(expression, RegularExpression)
-    matches = expression.match('I have 4 cukes in my belly now')
+    matches = expression.match("I have 4 cukes in my belly now")
     assert matches[0].value == 4
     assert matches[0].name == "cuke_count"
     assert matches[1].value == "belly"
@@ -18,14 +18,14 @@ def test_expression_factory_cucumber_expression():
     input_str = "I have {name:int} cukes in my {string} now"
     expression = ExpressionFactory().create_expression(input_str)
     assert isinstance(expression, CucumberExpression)
-    matches = expression.match("I have 4 cukes in my \"belly\" now")
+    matches = expression.match('I have 4 cukes in my "belly" now')
     assert matches[0].value == 4
     assert matches[0].name == "name"
     assert matches[1].value == "belly"
     assert matches[1].name is None
 
 
 def test_expression_factory_invalid():
-    input_str = "^(?:(\d{2,4})-)?(\d{1,3})\s*([A-Za-z]{3})\s*(?:\{(\d+,\d+|\d+)\})?(\d{1,2})(?:\{[A-Za-z0-9]+\})?$"
+    input_str = r"^(?:(\d{2,4})-)?(\d{1,3})\s*([A-Za-z]{3})\s*(?:\{(\d+,\d+|\d+)\})?(\d{1,2})(?:\{[A-Za-z0-9]+\})?$"
     expression = ExpressionFactory().create_expression(input_str)
     assert isinstance(expression, RegularExpression)