diff --git a/Makefile b/Makefile
index fa6a9c3d..7a9d628f 100644
--- a/Makefile
+++ b/Makefile
@@ -26,12 +26,12 @@ lint: ruff mypy
 
 
 ruff:
-	pip install -q -U ruff
+	-@ pip install -q -U ruff
 	ruff check --preview tatsu test examples
 
 
 mypy:
-	pip install -q -U mypy
+	-@ pip install -q -U mypy
 	mypy   --ignore-missing-imports . --exclude dist
 
 
diff --git a/examples/calc/calc.py b/examples/calc/calc.py
index 658fde8e..8feb4c94 100644
--- a/examples/calc/calc.py
+++ b/examples/calc/calc.py
@@ -1,4 +1,5 @@
 import json
+from pathlib import Path
 from pprint import pprint
 
 from codegen import PostfixCodeGenerator
@@ -9,7 +10,7 @@
 
 
 def simple_parse():
-    grammar = open('grammars/calc_cut.ebnf').read()
+    grammar = Path('grammars/calc_cut.ebnf').read_text()
 
     parser = tatsu.compile(grammar)
     ast = parser.parse('3 + 5 * ( 10 - 20 )', trace=False, colorize=True)
@@ -26,7 +27,7 @@ def simple_parse():
 
 
 def annotated_parse():
-    grammar = open('grammars/calc_annotated.ebnf').read()
+    grammar = Path('grammars/calc_annotated.ebnf').read_text()
 
     parser = tatsu.compile(grammar)
     ast = parser.parse('3 + 5 * ( 10 - 20 )')
@@ -63,7 +64,7 @@ def expression(self, ast):
 
 
 def parse_with_basic_semantics():
