Remove removing support for py 3.8

Author: jsa34

python/cucumber_expressions/argument.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import Optional, List
 
 from cucumber_expressions.parameter_type import ParameterType
 from cucumber_expressions.tree_regexp import TreeRegexp, Group
@@ -19,8 +19,8 @@ def __init__(
     def build(
         tree_regexp: TreeRegexp,
         text: str,
-        parameter_types_and_names: list[tuple[ParameterType, Optional[str]]],
-    ) -> Optional[list[Argument]]:
+        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:
             if not isinstance(item, tuple) or len(item) != 2:

python/cucumber_expressions/ast.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Optional, Any
+from typing import Optional, List, Any
 
 
 class NodeType(Enum):
@@ -41,18 +41,38 @@ class Node:
     def __init__(
         self,
         ast_type: NodeType,
-        nodes: Optional[list[Node]],
+        nodes: Optional[List[Node]],
         token: Optional[str],
         start: int,
         end: int,
     ):
         if nodes is None and token is None:
             raise Exception("Either nodes or token must be defined")
-        self.ast_type = ast_type
-        self.nodes = nodes
-        self.token = token
-        self.start = start
-        self.end = end
+        self._ast_type = ast_type
+        self._nodes = nodes
+        self._token = token
+        self._start = start
+        self._end = end
+
+    @property
+    def ast_type(self) -> NodeType:
+        return self._ast_type
+
+    @property
+    def nodes(self) -> List[Node]:
+        return self._nodes
+
+    @property
+    def token(self) -> str:
+        return self._token
+
+    @property
+    def start(self) -> int:
+        return self._start
+
+    @property
+    def end(self) -> int:
+        return self._end
 
     @property
     def text(self) -> str:
@@ -71,10 +91,26 @@ def to_json(self) -> dict[str, Any]:
 
 class Token:
     def __init__(self, ast_type: TokenType, text: str, start: int, end: int):
-        self.ast_type = ast_type
-        self.text = text
-        self.start = start
-        self.end = end
+        self._ast_type = ast_type
+        self._text = text
+        self._start = start
+        self._end = end
+
+    @property
+    def ast_type(self):
+        return self._ast_type
+
+    @property
+    def text(self):
+        return self._text
+
+    @property
+    def start(self):
+        return self._start
+
+    @property
+    def end(self):
+        return self._end
 
     @staticmethod
     def is_escape_character(char: str) -> bool:

python/cucumber_expressions/combinatorial_generated_expression_factory.py

@@ -1,3 +1,5 @@
+from typing import List
+
 from cucumber_expressions.generated_expression import GeneratedExpression
 from cucumber_expressions.parameter_type import ParameterType
 
@@ -10,16 +12,16 @@ 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

python/cucumber_expressions/expression.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 
 from cucumber_expressions.argument import Argument
 from cucumber_expressions.ast import Node, NodeType
@@ -22,12 +22,12 @@ class CucumberExpression:
     def __init__(self, expression: str, parameter_type_registry: ParameterTypeRegistry):
         self.expression = expression
         self.parameter_type_registry = parameter_type_registry
-        self.parameter_types_and_names: list[tuple[ParameterType, Optional[str]]] = []
+        self.parameter_types_and_names: List[tuple[ParameterType, Optional[str]]] = []
         self.tree_regexp = TreeRegexp(
             self.rewrite_to_regex(CucumberExpressionParser().parse(self.expression))
         )
 
-    def match(self, text: str) -> Optional[list[Argument]]:
+    def match(self, text: str) -> Optional[List[Argument]]:
         return Argument.build(self.tree_regexp, text, self.parameter_types_and_names)
 
     @property
@@ -130,5 +130,5 @@ def get_possible_node_with_optionals(self, node: Node) -> Optional[Node]:
         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]

python/cucumber_expressions/expression_generator.py

@@ -1,5 +1,6 @@
 import functools
 import re
+from typing import List
 
 from cucumber_expressions.generated_expression import GeneratedExpression
 from cucumber_expressions.parameter_type import ParameterType
@@ -14,10 +15,10 @@ class CucumberExpressionGenerator:
     def __init__(self, parameter_type_registry: ParameterTypeRegistry):
         self.parameter_type_registry = parameter_type_registry
 
-    def generate_expressions(self, text: str) -> list[GeneratedExpression]:
+    def generate_expressions(self, text: str) -> List[GeneratedExpression]:
         parameter_type_combinations = []
         parameter_type_matchers = self.create_parameter_type_matchers(text)
-        expression_template: list[str] = []
+        expression_template: List[str] = []
         pos = 0
 
         while True:
