Get things linting again.

Linted against pylint 3.11 with the pylintrc
file recommended from the Google Python Style Guide,
specifically from
https://github.com/google/styleguide/blob/28d10d1/pylintrc.

Then ran through `ruff check` as well.

Author: dpranke

benchmarks/run.py

@@ -19,23 +19,18 @@
 import sys
 import time
 
-THIS_DIR = os.path.abspath(os.path.dirname(__file__))
-REPO_DIR = os.path.dirname(THIS_DIR)
-if not REPO_DIR in sys.path:
-    sys.path.insert(0, REPO_DIR)
-
-import json5  # pylint: disable=wrong-import-position
-
+import json5
 
 ALL_BENCHMARKS = (
     '64KB-min.json',
     'bitly-usa-gov.json',
     'twitter.json',
 )
 
-
 DEFAULT_ITERATIONS = 3
 
+THIS_DIR = os.path.abspath(os.path.dirname(__file__))
+
 
 def main():
     parser = argparse.ArgumentParser()
@@ -49,7 +44,7 @@ def main():
 
     file_contents = []
     for f in args.benchmarks:
-        with open(f) as fp:
+        with open(f, encoding='utf-8') as fp:
             file_contents.append(fp.read())
 
 
@@ -86,20 +81,20 @@ def py_maker(*args, **kwargs):
         if json5_time and json_time:
             if json5_time > json_time:
                 avg = json5_time / json_time
-                print("%-20s: JSON was %5.1fx faster (%.6fs to %.6fs)" % (
-                      fname, avg, json_time, json5_time))
+                print(f"{fname:-%20s}: JSON was {avg:5.1f}x faster "
+                      f"({json_time:.6f} to {json5_time:.6fs}")
             else:
                 avg = json_time / json5_time
-                print("%-20s: JSON5 was %5.1fx faster (%.6fs to %.6fs)" % (
-                      fname, avg, json5_time, json_time))
+                print(f"{fname:-%20s}: JSON5 was {avg:5.1f}x faster "
+                      f"({json5_time:.6f} to {json_time:.6fs}")
         elif json5_time:
-            print("%-20s: JSON5 took %.6f secs, JSON was too fast to measure" %
-                  (fname, json5_time))
+            print(f"{fname:-20s}: JSON5 took {json5_time:.6f} secs, "
+                  f"JSON was too fast to measure")
         elif json_time:
-            print("%-20s: JSON took %.6f secs, JSON5 was too fast to measure" %
-                  (fname, json_time))
+            print(f"{fname:-20s}: JSON took {json_time:.6f} secs, "
+                  f"JSON5 was too fast to measure")
         else:
-            print("%-20s: both were too fast to measure" % (fname,))
+            print(f"{fname:-20s}: both were too fast to measure")
 
     return 0
 

json5/arg_parser.py

@@ -40,18 +40,16 @@ def parse_args(self, args=None, namespace=None):
 
         return rargs
 
-    # Redefining built-in 'file' pylint: disable=W0622
-
-    def _print_message(self, msg, file=None):
-        self._host.print_(msg=msg, stream=file, end='\n')
+    def _print_message(self, message, file=None):
+        self._host.print_(msg=message, stream=file, end='\n')
 
     def print_help(self, file=None):
-        self._print_message(msg=self.format_help(), file=file)
+        self._print_message(message=self.format_help(), file=file)
 
-    def error(self, message, bailout=True):  # pylint: disable=W0221
-        self.exit(2, '%s: error: %s\n' % (self.prog, message), bailout=bailout)
+    def error(self, message, bailout=True):
+        self.exit(2, f'{self.prog}: error: {message}\n', bailout=bailout)
 