-    grammar = open('grammars/calc_annotated.ebnf').read()
+    grammar = Path('grammars/calc_annotated.ebnf').read_text()
 
     parser = tatsu.compile(grammar)
     result = parser.parse(
@@ -95,7 +96,7 @@ def division(self, ast):
 
 
 def parse_factored():
-    grammar = open('grammars/calc_factored.ebnf').read()
+    grammar = Path('grammars/calc_factored.ebnf').read_text()
 
     parser = tatsu.compile(grammar)
     ast = parser.parse('3 + 5 * ( 10 - 20 )', semantics=CalcSemantics())
@@ -107,7 +108,7 @@ def parse_factored():
 
 
 def parse_to_model():
-    grammar = open('grammars/calc_model.ebnf').read()
+    grammar = Path('grammars/calc_model.ebnf').read_text()
 
     parser = tatsu.compile(grammar, asmodel=True)
     model = parser.parse('3 + 5 * ( 10 - 20 )')
@@ -136,7 +137,7 @@ def walk__divide(self, node):
 
 
 def parse_and_walk_model():
-    grammar = open('grammars/calc_model.ebnf').read()
+    grammar = Path('grammars/calc_model.ebnf').read_text()
 
     parser = tatsu.compile(grammar, asmodel=True)
     model = parser.parse('3 + 5 * ( 10 - 20 )')
@@ -150,7 +151,7 @@ def parse_and_walk_model():
 
 
 def parse_and_translate():
-    grammar = open('grammars/calc_model.ebnf').read()
+    grammar = Path('grammars/calc_model.ebnf').read_text()
 
     parser = tatsu.compile(grammar, asmodel=True)
     model = parser.parse('3 + 5 * ( 10 - 20 )')
diff --git a/ruff.toml b/ruff.toml
index 995519d1..04687d63 100644
--- a/ruff.toml
+++ b/ruff.toml
@@ -1,30 +1,44 @@
 line-length = 88
 
 select = [
-    'F', 'E', 'W', 'UP',
-    'I', 'YTT', 'S', 'B',
-    'COM', 'C4', 'SIM',
-    'PTH', 'TRY',
-    'FLY', 'PERF', 'FURB', 'RUF',
-    'PL', 'PGH', 'RET',
-    # 'ERA', # commented out code
+    "F", "E", "W", "UP",
+    "I", "YTT", "S", "B",
+    "COM", "C4", "SIM",
+    "PTH", "TRY",
+    "FLY", "PERF", "FURB", "RUF",
+    "PL", "PGH", "RET",
+    # "ERA", # commented out code
 ]
 ignore = [
-    'E501', 'E741', 'E402',
-    'S101', 'S102', 'S105', 'S301', 'S311',
-    'C408',
-    'SIM115', 'SIM114',
-    'PTH123',
-    'TRY003', 'TRY300',
-    'PLW1514', 'PLR6301',
-    'PLC0415',
-    'PLR0913', 'PLR2004', 'PLR0904', 'PLR0915',
-    'PLW0603', 'PLW2901', 'PLW3201',
-    'RET505',
+#    "C408",  # unnecessary-collection-call
+    "E501",  # line-too-long
+    "E741",  # ambiguous-variable-name
+    "E402",  # module-import-not-at-top-of-file
+    "S101",  # use of assert
+    "PLC0415",  # import-outside-top-level
+    "PLR6301",  # no-self-use
+    "PLR0904",  # too-many-public-methods
+    "PLR0913",  # too-many-arguments
+    "PLR0915",  # too-many-statements
+    "PLR2004",  # magic-value-comparison
+    "PLW1514",  # unspecified-encoding
+#    "PLW0603",  # global-statement
+#    "PLW2901",  # redefined-loop-name
+    "PLW3201",  # bad-dunder-method-name
+#    "PTH123",  # builtin-open
+    "RET505",  # superfluous-else-return
+    "S102",  # exec-builtin
+#    "S105",  # hardcoded-password-string
+    "S301",  # suspicious-pickle-usage
+#    "S311",  # suspicious-non-cryptographic-random-usage
+    "SIM115",  # open-file-with-context-handler
+    "SIM114",  # if-with-same-arms
+    "TRY003",  # raise-vanilla-args
+    "TRY300",  # try-consider-else
 ]
-exclude = ['tatsu/bootstrap.py']
+exclude = []
 
-target-version = 'py312'
+target-version = "py312"
 
 [per-file-ignores]
 
@@ -33,4 +47,4 @@ target-version = 'py312'
 max-complexity = 10
 
 [pydocstyle]
-convention = 'numpy'
+convention = "numpy"
diff --git a/tatsu/ast.py b/tatsu/ast.py
index d3c550be..4adef9ab 100644
--- a/tatsu/ast.py
+++ b/tatsu/ast.py
@@ -107,13 +107,11 @@ def _safekey(self, key):
         return key
 
     def _define(self, keys, list_keys=None):
-        for key in keys:
-            key = self._safekey(key)
+        for key in (self._safekey(k) for k in keys):
             if key not in self:
                 super().__setitem__(key, None)
 
-        for key in list_keys or []:
-            key = self._safekey(key)
+        for key in (self._safekey(k) for k in list_keys or []):
             if key not in self:
                 super().__setitem__(key, [])
 
diff --git a/tatsu/bootstrap.py b/tatsu/bootstrap.py
index f71ee807..06a21f15 100644
--- a/tatsu/bootstrap.py
+++ b/tatsu/bootstrap.py
@@ -9,23 +9,24 @@
 # Any changes you make to it will be overwritten the next time
 # the file is generated.
 
+# ruff: noqa: I001, SIM117
+
 import sys
+from pathlib import Path
 
 from tatsu.buffering import Buffer
 from tatsu.parsing import Parser
 from tatsu.parsing import tatsumasu
-from tatsu.parsing import leftrec, nomemo, isname   # noqa
+from tatsu.parsing import leftrec, nomemo, isname  # noqa: F401
 from tatsu.infos import ParserConfig
-from tatsu.util import re, generic_main  # noqa
+from tatsu.util import re, generic_main  # noqa: F401
 
 
-KEYWORDS = {'None'}  # type: ignore
+KEYWORDS: set[str] = set()
 
 
 class EBNFBootstrapBuffer(Buffer):
-    def __init__(
-        self, text, /, config: ParserConfig | None = None, **settings
-    ):
+    def __init__(self, text, /, config: ParserConfig | None = None, **settings):
         config = ParserConfig.new(
             config,
             owner=self,
@@ -62,11 +63,11 @@ def __init__(self, /, config: ParserConfig | None = None, **settings):
         super().__init__(config=config)
 
     @tatsumasu()
-    def _start_(self):  # noqa
+    def _start_(self):
         self._grammar_()
 
     @tatsumasu('Grammar')
-    def _grammar_(self):  # noqa
+    def _grammar_(self):
         self._constant('TATSU')
         self.name_last_node('title')
 
@@ -78,8 +79,10 @@ def block1():
                 with self._option():
                     self._keyword_()
                     self.add_last_node_to_name('keywords')
-                self._error('expecting one of: ' '<directive> <keyword>')
-
+                self._error(
+                    'expecting one of: '
+                    '<directive> <keyword>'  # noqa: COM812
+                )
         self._closure(block1)
         self._rule_()
         self.add_last_node_to_name('rules')
@@ -92,15 +95,20 @@ def block6():
                 with self._option():
                     self._keyword_()
                     self.add_last_node_to_name('keywords')
-                self._error('expecting one of: ' '<keyword> <rule>')
-
+                self._error(
+                    'expecting one of: '
+                    '<keyword> <rule>'  # noqa: COM812
+                )
         self._closure(block6)
         self._check_eof()
 
-        self._define(['title'], ['directives', 'keywords', 'rules'])
+        self._define(
+            ['title'],
+            ['directives', 'keywords', 'rules'],
+        )
 
     @tatsumasu()
-    def _directive_(self):  # noqa
+    def _directive_(self):
         self._token('@@')
         with self._ifnot():
             self._token('keyword')
@@ -116,7 +124,7 @@ def _directive_(self):  # noqa
                                 self._token('eol_comments')
                             self._error(
                                 'expecting one of: '
-                                "'comments' 'eol_comments'"
+                                "'comments' 'eol_comments'"  # noqa: COM812
                             )
                     self.name_last_node('name')
                     self._cut()
@@ -126,7 +134,10 @@ def _directive_(self):  # noqa
                     self._regex_()
                     self.name_last_node('value')
 
-                    self._define(['name', 'value'], [])
+                    self._define(
+                        ['name', 'value'],
+                        [],
+                    )
                 with self._option():
                     with self._group():
                         self._token('whitespace')
@@ -146,11 +157,15 @@ def _directive_(self):  # noqa
                             with self._option():
                                 self._constant('None')
                             self._error(
-                                'expecting one of: ' "'False' 'None' <regex>"
+                                'expecting one of: '
+                                "'False' 'None' <regex>"  # noqa: COM812
                             )
                     self.name_last_node('value')
 
-                    self._define(['name', 'value'], [])
+                    self._define(
+                        ['name', 'value'],
+                        [],
+                    )
                 with self._option():
                     with self._group():
                         with self._choice():
@@ -165,7 +180,7 @@ def _directive_(self):  # noqa
                             self._error(
                                 'expecting one of: '
                                 "'ignorecase' 'left_recursion'"
-                                "'nameguard' 'parseinfo'"
+                                "'nameguard' 'parseinfo'"  # noqa: COM812
                             )
                     self.name_last_node('name')
                     self._cut()
@@ -177,13 +192,22 @@ def _directive_(self):  # noqa
                                 self._boolean_()
                                 self.name_last_node('value')
 
-                                self._define(['value'], [])
+                                self._define(
+                                    ['value'],
+                                    [],
+                                )
                             with self._option():
                                 self._constant(True)
                                 self.name_last_node('value')
-                            self._error('expecting one of: ' "'::'")
+                            self._error(
+                                'expecting one of: '
+                                "'::'"  # noqa: COM812
+                            )
 
-                    self._define(['name', 'value'], [])
+                    self._define(
+                        ['name', 'value'],
+                        [],
+                    )
                 with self._option():
                     with self._group():
                         self._token('grammar')
@@ -194,7 +218,10 @@ def _directive_(self):  # noqa
                     self._word_()
                     self.name_last_node('value')
 
-                    self._define(['name', 'value'], [])
+                    self._define(
+                        ['name', 'value'],
+                        [],
+                    )
                 with self._option():
                     with self._group():
                         self._token('namechars')
@@ -205,27 +232,33 @@ def _directive_(self):  # noqa
                     self._string_()
                     self.name_last_node('value')
 
-                    self._define(['name', 'value'], [])
+                    self._define(
+                        ['name', 'value'],
+                        [],
+                    )
                 self._error(
                     'expecting one of: '
                     "'comments' 'eol_comments' 'grammar'"
                     "'ignorecase' 'left_recursion'"
                     "'namechars' 'nameguard' 'parseinfo'"
-                    "'whitespace'"
+                    "'whitespace'"  # noqa: COM812
                 )
         self._cut()
 
-        self._define(['name', 'value'], [])
+        self._define(
+            ['name', 'value'],
+            [],
+        )
 
     @tatsumasu()
-    def _keywords_(self):  # noqa
+    def _keywords_(self):
+
         def block0():
             self._keywords_()
-
         self._positive_closure(block0)
 
     @tatsumasu()
-    def _keyword_(self):  # noqa
+    def _keyword_(self):
         self._token('@@keyword')
         self._cut()
         self._token('::')
@@ -241,12 +274,14 @@ def block0():
                             self._token(':')
                         with self._option():
                             self._token('=')
-                        self._error('expecting one of: ' "':' '='")
-
+                        self._error(
+                            'expecting one of: '
+                            "':' '='"  # noqa: COM812
+                        )
         self._closure(block0)
 
     @tatsumasu()
-    def _paramdef_(self):  # noqa
+    def _paramdef_(self):
         with self._choice():
             with self._option():
                 self._token('::')
@@ -254,7 +289,10 @@ def _paramdef_(self):  # noqa
                 self._params_()
                 self.name_last_node('params')
 
-                self._define(['params'], [])
+                self._define(
+                    ['params'],
+                    [],
+                )
             with self._option():
                 self._token('(')
                 self._cut()
@@ -271,21 +309,33 @@ def _paramdef_(self):  # noqa
                             self._kwparams_()
                             self.name_last_node('kwparams')
 
-                            self._define(['kwparams', 'params'], [])
+                            self._define(
+                                ['kwparams', 'params'],
+                                [],
+                            )
                         with self._option():
                             self._params_()
                             self.name_last_node('params')
-                        self._error('expecting one of: ' '<kwparams> <params>')
+                        self._error(
+                            'expecting one of: '
+                            '<kwparams> <params>'  # noqa: COM812
+                        )
                 self._token(')')
 
-                self._define(['kwparams', 'params'], [])
-            self._error('expecting one of: ' "'(' '::'")
+                self._define(
+                    ['kwparams', 'params'],
+                    [],
+                )
+            self._error(
+                'expecting one of: '
+                "'(' '::'"  # noqa: COM812
+            )
 
     @tatsumasu('Rule')
-    def _rule_(self):  # noqa
+    def _rule_(self):
+
         def block1():
             self._decorator_()
-
         self._closure(block1)
         self.name_last_node('decorators')
         self._name_()
@@ -299,7 +349,10 @@ def block1():
                     self._params_()
                     self.name_last_node('params')
 
-                    self._define(['params'], [])
+                    self._define(
+                        ['params'],
+                        [],
+                    )
                 with self._option():
                     self._token('(')
                     self._cut()
@@ -316,24 +369,37 @@ def block1():
                                 self._kwparams_()
                                 self.name_last_node('kwparams')
 
-                                self._define(['kwparams', 'params'], [])
+                                self._define(
+                                    ['kwparams', 'params'],
+                                    [],
+                                )
                             with self._option():
                                 self._params_()
                                 self.name_last_node('params')
                             self._error(
-                                'expecting one of: ' '<kwparams> <params>'
+                                'expecting one of: '
+                                '<kwparams> <params>'  # noqa: COM812
                             )
                     self._token(')')
 
-                    self._define(['kwparams', 'params'], [])
-                self._error('expecting one of: ' "'(' '::'")
+                    self._define(
+                        ['kwparams', 'params'],
+                        [],
+                    )
+                self._error(
+                    'expecting one of: '
+                    "'(' '::'"  # noqa: COM812
+                )
         with self._optional():
             self._token('<')
             self._cut()
             self._known_name_()
             self.name_last_node('base')
 
-            self._define(['base'], [])
+            self._define(
+                ['base'],
+                [],
+            )
         self._token('=')
         self._cut()
         self._expre_()
@@ -342,11 +408,12 @@ def block1():
         self._cut()
 
         self._define(
-            ['base', 'decorators', 'exp', 'kwparams', 'name', 'params'], []
+            ['base', 'decorators', 'exp', 'kwparams', 'name', 'params'],
+            [],
         )
 
     @tatsumasu()
-    def _decorator_(self):  # noqa
+    def _decorator_(self):
         self._token('@')
         with self._ifnot():
             self._token('@')
@@ -359,11 +426,14 @@ def _decorator_(self):  # noqa
                     self._token('name')
                 with self._option():
                     self._token('nomemo')
-                self._error('expecting one of: ' "'name' 'nomemo' 'override'")
+                self._error(
+                    'expecting one of: '
+                    "'name' 'nomemo' 'override'"  # noqa: COM812
+                )
         self.name_last_node('@')
 
     @tatsumasu()
-    def _params_(self):  # noqa
+    def _params_(self):
         self._first_param_()
         self.add_last_node_to_name('@')
 
@@ -374,11 +444,10 @@ def block1():
             with self._ifnot():
                 self._token('=')
             self._cut()
-
         self._closure(block1)
 
     @tatsumasu()
-    def _first_param_(self):  # noqa
+    def _first_param_(self):
         with self._choice():
             with self._option():
                 self._path_()
@@ -388,21 +457,21 @@ def _first_param_(self):  # noqa
                 'expecting one of: '
                 '(?!\\d)\\w+(?:::(?!\\d)\\w+)+ <boolean>'
                 '<float> <hex> <int> <literal> <null>'
-                '<path> <raw_string> <string> <word>'
+                '<path> <raw_string> <string> <word>'  # noqa: COM812
             )
 
     @tatsumasu()
-    def _kwparams_(self):  # noqa
+    def _kwparams_(self):
+
         def sep0():
             self._token(',')
 
         def block0():
             self._pair_()
-
         self._positive_gather(block0, sep0)
 
     @tatsumasu()
-    def _pair_(self):  # noqa
+    def _pair_(self):
         self._word_()
         self.add_last_node_to_name('@')
         self._token('=')
@@ -411,7 +480,7 @@ def _pair_(self):  # noqa
         self.add_last_node_to_name('@')
 
     @tatsumasu()
-    def _expre_(self):  # noqa
+    def _expre_(self):
         with self._choice():
             with self._option():
                 self._choice_()
@@ -420,11 +489,11 @@ def _expre_(self):  # noqa
             self._error(
                 'expecting one of: '
                 "'|' <choice> <element> <option>"
-                '<sequence>'
+                '<sequence>'  # noqa: COM812
             )
 
     @tatsumasu('Choice')
-    def _choice_(self):  # noqa
+    def _choice_(self):
         with self._optional():
             self._token('|')
             self._cut()
@@ -436,24 +505,23 @@ def block1():
             self._cut()
             self._option_()
             self.add_last_node_to_name('@')
-
         self._positive_closure(block1)
 
     @tatsumasu('Option')
-    def _option_(self):  # noqa
+    def _option_(self):
         self._sequence_()
         self.name_last_node('@')
 
     @tatsumasu('Sequence')
-    def _sequence_(self):  # noqa
+    def _sequence_(self):
+
         def block1():
             self._element_()
-
         self._positive_closure(block1)
         self.name_last_node('sequence')
 
     @tatsumasu()
-    def _element_(self):  # noqa
+    def _element_(self):
         with self._choice():
             with self._option():
                 self._rule_include_()
@@ -474,29 +542,30 @@ def _element_(self):  # noqa
                 '<override_single_deprecated>'
                 '<positive_closure> <right_join>'
                 '<rule_include> <skip_to> <special>'
-                '<term> <void>'
+                '<term> <void>'  # noqa: COM812
             )
 
     @tatsumasu('RuleInclude')