@@ -92,7 +93,7 @@ def create_parameter_type_matchers(self, text) -> list[ParameterTypeMatcher]:
     @staticmethod
     def create_parameter_type_matchers_with_type(
         parameter_type, text
-    ) -> list[ParameterTypeMatcher]:
+    ) -> List[ParameterTypeMatcher]:
         return [
             ParameterTypeMatcher(parameter_type, re.compile(f"({regexp})"), text, 0)
             for regexp in parameter_type.regexps

python/cucumber_expressions/expression_parser.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import NamedTuple, Optional, Callable
+from typing import NamedTuple, Optional, Callable, List
 
 from cucumber_expressions.ast import Token, TokenType, Node, NodeType
 from cucumber_expressions.errors import (
@@ -18,7 +18,7 @@ class Result(NamedTuple):
 
 class Parser(NamedTuple):
     expression: str
-    tokens: list[Token]
+    tokens: List[Token]
     current: int
 
 
@@ -75,7 +75,7 @@ def parse(self, expression: str) -> Node:
 
         # optional := '(' + option* + ')'
         # option := optional | parameter | text
-        optional_sub_parsers: list = []
+        optional_sub_parsers = []
         parse_optional = self.parse_between(
             NodeType.OPTIONAL,
             TokenType.BEGIN_OPTIONAL,
@@ -170,7 +170,7 @@ def parse_between(
         ast_type: NodeType,
         begin_token: TokenType,
         end_token: TokenType,
-        parsers: list,
+        parsers: List,
     ) -> Callable[[Parser], Result | tuple[int, Node]]:
         def _parse_between(parser: Parser):
             if not self.looking_at(parser.tokens, parser.current, begin_token):
@@ -205,7 +205,7 @@ def _parse_between(parser: Parser):
 
     @staticmethod
     def parse_token(
-        expression, parsers: list, tokens: list[Token], start_at: int
+        expression, parsers: List, tokens: List[Token], start_at: int
     ) -> Result:
         for parser in parsers:
             consumed, ast = parser(Parser(expression, tokens, start_at))
@@ -217,14 +217,14 @@ def parse_token(
     def parse_tokens_until(
         self,
         expression,
-        parsers: list,
-        tokens: list[Token],
+        parsers: List,
+        tokens: List[Token],
         start_at: int,
-        end_tokens: list[TokenType],
-    ) -> tuple[int, list[Node]]:
+        end_tokens: List[TokenType],
+    ) -> tuple[int, List[Node]]:
         current = start_at
         size = len(tokens)
-        ast: list[Node] = []
+        ast: List[Node] = []
         while current < size:
             if self.looking_at_any(tokens, current, end_tokens):
                 break
@@ -238,14 +238,14 @@ def parse_tokens_until(
         return current - start_at, ast
 
     def looking_at_any(
-        self, tokens: list[Token], position: int, token_types: list[TokenType]
+        self, tokens: List[Token], position: int, token_types: List[TokenType]
     ) -> bool:
         return any(
             self.looking_at(tokens, position, token_type) for token_type in token_types
         )
 
     @staticmethod
-    def looking_at(tokens: list[Token], position: int, token_type: TokenType) -> bool:
+    def looking_at(tokens: List[Token], position: int, token_type: TokenType) -> bool:
         if position < 0:
             # If configured correctly this will never happen
             # Keep for completeness
@@ -255,8 +255,8 @@ def looking_at(tokens: list[Token], position: int, token_type: TokenType) -> boo
         return tokens[position].ast_type == token_type
 
     def split_alternatives(
-        self, start: int, end: int, alternation: list[Node]
-    ) -> list[Node]:
+        self, start: int, end: int, alternation: List[Node]
+    ) -> List[Node]:
         separators = []
         alternatives = []
         alternative = []
@@ -272,8 +272,8 @@ def split_alternatives(
 
     @staticmethod
     def create_alternative_nodes(
-        start: int, end: int, separators: list, alternatives: list
-    ) -> list[Node]:
+        start: int, end: int, separators: List, alternatives: List
+    ) -> List[Node]:
         for index, alternative in enumerate(alternatives):
             if index == 0:
                 right_separator = separators[index]

python/cucumber_expressions/expression_tokenizer.py

@@ -1,3 +1,5 @@
+from typing import List
+
 from cucumber_expressions.ast import TokenType, Token
 from cucumber_expressions.errors import (
     TheEndOfLineCannotBeEscaped,
@@ -8,11 +10,11 @@
 class CucumberExpressionTokenizer:
     def __init__(self):
         self.expression: str = ""
-        self.buffer: list[str] = []
+        self.buffer: List[str] = []
         self.escaped: int = 0
         self.buffer_start_index: int = 0
 
-    def tokenize(self, expression: str, to_json: bool = False) -> list[Token]:
+    def tokenize(self, expression: str, to_json: bool = False) -> List[Token]:
         self.expression = expression
         tokens = []
         previous_token_type = TokenType.START_OF_LINE
@@ -48,7 +50,7 @@ def tokenize(self, expression: str, to_json: bool = False) -> list[Token]:
 
         tokens.append(Token(TokenType.END_OF_LINE, "", len(chars), len(chars)))
 
-        def convert_to_json_format(_tokens: list[Token]) -> list:
+        def convert_to_json_format(_tokens: List[Token]) -> List:
             return [
                 {
                     "type": t.ast_type.value,

python/cucumber_expressions/generated_expression.py

@@ -5,14 +5,14 @@ def __init__(self, expression_template: str, parameter_types):
         self.usage_by_type_name = {}
 
     @property
-    def source(self) -> str:
+    def source(self):
         return self.expression_template % tuple(p.name for p in self.parameter_types)
 
     @property
-    def parameter_names(self) -> list[str]:
+    def parameter_names(self):
         return [self.get_parameter_name(t.name) for t in self.parameter_types]
 
-    def get_parameter_name(self, type_name: str) -> str:
+    def get_parameter_name(self, type_name):
         count = self.usage_by_type_name.get(type_name) or 0
         count = count + 1
         self.usage_by_type_name[type_name] = count

python/cucumber_expressions/group.py

@@ -1,17 +1,38 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+
 class Group:
     def __init__(
         self,
         value: str,
         start: int,
         end: int,
-        children: list["Group"],
-        name: str | None = None,
+        children: List[Group],
+        name: Optional[str] = None,
     ):
-        self.children = children
+        self._children = children
+        self._value = value
+        self._start = start
+        self._end = end
         self.name = name
-        self.value = value
-        self.start = start
-        self.end = end
+
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def start(self):
+        return self._start
+
+    @property
+    def end(self):
+        return self._end
+
+    @property
+    def children(self):
+        return self._children
 
     @property
     def values(self):