-    def exit(self, status=0, message=None,  # pylint: disable=W0221
+    def exit(self, status=0, message=None,
              bailout=True):
         self.exit_status = status
         if message:

json5/lib.py

@@ -15,7 +15,7 @@
 import math
 import re
 from typing import Any, Callable, IO, Iterable, Mapping, Optional, \
-    Sequence, Set, Tuple, Union
+    Set, Tuple, Union
 import unicodedata
 
 from .parser import Parser
@@ -92,13 +92,15 @@ def _fp_constant_parser(s):
     if object_pairs_hook:
         dictify = object_pairs_hook
     elif object_hook:
-        dictify = lambda pairs: object_hook(dict(pairs))
+        def dictify(pairs):
+            return object_hook(dict(pairs))
     else:
-        dictify = lambda pairs: dict(pairs) # pylint: disable=unnecessary-lambda
+        dictify = dict
 
     if not allow_duplicate_keys:
         _orig_dictify = dictify
-        dictify = lambda pairs: _reject_duplicate_keys(pairs, _orig_dictify)
+        def dictify(pairs):
+            return _reject_duplicate_keys(pairs, _orig_dictify)
 
     parse_float = parse_float or float
     parse_int = parse_int or int
@@ -111,7 +113,7 @@ def _reject_duplicate_keys(pairs, dictify):
     keys = set()
     for key, _ in pairs:
         if key in keys:
-            raise ValueError('Duplicate key "%s" found in object', key)
+            raise ValueError(f'Duplicate key "{key}" found in object')
         keys.add(key)
     return dictify(pairs)
 
@@ -129,12 +131,11 @@ def _walk_ast(el,
     if ty == 'number':
         if v.startswith('0x') or v.startswith('0X'):
             return parse_int(v, base=16)
-        elif '.' in v or 'e' in v or 'E' in v:
+        if '.' in v or 'e' in v or 'E' in v:
             return parse_float(v)
-        elif 'Infinity' in v or 'NaN' in v:
+        if 'Infinity' in v or 'NaN' in v:
             return parse_constant(v)
-        else:
-            return parse_int(v)
+        return parse_int(v)
     if ty == 'string':
         return v
     if ty == 'object':
@@ -147,7 +148,7 @@ def _walk_ast(el,
     if ty == 'array':
         return [_walk_ast(el, dictify, parse_float, parse_int, parse_constant)
                 for el in v]
-    raise Exception('unknown el: ' + el)  # pragma: no cover
+    raise ValueError('unknown el: ' + el)  # pragma: no cover
 
 
 def dump(obj: Any,
@@ -202,6 +203,7 @@ def dump(obj: Any,
     should produce exactly the same output as ``json.dump(obj, fp).``
     """
 
+    del kwargs
     fp.write(dumps(obj=obj, skipkeys=skipkeys, ensure_ascii=ensure_ascii,
                    check_circular=check_circular, allow_nan=allow_nan,
                    cls=cls, indent=indent, separators=separators,
@@ -261,6 +263,7 @@ def dumps(obj: Any,
     """
 
     assert kwargs.get('cls', None) is None, 'Custom encoders are not supported'
+    del cls
 
     if separators is None:
         if indent is None:
@@ -291,6 +294,7 @@ def _dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, indent,
            seen: Optional[Set[int]],
            level: int,
            is_key: bool):
+    # pylint: disable=too-many-statements
     if obj is True:
         s = 'true'
     elif obj is False:
@@ -332,10 +336,10 @@ def _dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, indent,
 
     if is_key:
         if s is not None:
-            return True, '"%s"' % s
+            return True, f'"{s}"'
         if skipkeys:
             return False, None
-        raise TypeError('invalid key %s' % repr(obj))
+        raise TypeError(f'invalid key {repr(obj)}')
 
     if s is not None:
         return True, s
@@ -344,7 +348,7 @@ def _dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, indent,
         end_str = ''
         if trailing_commas:
             end_str = ','
-        if type(indent) == int:
+        if isinstance(indent, int):
             if indent > 0:
                 indent_str = '\n' + ' ' * indent * level
                 end_str += '\n' + ' ' * indent * (level - 1)
@@ -365,11 +369,11 @@ def _dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, indent,
         i = id(obj)
         if i in seen:
             raise ValueError('Circular reference detected.')
-        else:
-            seen.add(i)
+        seen.add(i)
 
-    # In Python3, we'd check if this was an abc.Mapping or an abc.Sequence.
-    # For now, just check for the attrs we need to iterate over the object.
+    # Ideally we'd use collections.abc.Mapping and collections.abc.Sequence
+    # here, but for backwards-compatibility with potential old callers,
+    # we only check for the two attributes we need in each case.
     if hasattr(obj, 'keys') and hasattr(obj, '__getitem__'):
         s = _dump_dict(obj, skipkeys, ensure_ascii,
                        check_circular, allow_nan, indent,
@@ -423,9 +427,8 @@ def _dump_dict(obj, skipkeys, ensure_ascii, check_circular, allow_nan,
         if valid_key:
             if not allow_duplicate_keys:
                 if key_str in new_keys:
-                    raise ValueError('duplicate key %s' % repr(key))
-                else:
-                    new_keys.add(key_str)
+                    raise ValueError(f'duplicate key {repr(key)}')
+                new_keys.add(key_str)
             if num_items_added:
                 s += item_sep
             s += key_str + kv_sep + _dumps(obj[key], skipkeys, ensure_ascii,
@@ -436,7 +439,7 @@ def _dump_dict(obj, skipkeys, ensure_ascii, check_circular, allow_nan,
                                            seen, level, is_key=False)[1]
             num_items_added += 1
         elif not skipkeys:
-            raise TypeError('invalid key %s' % repr(key))
+            raise TypeError(f'invalid key {repr(key)}')
 
     s += end_str + '}'
     return s
@@ -486,15 +489,15 @@ def _dump_str(obj, ensure_ascii):
             ret.append(ch)
         else:
             o = ord(ch)
-            if o >= 32 and o < 128:
+            if 32 <= o < 128:
                 ret.append(ch)
             elif o < 65536:
-                ret.append('\\u' + '%04x' % o)
+                ret.append(f'\\u{o:04x}')
             else:
                 val = o - 0x10000
                 high = 0xd800 + (val >> 10)
                 low = 0xdc00 + (val & 0x3ff)
-                ret.append('\\u%04x\\u%04x' % (high, low))
+                ret.append(f'\\u{high:04x}\\u{low:04x}')
     return ''.join(ret) + '"'
 
 
@@ -566,4 +569,4 @@ def _is_reserved_word(k):
 
 
 def _raise_type_error(obj):
-    raise TypeError('%s is not JSON5 serializable' % repr(obj))
+    raise TypeError(f'{repr(obj)} is not JSON5 serializable')

json5/parser.py

@@ -1,4 +1,6 @@
-# pylint: disable=line-too-long,unnecessary-lambda
+# pylint: disable=line-too-long,too-many-lines,unnecessary-lambda
+
+import unicodedata
 
 
 class Parser:
@@ -24,9 +26,8 @@ def _err_str(self):
         if self.errpos == len(self.msg):
             thing = 'end of input'
         else:
-            thing = '"%s"' % self.msg[self.errpos]
-        return '%s:%d Unexpected %s at column %d' % (
-            self.fname, lineno, thing, colno)
+            thing = f'"{self.msg[self.errpos]}"'
+        return f'{self.fname}:{lineno} Unexpected {thing} at column {colno}'
 
     def _err_offsets(self):
         lineno = 1
@@ -48,8 +49,7 @@ def _succeed(self, v, newpos=None):
     def _fail(self):
         self.val = None
         self.failed = True
-        if self.pos >= self.errpos:
-            self.errpos = self.pos
+        self.errpos = max(self.errpos, self.pos)
 
     def _rewind(self, newpos):
         self._succeed(None, newpos)
@@ -94,8 +94,7 @@ def _star(self, rule, vs=None):
             if self.failed:
                 self._rewind(p)
                 break
-            else:
-                vs.append(self.val)
+            vs.append(self.val)
         self._succeed(vs)
 
     def _seq(self, rules):
@@ -148,7 +147,6 @@ def _set(self, var, val):
         self._scopes[-1][1][var] = val
 
     def _is_unicat(self, var, cat):
-        import unicodedata
         return unicodedata.category(var) == cat
 
     def _join(self, s, vs):
@@ -199,7 +197,7 @@ def _ws__c8__s0_(self):
         self._not(lambda: self._not(self._ws__c8__s0_n_n_))
 
     def _ws__c8__s0_n_n_(self):
-        (lambda: self._choose([self._ws__c8__s0_n_n_g__c0_]))()
+        self._choose([self._ws__c8__s0_n_n_g__c0_])
 
     def _ws__c8__s0_n_n_g__c0_(self):
         self._seq([lambda: self._bind(self._anything_, 'x'),

pylintrc

@@ -35,5 +35,12 @@ dev = ["hypothesis"]
 [project.scripts]
 pyjson5 = "json5.tool:main"
 
+[tool.ruff]
+include = [ "run", "*/*.py" ]
+line-length = 79
+
+[tool.ruff.format]
+quote-style = "single"
+
 [tool.setuptools.dynamic]
 version = {attr = "json5.__version__"}