-    def _rule_include_(self):  # noqa
+    def _rule_include_(self):
         self._token('>')
         self._cut()
         self._known_name_()
         self.name_last_node('@')
 
     @tatsumasu()
-    def _named_(self):  # noqa
+    def _named_(self):
         with self._choice():
             with self._option():
                 self._named_list_()
             with self._option():
                 self._named_single_()
             self._error(
-                'expecting one of: ' '<name> <named_list> <named_single>'
+                'expecting one of: '
+                '<name> <named_list> <named_single>'  # noqa: COM812
             )
 
     @tatsumasu('NamedList')
-    def _named_list_(self):  # noqa
+    def _named_list_(self):
         self._name_()
         self.name_last_node('name')
         self._token('+:')
@@ -504,10 +573,13 @@ def _named_list_(self):  # noqa
         self._term_()
         self.name_last_node('exp')
 
-        self._define(['exp', 'name'], [])
+        self._define(
+            ['exp', 'name'],
+            [],
+        )
 
     @tatsumasu('Named')
-    def _named_single_(self):  # noqa
+    def _named_single_(self):
         self._name_()
         self.name_last_node('name')
         self._token(':')
@@ -515,10 +587,13 @@ def _named_single_(self):  # noqa
         self._term_()
         self.name_last_node('exp')
 
-        self._define(['exp', 'name'], [])
+        self._define(
+            ['exp', 'name'],
+            [],
+        )
 
     @tatsumasu()
-    def _override_(self):  # noqa
+    def _override_(self):
         with self._choice():
             with self._option():
                 self._override_list_()
@@ -530,32 +605,32 @@ def _override_(self):  # noqa
                 'expecting one of: '
                 "'@' '@+:' '@:' <override_list>"
                 '<override_single>'
-                '<override_single_deprecated>'
+                '<override_single_deprecated>'  # noqa: COM812
             )
 
     @tatsumasu('OverrideList')
-    def _override_list_(self):  # noqa
+    def _override_list_(self):
         self._token('@+:')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu('Override')
-    def _override_single_(self):  # noqa
+    def _override_single_(self):
         self._token('@:')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu('Override')
-    def _override_single_deprecated_(self):  # noqa
+    def _override_single_deprecated_(self):
         self._token('@')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu()
-    def _term_(self):  # noqa
+    def _term_(self):
         with self._choice():
             with self._option():
                 self._void_()
@@ -597,11 +672,11 @@ def _term_(self):  # noqa
                 '<negative_lookahead> <optional>'
                 '<pattern> <positive_closure>'
                 '<right_join> <separator> <skip_to>'
-                '<special> <token> <void>'
+                '<special> <token> <void>'  # noqa: COM812
             )
 
     @tatsumasu('Group')
-    def _group_(self):  # noqa
+    def _group_(self):
         self._token('(')
         self._cut()
         self._expre_()
@@ -609,10 +684,13 @@ def _group_(self):  # noqa
         self._token(')')
         self._cut()
 
-        self._define(['exp'], [])
+        self._define(
+            ['exp'],
+            [],
+        )
 
     @tatsumasu()
-    def _gather_(self):  # noqa
+    def _gather_(self):
         with self._if():
             with self._group():
                 self._separator_()
@@ -625,11 +703,12 @@ def _gather_(self):  # noqa
                 with self._option():
                     self._normal_gather_()
                 self._error(
-                    'expecting one of: ' '<normal_gather> <positive_gather>'
+                    'expecting one of: '
+                    '<normal_gather> <positive_gather>'  # noqa: COM812
                 )
 
     @tatsumasu('PositiveGather')
-    def _positive_gather_(self):  # noqa
+    def _positive_gather_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('.{')
@@ -642,13 +721,19 @@ def _positive_gather_(self):  # noqa
                     self._token('+')
                 with self._option():
                     self._token('-')
-                self._error('expecting one of: ' "'+' '-'")
+                self._error(
+                    'expecting one of: '
+                    "'+' '-'"  # noqa: COM812
+                )
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu('Gather')
-    def _normal_gather_(self):  # noqa
+    def _normal_gather_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('.{')
@@ -661,10 +746,13 @@ def _normal_gather_(self):  # noqa
             self._cut()
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu()
-    def _join_(self):  # noqa
+    def _join_(self):
         with self._if():
             with self._group():
                 self._separator_()
@@ -677,11 +765,12 @@ def _join_(self):  # noqa
                 with self._option():
                     self._normal_join_()
                 self._error(
-                    'expecting one of: ' '<normal_join> <positive_join>'
+                    'expecting one of: '
+                    '<normal_join> <positive_join>'  # noqa: COM812
                 )
 
     @tatsumasu('PositiveJoin')
-    def _positive_join_(self):  # noqa
+    def _positive_join_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('%{')
@@ -694,13 +783,19 @@ def _positive_join_(self):  # noqa
                     self._token('+')
                 with self._option():
                     self._token('-')
-                self._error('expecting one of: ' "'+' '-'")
+                self._error(
+                    'expecting one of: '
+                    "'+' '-'"  # noqa: COM812
+                )
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu('Join')
-    def _normal_join_(self):  # noqa
+    def _normal_join_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('%{')
@@ -713,10 +808,13 @@ def _normal_join_(self):  # noqa
             self._cut()
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu('LeftJoin')
-    def _left_join_(self):  # noqa
+    def _left_join_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('<{')
@@ -730,13 +828,19 @@ def _left_join_(self):  # noqa
                     self._token('+')
                 with self._option():
                     self._token('-')
-                self._error('expecting one of: ' "'+' '-'")
+                self._error(
+                    'expecting one of: '
+                    "'+' '-'"  # noqa: COM812
+                )
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu('RightJoin')
-    def _right_join_(self):  # noqa
+    def _right_join_(self):
         self._separator_()
         self.name_last_node('sep')
         self._token('>{')
@@ -750,13 +854,19 @@ def _right_join_(self):  # noqa
                     self._token('+')
                 with self._option():
                     self._token('-')
-                self._error('expecting one of: ' "'+' '-'")
+                self._error(
+                    'expecting one of: '
+                    "'+' '-'"  # noqa: COM812
+                )
         self._cut()
 
-        self._define(['exp', 'sep'], [])
+        self._define(
+            ['exp', 'sep'],
+            [],
+        )
 
     @tatsumasu()
-    def _separator_(self):  # noqa
+    def _separator_(self):
         with self._choice():
             with self._option():
                 self._group_()
@@ -772,11 +882,11 @@ def _separator_(self):  # noqa
                 'expecting one of: '
                 "'(' '/./' '`' <any> <constant> <group>"
                 '<pattern> <raw_string> <regexes>'
-                '<string> <token>'
+                '<string> <token>'  # noqa: COM812
             )
 
     @tatsumasu('PositiveClosure')
-    def _positive_closure_(self):  # noqa
+    def _positive_closure_(self):
         self._token('{')
         self._expre_()
         self.name_last_node('@')
@@ -787,11 +897,14 @@ def _positive_closure_(self):  # noqa
                     self._token('-')
                 with self._option():
                     self._token('+')
-                self._error('expecting one of: ' "'+' '-'")
+                self._error(
+                    'expecting one of: '
+                    "'+' '-'"  # noqa: COM812
+                )
         self._cut()
 
     @tatsumasu('Closure')
-    def _closure_(self):  # noqa
+    def _closure_(self):
         self._token('{')
         self._expre_()
         self.name_last_node('@')
@@ -801,14 +914,14 @@ def _closure_(self):  # noqa
         self._cut()
 
     @tatsumasu('EmptyClosure')
-    def _empty_closure_(self):  # noqa
+    def _empty_closure_(self):
         self._token('{')
         self._void()
         self.name_last_node('@')
         self._token('}')
 
     @tatsumasu('Optional')
-    def _optional_(self):  # noqa
+    def _optional_(self):
         self._token('[')
         self._cut()
         self._expre_()
@@ -817,7 +930,7 @@ def _optional_(self):  # noqa
         self._cut()
 
     @tatsumasu('Special')
-    def _special_(self):  # noqa
+    def _special_(self):
         self._token('?(')
         self._cut()
         self._pattern('.*?(?!\\)\\?)')
@@ -826,28 +939,28 @@ def _special_(self):  # noqa
         self._cut()
 
     @tatsumasu('Lookahead')
-    def _lookahead_(self):  # noqa
+    def _lookahead_(self):
         self._token('&')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu('NegativeLookahead')
-    def _negative_lookahead_(self):  # noqa
+    def _negative_lookahead_(self):
         self._token('!')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu('SkipTo')
-    def _skip_to_(self):  # noqa
+    def _skip_to_(self):
         self._token('->')
         self._cut()
         self._term_()
         self.name_last_node('@')
 
     @tatsumasu()
-    def _atom_(self):  # noqa
+    def _atom_(self):
         with self._choice():
             with self._option():
                 self._cut_()
@@ -870,39 +983,39 @@ def _atom_(self):  # noqa
                 "'$' '>>' '`' '~' <alert> <call>"
                 '<constant> <cut> <cut_deprecated> <eof>'
                 '<pattern> <raw_string> <regexes>'
-                '<string> <token> <word> \\^+'
+                '<string> <token> <word> \\^+'  # noqa: COM812
             )
 
     @tatsumasu('RuleRef')
-    def _call_(self):  # noqa
+    def _call_(self):
         self._word_()
 
     @tatsumasu('Void')
-    def _void_(self):  # noqa
+    def _void_(self):
         self._token('()')
         self._cut()
 
     @tatsumasu('Cut')
-    def _cut_(self):  # noqa
+    def _cut_(self):
         self._token('~')
         self._cut()
 
     @tatsumasu('Cut')
-    def _cut_deprecated_(self):  # noqa
+    def _cut_deprecated_(self):
         self._token('>>')
         self._cut()
 
     @tatsumasu()
-    def _known_name_(self):  # noqa
+    def _known_name_(self):
         self._name_()
         self._cut()
 
     @tatsumasu()
-    def _name_(self):  # noqa
+    def _name_(self):
         self._word_()
 
     @tatsumasu('Constant')
-    def _constant_(self):  # noqa
+    def _constant_(self):
         with self._if():
             self._token('`')
         with self._group():
@@ -917,31 +1030,36 @@ def _constant_(self):  # noqa
                 with self._option():
                     self._pattern('`(.*?)`')
                 self._error(
-                    'expecting one of: ' "'`' (?ms)```((?:.|\\n)*?)``` `(.*?)`"
+                    'expecting one of: '
+                    "'`' (?ms)```((?:.|\\n)*?)``` `(.*?)`"  # noqa: COM812
                 )
 
     @tatsumasu('Alert')
-    def _alert_(self):  # noqa
+    def _alert_(self):
         self._pattern('\\^+')
         self.name_last_node('level')
         self._constant_()
         self.name_last_node('message')
 
-        self._define(['level', 'message'], [])
+        self._define(
+            ['level', 'message'],
+            [],
+        )
 
     @tatsumasu('Token')
-    def _token_(self):  # noqa
+    def _token_(self):
         with self._choice():
             with self._option():
                 self._string_()
             with self._option():
                 self._raw_string_()
             self._error(
-                'expecting one of: ' '<STRING> <raw_string> <string> r'
+                'expecting one of: '
+                '<STRING> <raw_string> <string> r'  # noqa: COM812
             )
 
     @tatsumasu()
-    def _literal_(self):  # noqa
+    def _literal_(self):
         with self._choice():
             with self._option():
                 self._string_()
@@ -966,21 +1084,21 @@ def _literal_(self):  # noqa
                 '<float> <hex> <int> <null> <raw_string>'
                 '<string> <word> [-'
                 '+]?(?:\\d+\\.\\d*|\\d*\\.\\d+)(?:[Ee][-'
-                '+]?\\d+)? [-+]?\\d+ r'
+                '+]?\\d+)? [-+]?\\d+ r'  # noqa: COM812
             )
 
     @tatsumasu()
-    def _string_(self):  # noqa
+    def _string_(self):
         self._STRING_()
 
     @tatsumasu()
-    def _raw_string_(self):  # noqa
+    def _raw_string_(self):
         self._pattern('r')
         self._STRING_()
         self.name_last_node('@')
 
     @tatsumasu()
-    def _STRING_(self):  # noqa
+    def _STRING_(self):
         with self._choice():
             with self._option():
                 self._pattern('"((?:[^"\\n]|\\\\"|\\\\\\\\)*?)"')
@@ -993,49 +1111,49 @@ def _STRING_(self):  # noqa
             self._error(
                 'expecting one of: '
                 '"((?:[^"\\n]|\\"|\\\\)*?)"'
-                "'((?:[^'\\n]|\\'|\\\\)*?)'"
+                "'((?:[^'\\n]|\\'|\\\\)*?)'"  # noqa: COM812
             )
 
     @tatsumasu()
-    def _hex_(self):  # noqa
+    def _hex_(self):
         self._pattern('0[xX](?:\\d|[a-fA-F])+')
 
     @tatsumasu()
-    def _float_(self):  # noqa
+    def _float_(self):
         self._pattern('[-+]?(?:\\d+\\.\\d*|\\d*\\.\\d+)(?:[Ee][-+]?\\d+)?')
 
     @tatsumasu()
-    def _int_(self):  # noqa
+    def _int_(self):
         self._pattern('[-+]?\\d+')
 
     @tatsumasu()
-    def _path_(self):  # noqa
+    def _path_(self):
         self._pattern('(?!\\d)\\w+(?:::(?!\\d)\\w+)+')
 
     @tatsumasu()
-    def _word_(self):  # noqa
+    def _word_(self):
         self._pattern('(?!\\d)\\w+')
 
     @tatsumasu('Any')
-    def _any_(self):  # noqa
+    def _any_(self):
         self._token('/./')
 
     @tatsumasu('Pattern')
-    def _pattern_(self):  # noqa
+    def _pattern_(self):
         self._regexes_()
 
     @tatsumasu()
-    def _regexes_(self):  # noqa
+    def _regexes_(self):
+
         def sep0():
             self._token('+')
 
         def block0():
             self._regex_()
-
         self._positive_gather(block0, sep0)
 
     @tatsumasu()
-    def _regex_(self):  # noqa
+    def _regex_(self):
         with self._choice():
             with self._option():
                 self._token('/')
@@ -1055,236 +1173,242 @@ def _regex_(self):  # noqa
                 self._token('?')
                 self._STRING_()
                 self.name_last_node('@')
-            self._error('expecting one of: ' "'/' '?' '?/'")
+            self._error(
+                'expecting one of: '
+                "'/' '?' '?/'"  # noqa: COM812
+            )
 
     @tatsumasu()
-    def _boolean_(self):  # noqa
+    def _boolean_(self):
         with self._choice():
             with self._option():
                 self._token('True')
             with self._option():
                 self._token('False')
-            self._error('expecting one of: ' "'False' 'True'")
+            self._error(
+                'expecting one of: '
+                "'False' 'True'"  # noqa: COM812
+            )
 
     @tatsumasu()
-    def _null_(self):  # noqa
+    def _null_(self):
         self._token('None')
 
     @tatsumasu('EOF')
-    def _eof_(self):  # noqa
+    def _eof_(self):
         self._token('$')
         self._cut()
 
 
 class EBNFBootstrapSemantics:
-    def start(self, ast):  # noqa
+    def start(self, ast):
         return ast
 
-    def grammar(self, ast):  # noqa
+    def grammar(self, ast):
         return ast
 
-    def directive(self, ast):  # noqa
+    def directive(self, ast):
         return ast
 
-    def keywords(self, ast):  # noqa
+    def keywords(self, ast):
         return ast
 
-    def keyword(self, ast):  # noqa
+    def keyword(self, ast):
         return ast
 
-    def paramdef(self, ast):  # noqa
+    def paramdef(self, ast):
         return ast
 
-    def rule(self, ast):  # noqa
+    def rule(self, ast):
         return ast
 
-    def decorator(self, ast):  # noqa
+    def decorator(self, ast):
         return ast
 
-    def params(self, ast):  # noqa
+    def params(self, ast):
         return ast
 
-    def first_param(self, ast):  # noqa
+    def first_param(self, ast):
         return ast
 
-    def kwparams(self, ast):  # noqa
+    def kwparams(self, ast):
         return ast
 
-    def pair(self, ast):  # noqa
+    def pair(self, ast):
         return ast
 
-    def expre(self, ast):  # noqa
+    def expre(self, ast):
         return ast
 
-    def choice(self, ast):  # noqa
+    def choice(self, ast):
         return ast
 
-    def option(self, ast):  # noqa
+    def option(self, ast):
         return ast
 
-    def sequence(self, ast):  # noqa
+    def sequence(self, ast):
         return ast
 
-    def element(self, ast):  # noqa
+    def element(self, ast):
         return ast
 
-    def rule_include(self, ast):  # noqa
+    def rule_include(self, ast):
         return ast
 
-    def named(self, ast):  # noqa
+    def named(self, ast):
         return ast
 
-    def named_list(self, ast):  # noqa
+    def named_list(self, ast):
         return ast
 
-    def named_single(self, ast):  # noqa
+    def named_single(self, ast):
         return ast
 
-    def override(self, ast):  # noqa
+    def override(self, ast):
         return ast
 
-    def override_list(self, ast):  # noqa
+    def override_list(self, ast):
         return ast
 
-    def override_single(self, ast):  # noqa
+    def override_single(self, ast):
         return ast
 
-    def override_single_deprecated(self, ast):  # noqa
+    def override_single_deprecated(self, ast):
         return ast
 
-    def term(self, ast):  # noqa
+    def term(self, ast):
         return ast
 
-    def group(self, ast):  # noqa
+    def group(self, ast):
         return ast
 
-    def gather(self, ast):  # noqa
+    def gather(self, ast):
         return ast
 
-    def positive_gather(self, ast):  # noqa
+    def positive_gather(self, ast):
         return ast
 
-    def normal_gather(self, ast):  # noqa
+    def normal_gather(self, ast):
         return ast
 
-    def join(self, ast):  # noqa
+    def join(self, ast):
         return ast
 
-    def positive_join(self, ast):  # noqa
+    def positive_join(self, ast):
         return ast
 
-    def normal_join(self, ast):  # noqa
+    def normal_join(self, ast):
         return ast
 
-    def left_join(self, ast):  # noqa
+    def left_join(self, ast):
         return ast
 
-    def right_join(self, ast):  # noqa
+    def right_join(self, ast):
         return ast
 
-    def separator(self, ast):  # noqa
+    def separator(self, ast):
         return ast
 
-    def positive_closure(self, ast):  # noqa
+    def positive_closure(self, ast):
         return ast
 
-    def closure(self, ast):  # noqa
+    def closure(self, ast):
         return ast
 
-    def empty_closure(self, ast):  # noqa
+    def empty_closure(self, ast):
         return ast
 
-    def optional(self, ast):  # noqa
+    def optional(self, ast):
         return ast
 
-    def special(self, ast):  # noqa
+    def special(self, ast):
         return ast
 
-    def lookahead(self, ast):  # noqa
+    def lookahead(self, ast):
         return ast
 
-    def negative_lookahead(self, ast):  # noqa
+    def negative_lookahead(self, ast):
         return ast
 
-    def skip_to(self, ast):  # noqa
+    def skip_to(self, ast):
         return ast
 
-    def atom(self, ast):  # noqa
+    def atom(self, ast):
         return ast
 
-    def call(self, ast):  # noqa
+    def call(self, ast):
         return ast
 
-    def void(self, ast):  # noqa
+    def void(self, ast):
         return ast
 
-    def cut(self, ast):  # noqa
+    def cut(self, ast):
         return ast
 
-    def cut_deprecated(self, ast):  # noqa
+    def cut_deprecated(self, ast):
         return ast
 
-    def known_name(self, ast):  # noqa
+    def known_name(self, ast):
         return ast
 
-    def name(self, ast):  # noqa
+    def name(self, ast):
         return ast
 
-    def constant(self, ast):  # noqa
+    def constant(self, ast):
         return ast
 
-    def alert(self, ast):  # noqa
+    def alert(self, ast):
         return ast
 
-    def token(self, ast):  # noqa
+    def token(self, ast):
         return ast
 
-    def literal(self, ast):  # noqa
+    def literal(self, ast):
         return ast
 
-    def string(self, ast):  # noqa
+    def string(self, ast):
         return ast
 
-    def raw_string(self, ast):  # noqa
+    def raw_string(self, ast):
         return ast
 
-    def STRING(self, ast):  # noqa
+    def STRING(self, ast):
         return ast
 
-    def hex(self, ast):  # noqa
+    def hex(self, ast):
         return ast
 
-    def float(self, ast):  # noqa
+    def float(self, ast):
         return ast
 
-    def int(self, ast):  # noqa
+    def int(self, ast):
         return ast
 
-    def path(self, ast):  # noqa
+    def path(self, ast):
         return ast
 
-    def word(self, ast):  # noqa
+    def word(self, ast):
         return ast
 
-    def any(self, ast):  # noqa
+    def any(self, ast):
         return ast
 
-    def pattern(self, ast):  # noqa
+    def pattern(self, ast):
         return ast
 
-    def regexes(self, ast):  # noqa
+    def regexes(self, ast):
         return ast
 
-    def regex(self, ast):  # noqa
+    def regex(self, ast):
         return ast
 
-    def boolean(self, ast):  # noqa
+    def boolean(self, ast):
         return ast
 
-    def null(self, ast):  # noqa
+    def null(self, ast):
         return ast
 
-    def eof(self, ast):  # noqa
+    def eof(self, ast):
         return ast
 
 
@@ -1292,10 +1416,13 @@ def main(filename, **kwargs):
     if not filename or filename == '-':
         text = sys.stdin.read()
     else:
-        with open(filename) as f:
-            text = f.read()
+        text = Path(filename).read_text()
     parser = EBNFBootstrapParser()
-    return parser.parse(text, filename=filename, **kwargs)
+    return parser.parse(
+        text,
+        filename=filename,
+        **kwargs,
+    )
 
 
 if __name__ == '__main__':
diff --git a/tatsu/codegen/objectmodel.py b/tatsu/codegen/objectmodel.py
index b05dd846..406fbd6c 100644
--- a/tatsu/codegen/objectmodel.py
+++ b/tatsu/codegen/objectmodel.py
@@ -189,6 +189,7 @@ def render_fields(self, fields):
         base_type = fields['base_type']
 
         fields.update(
+            name=self.node.name,
             base_class_declarations=base_class_declarations,
             model_class_declarations=model_class_declarations,
             version=version,
diff --git a/tatsu/codegen/python.py b/tatsu/codegen/python.py
index 2d9a70df..2414e756 100755
--- a/tatsu/codegen/python.py
+++ b/tatsu/codegen/python.py
@@ -55,7 +55,7 @@ def make_defines_declaration(self):
     define_template = """\
             self._define(
                 %s,
-                %s
+                %s,
             )\
         """
 
@@ -179,7 +179,7 @@ def render(self, **fields):
                 with self._choice():
                 {options:1::}
                     self._error(
-                {error:2:\\n:}
+                {error:2:\\n:}  # noqa: COM812
                     )\
                 """
 
@@ -415,7 +415,7 @@ def render_fields(self, fields):
         {leftrec}\
         {nomemo}\
         {isname}
-        def _{name}_(self):  # noqa
+        def _{name}_(self):
         {exp:1::}
         """
 
@@ -471,10 +471,10 @@ def render_fields(self, fields):
 
         version = str(tuple(int(n) for n in str(timestamp()).split('.')))
 
-        keywords = [str(k) for k in self.keywords]
+        keywords = [str(k) for k in self.keywords if k is not None]
         keywords = '\n'.join('    %s,' % repr(k) for k in keywords)
         if keywords:
-            keywords = '\n%s\n' % keywords
+            keywords = '(\n%s\n)' % keywords
 
         fields.update(
             rules=indent(rules),
@@ -493,7 +493,7 @@ def render_fields(self, fields):
         )
 
     abstract_rule_template = """
-            def {name}(self, ast):  # noqa
+            def {name}(self, ast):
                 return ast
             """
 
@@ -509,17 +509,20 @@ def {name}(self, ast):  # noqa
                 # Any changes you make to it will be overwritten the next time
                 # the file is generated.
 
+                # ruff: noqa: I001, SIM117
+
                 import sys
+                from pathlib import Path
 
                 from tatsu.buffering import Buffer
                 from tatsu.parsing import Parser
                 from tatsu.parsing import tatsumasu
-                from tatsu.parsing import leftrec, nomemo, isname # noqa
+                from tatsu.parsing import leftrec, nomemo, isname  # noqa: F401
                 from tatsu.infos import ParserConfig
-                from tatsu.util import re, generic_main  # noqa
+                from tatsu.util import re, generic_main  # noqa: F401
 
 
-                KEYWORDS = {{{keywords}}}  # type: ignore
+                KEYWORDS: set[str] = set({keywords})
 
 
                 class {name}Buffer(Buffer):
@@ -570,13 +573,12 @@ def main(filename, **kwargs):
                     if not filename or filename == '-':
                         text = sys.stdin.read()
                     else:
-                        with open(filename) as f:
-                            text = f.read()
+                        text = Path(filename).read_text()
                     parser = {name}Parser()
                     return parser.parse(
                         text,
                         filename=filename,
-                        **kwargs
+                        **kwargs,
                     )
 
 
diff --git a/tatsu/color.py b/tatsu/color.py
index 63fcda32..117ec581 100644
--- a/tatsu/color.py
+++ b/tatsu/color.py
@@ -1,3 +1,4 @@
+# ruff: noqa: PLW0603
 from __future__ import annotations
 
 
diff --git a/tatsu/grammars.py b/tatsu/grammars.py
index fba4a991..7c430df4 100644
--- a/tatsu/grammars.py
+++ b/tatsu/grammars.py
@@ -357,8 +357,8 @@ def _to_str(self, lean=False):
         parts = []
         for pat in (str(p) for p in self.patterns):
             if '/' in pat:
-                pat = pat.replace('"', r'\"')
-                regex = f'?"{pat}"'
+                newpat = pat.replace('"', r'\"')
+                regex = f'?"{newpat}"'
             else:
                 regex = f'/{pat}/'
             parts.append(regex)
@@ -1074,7 +1074,7 @@ def _to_str(self, lean=False):
 
         directives = ''
         for directive, value in self.directives.items():
-            fmt = dict(
+            fmt = dict(  # noqa: C408
                 name=directive,
                 frame='/' if directive in regex_directives else '',
                 value=(
diff --git a/tatsu/leftrec.py b/tatsu/leftrec.py
index 9e531a64..73860682 100644
--- a/tatsu/leftrec.py
+++ b/tatsu/leftrec.py
@@ -1,3 +1,4 @@
+# ruff: noqa: PLW2901
 from __future__ import annotations
 
 from collections import defaultdict
diff --git a/tatsu/objectmodel.py b/tatsu/objectmodel.py
index d5d791b8..8c1e65c4 100644
--- a/tatsu/objectmodel.py
+++ b/tatsu/objectmodel.py
@@ -9,7 +9,7 @@
 from .infos import CommentInfo, ParseInfo
 from .util import AsJSONMixin, asjson, asjsons
 
-BASE_CLASS_TOKEN = '::'
+BASE_CLASS_TOKEN = '::'  # noqa: S105
 
 
 @dataclass(eq=False)
diff --git a/tatsu/util/_common.py b/tatsu/util/_common.py
index db3d510a..510cd6bd 100644
--- a/tatsu/util/_common.py
+++ b/tatsu/util/_common.py
@@ -491,9 +491,9 @@ def filelist_from_patterns(patterns, ignore=None, base='.', sizesort=False):
             path += '/*'
 
         parts = path.parts[1:] if path.is_absolute() else path.parts
-        pattern = str(Path().joinpath(*parts))
+        joined_pattern = str(Path().joinpath(*parts))
         filenames.update(
-            p for p in Path(path.root).glob(pattern) if not p.is_dir()
+            p for p in Path(path.root).glob(joined_pattern) if not p.is_dir()
         )
 
     filenames = list(filenames)
diff --git a/test/buffering_test.py b/test/buffering_test.py
index 064779dd..7cd5fd6c 100644
--- a/test/buffering_test.py
+++ b/test/buffering_test.py
@@ -40,7 +40,7 @@ def test_next_consisntency(self):
 
     def test_goto_consistency(self):
         for _ in range(100):
-            self.buf.goto(random.randrange(len(self.text)))
+            self.buf.goto(random.randrange(len(self.text)))  # noqa: S311
             bl, bc = self.buf.line_info()[1:3]
             #            print('li', bl, bc)
             #            print('bu', self.buf.line, self.buf.col)
diff --git a/test/grammar/semantics_test.py b/test/grammar/semantics_test.py
index 22b45cea..d299a1c0 100644
--- a/test/grammar/semantics_test.py
+++ b/test/grammar/semantics_test.py
@@ -1,3 +1,4 @@
+# ruff: noqa: S102
 import unittest
 
 from tatsu import synth
diff --git a/test/parser_equivalence_test.py b/test/parser_equivalence_test.py
index f41a2306..cee99298 100644
--- a/test/parser_equivalence_test.py
+++ b/test/parser_equivalence_test.py
@@ -1,3 +1,4 @@
+# ruff: noqa: S102
 import types
 
 import pytest
diff --git a/test/parsing_test.py b/test/parsing_test.py
index 906e7c1c..f5b70fd4 100644
--- a/test/parsing_test.py
+++ b/test/parsing_test.py
@@ -1,6 +1,7 @@
 import json
 import tempfile
 import unittest
+from pathlib import Path
 
 import tatsu
 from tatsu.parser import EBNFBuffer
@@ -45,9 +46,9 @@ def test_real_include(self):
 
             start = a b;"""
 
-        with open(include_a, 'w') as fh:
+        with Path(include_a).open('w') as fh:
             fh.write("a = 'inclusion';")
-        with open(include_b, 'w') as fh:
+        with Path(include_b).open('w') as fh:
             fh.write("b = 'works';")
 
         model = tatsu.compile(
diff --git a/test/zzz_bootstrap/bootstrap_test.py b/test/zzz_bootstrap/bootstrap_test.py
index 50222048..1f1ae95b 100644
--- a/test/zzz_bootstrap/bootstrap_test.py
+++ b/test/zzz_bootstrap/bootstrap_test.py
@@ -33,7 +33,7 @@ def test_bootstrap(self):
         g = EBNFParser('EBNFBootstrap')
         grammar0 = g.parse(text, parseinfo=False)
         ast0 = json.dumps(asjson(grammar0), indent=2)
-        with open('./tmp/00.ast', 'w') as f:
+        with Path('./tmp/00.ast').open('w') as f:
             f.write(ast0)
 
         print('-' * 20, 'phase 01 - parse with parser generator')
@@ -86,7 +86,7 @@ def test_bootstrap(self):
 
         print('-' * 20, 'phase 06 - generate parser code')
         gencode6 = codegen(parser)
-        with open('./tmp/g06.py', 'w') as f:
+        with Path('./tmp/g06.py').open('w') as f:
             f.write(gencode6)
 
         print('-' * 20, 'phase 07 - import generated code')
@@ -108,7 +108,7 @@ def test_bootstrap(self):
         parser = GrammarGenerator('EBNFBootstrap')
         g9 = parser.parse(text)
         generated_grammar9 = str(g9)
-        with open('./tmp/09.ebnf', 'w') as f:
+        with Path('./tmp/09.ebnf').open('w') as f:
             f.write(generated_grammar9)
         self.assertEqual(generated_grammar9, generated_grammar1)
 
@@ -119,26 +119,26 @@ def test_bootstrap(self):
             semantics=EBNFGrammarSemantics('EBNFBootstrap'),
         )
         generated_grammar10 = str(g10)
-        with open('./tmp/10.ebnf', 'w') as f:
+        with Path('./tmp/10.ebnf').open('w') as f:
             f.write(generated_grammar10)
         gencode10 = codegen(g10)
-        with open('./tmp/g10.py', 'w') as f:
+        with Path('./tmp/g10.py').open('w') as f:
             f.write(gencode10)
 
         print('-' * 20, 'phase 11 - Pickle the model and try again.')
-        with open('./tmp/11.tatsu', 'wb') as f:
+        with Path('./tmp/11.tatsu').open('wb') as f:
             pickle.dump(g10, f)
-        with open('./tmp/11.tatsu', 'rb') as f:
+        with Path('./tmp/11.tatsu').open('rb') as f:
             g11 = pickle.load(f)
         r11 = g11.parse(
             text,
             start_rule='start',
             semantics=EBNFGrammarSemantics('EBNFBootstrap'),
         )
-        with open('./tmp/11.ebnf', 'w') as f:
+        with Path('./tmp/11.ebnf').open('w') as f:
             f.write(str(g11))
         gencode11 = codegen(r11)
-        with open('./tmp/bootstrap_g11.py', 'w') as f:
+        with Path('./tmp/bootstrap_g11.py').open('w') as f:
             f.write(gencode11)
 
         print('-' * 20, 'phase 12 - Walker')
@@ -153,7 +153,7 @@ def walk_default(self, o, children):
 
         v = PrintNameWalker()
         v.walk(g11)
-        with open('./tmp/12.txt', 'w') as f:
+        with Path('./tmp/12.txt').open('w') as f:
             f.write('\n'.join(v.walked))
 
         print('-' * 20, 'phase 13 - Graphics')