Add pyupgrade to pre-commit config.

.pre-commit-config.yaml

@@ -2,6 +2,11 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
 
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.3.1
+    hooks:
+      - id: pyupgrade
+
   - repo: https://github.com/psf/black
     rev: 22.12.0
     hooks:

benedict/dicts/__init__.py

@@ -45,9 +45,9 @@ def __init__(self, *args, **kwargs):
         if len(args) == 1 and isinstance(args[0], benedict):
             obj = args[0]
             kwargs.setdefault("keypath_separator", obj.keypath_separator)
-            super(benedict, self).__init__(obj.dict(), **kwargs)
+            super().__init__(obj.dict(), **kwargs)
             return
-        super(benedict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def __deepcopy__(self, memo):
         obj_type = type(self)
@@ -57,7 +57,7 @@ def __deepcopy__(self, memo):
         return obj
 
     def __getitem__(self, key):
-        return self._cast(super(benedict, self).__getitem__(key))
+        return self._cast(super().__getitem__(key))
 
     def _cast(self, value):
         """
@@ -89,7 +89,7 @@ def copy(self):
         """
         Creates and return a copy of the current instance (shallow copy).
         """
-        return self._cast(super(benedict, self).copy())
+        return self._cast(super().copy())
 
     def deepcopy(self):
         """
@@ -137,15 +137,13 @@ def flatten(self, separator="_"):
         return _flatten(self, separator)
 
     def get(self, key, default=None):
-        return self._cast(super(benedict, self).get(key, default))
+        return self._cast(super().get(key, default))
 
     def get_dict(self, key, default=None):
-        return self._cast(super(benedict, self).get_dict(key, default))
+        return self._cast(super().get_dict(key, default))
 
     def get_list_item(self, key, index=0, default=None, separator=","):
-        return self._cast(
-            super(benedict, self).get_list_item(key, index, default, separator)
-        )
+        return self._cast(super().get_list_item(key, index, default, separator))
 
     def groupby(self, key, by_key):
         """
@@ -216,7 +214,7 @@ def nest(
         return _nest(self[key], id_key, parent_id_key, children_key)
 
     def pop(self, key, *args):
-        return self._cast(super(benedict, self).pop(key, *args))
+        return self._cast(super().pop(key, *args))
 
     def remove(self, keys, *args):
         """
@@ -226,7 +224,7 @@ def remove(self, keys, *args):
         _remove(self, keys, *args)
 
     def setdefault(self, key, default=None):
-        return self._cast(super(benedict, self).setdefault(key, default))
+        return self._cast(super().setdefault(key, default))
 
     def rename(self, key, key_new):
         """

benedict/dicts/base/base_dict.py

@@ -21,11 +21,11 @@ def __init__(self, *args, **kwargs):
         if len(args) == 1 and isinstance(args[0], dict):
             self._dict = self._get_dict_or_value(args[0])
             self._pointer = True
-            super(BaseDict, self).__init__(self._dict)
+            super().__init__(self._dict)
             return
         self._dict = None
         self._pointer = False
-        super(BaseDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def __bool__(self):
         if self._pointer:
@@ -35,7 +35,7 @@ def __bool__(self):
     def __contains__(self, key):
         if self._pointer:
             return key in self._dict
-        return super(BaseDict, self).__contains__(key)
+        return super().__contains__(key)
 
     def __deepcopy__(self, memo):
         obj = self.__class__()
@@ -47,32 +47,32 @@ def __delitem__(self, key):
         if self._pointer:
             del self._dict[key]
             return
-        super(BaseDict, self).__delitem__(key)
+        super().__delitem__(key)
 
     def __eq__(self, other):
         if self._pointer:
             return self._dict == other
-        return super(BaseDict, self).__eq__(other)
+        return super().__eq__(other)
 
     def __getitem__(self, key):
         if self._pointer:
             return self._dict[key]
-        return super(BaseDict, self).__getitem__(key)
+        return super().__getitem__(key)
 
     def __iter__(self):
         if self._pointer:
             return iter(self._dict)
-        return super(BaseDict, self).__iter__()
+        return super().__iter__()
 
     def __len__(self):
         if self._pointer:
             return len(self._dict)
-        return super(BaseDict, self).__len__()
+        return super().__len__()
 
     def __repr__(self):
         if self._pointer:
             return repr(self._dict)
-        return super(BaseDict, self).__repr__()
+        return super().__repr__()
 
     def __setitem__(self, key, value):
         value = self._get_dict_or_value(value)
@@ -85,23 +85,23 @@ def __setitem__(self, key, value):
                 return
             self._dict[key] = value
             return
-        super(BaseDict, self).__setitem__(key, value)
+        super().__setitem__(key, value)
 
     def __str__(self):
         if self._pointer:
             return str(self._dict)
-        return super(BaseDict, self).__str__()
+        return super().__str__()
 
     def clear(self):
         if self._pointer:
             self._dict.clear()
             return
-        super(BaseDict, self).clear()
+        super().clear()
 
     def copy(self):
         if self._pointer:
             return self._dict.copy()
-        return super(BaseDict, self).copy()
+        return super().copy()
 
     def dict(self):
         if self._pointer:
@@ -111,37 +111,37 @@ def dict(self):
     def get(self, key, default=None):
         if self._pointer:
             return self._dict.get(key, default)
-        return super(BaseDict, self).get(key, default)
+        return super().get(key, default)
 
     def items(self):
         if self._pointer:
             return self._dict.items()
-        return super(BaseDict, self).items()
+        return super().items()
 
     def keys(self):
         if self._pointer:
             return self._dict.keys()
-        return super(BaseDict, self).keys()
+        return super().keys()
 
     def pop(self, key, *args):
         if self._pointer:
             return self._dict.pop(key, *args)
-        return super(BaseDict, self).pop(key, *args)
+        return super().pop(key, *args)
 
     def setdefault(self, key, default=None):
         default = self._get_dict_or_value(default)
         if self._pointer:
             return self._dict.setdefault(key, default)
-        return super(BaseDict, self).setdefault(key, default)
+        return super().setdefault(key, default)
 
     def update(self, other):
         other = self._get_dict_or_value(other)
         if self._pointer:
             self._dict.update(other)
             return
-        super(BaseDict, self).update(other)
+        super().update(other)
 
     def values(self):
         if self._pointer:
             return self._dict.values()
-        return super(BaseDict, self).values()
+        return super().values()

benedict/dicts/io/io_dict.py

@@ -12,9 +12,9 @@ def __init__(self, *args, **kwargs):
         # use 'format' kwarg to specify the decoder to use, default 'json'.
         if len(args) == 1 and type_util.is_string(args[0]):
             d = IODict._decode_init(args[0], **kwargs)
-            super(IODict, self).__init__(d)
+            super().__init__(d)
             return
-        super(IODict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     @staticmethod
     def _decode_init(s, **kwargs):

benedict/dicts/keylist/keylist_dict.py

@@ -5,12 +5,12 @@
 
 class KeylistDict(BaseDict):
     def __init__(self, *args, **kwargs):
-        super(KeylistDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def __contains__(self, key):
         if type_util.is_list_or_tuple(key):
             return self._contains_by_keys(key)
-        return super(KeylistDict, self).__contains__(key)
+        return super().__contains__(key)
 
     def _contains_by_keys(self, keys):
         parent, _, _ = keylist_util.get_item(self, keys)
@@ -22,7 +22,7 @@ def __delitem__(self, key):
         if type_util.is_list_or_tuple(key):
             self._delitem_by_keys(key)
             return
-        super(KeylistDict, self).__delitem__(key)
+        super().__delitem__(key)
 
     def _delitem_by_keys(self, keys):
         parent, key, _ = keylist_util.get_item(self, keys)
@@ -37,7 +37,7 @@ def _delitem_by_keys(self, keys):
     def __getitem__(self, key):
         if type_util.is_list_or_tuple(key):
             return self._getitem_by_keys(key)
-        return super(KeylistDict, self).__getitem__(key)
+        return super().__getitem__(key)
 
     def _getitem_by_keys(self, keys):
         parent, key, _ = keylist_util.get_item(self, keys)
@@ -49,15 +49,15 @@ def __setitem__(self, key, value):
         if type_util.is_list_or_tuple(key):
             self._setitem_by_keys(key, value)
             return
-        super(KeylistDict, self).__setitem__(key, value)
+        super().__setitem__(key, value)
 
     def _setitem_by_keys(self, keys, value):
         keylist_util.set_item(self, keys, value)
 
     def get(self, key, default=None):
         if type_util.is_list_or_tuple(key):
             return self._get_by_keys(key, default)
-        return super(KeylistDict, self).get(key, default)
+        return super().get(key, default)
 
     def _get_by_keys(self, keys, default=None):
         parent, key, _ = keylist_util.get_item(self, keys)
@@ -70,7 +70,7 @@ def _get_by_keys(self, keys, default=None):
     def pop(self, key, *args):
         if type_util.is_list_or_tuple(key):
             return self._pop_by_keys(key, *args)
-        return super(KeylistDict, self).pop(key, *args)
+        return super().pop(key, *args)
 
     def _pop_by_keys(self, keys, *args):
         parent, key, _ = keylist_util.get_item(self, keys)

benedict/dicts/keypath/keypath_dict.py

@@ -9,7 +9,7 @@ class KeypathDict(KeylistDict):
     def __init__(self, *args, **kwargs):
         self._keypath_separator = kwargs.pop("keypath_separator", ".")
         check_keys = kwargs.pop("check_keys", True)
-        super(KeypathDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         if check_keys:
             keypath_util.check_keys(self, self._keypath_separator)
 
@@ -23,17 +23,17 @@ def keypath_separator(self, value):
         self._keypath_separator = value
 
     def __contains__(self, key):
-        return super(KeypathDict, self).__contains__(self._parse_key(key))
+        return super().__contains__(self._parse_key(key))
 
     def __delitem__(self, key):
-        super(KeypathDict, self).__delitem__(self._parse_key(key))
+        super().__delitem__(self._parse_key(key))
 
     def __getitem__(self, key):
-        return super(KeypathDict, self).__getitem__(self._parse_key(key))
+        return super().__getitem__(self._parse_key(key))
 
     def __setitem__(self, key, value):
         keypath_util.check_keys(value, self._keypath_separator)
-        super(KeypathDict, self).__setitem__(self._parse_key(key), value)
+        super().__setitem__(self._parse_key(key), value)
 
     def _parse_key(self, key):
         keys = keypath_util.parse_keys(key, self._keypath_separator)
@@ -52,11 +52,11 @@ def fromkeys(cls, sequence, value=None):
         return d
 
     def get(self, key, default=None):
-        return super(KeypathDict, self).get(self._parse_key(key), default)
+        return super().get(self._parse_key(key), default)
 
     def pop(self, key, *args):
-        return super(KeypathDict, self).pop(self._parse_key(key), *args)
+        return super().pop(self._parse_key(key), *args)
 
     def update(self, other):
         keypath_util.check_keys(other, self._keypath_separator)
-        super(KeypathDict, self).update(other)
+        super().update(other)

benedict/dicts/parse/parse_dict.py

@@ -10,7 +10,7 @@ def __init__(self, *args, **kwargs):
         """
         Constructs a new instance.
         """
-        super(ParseDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def _get_value(self, key, default, choices, parser_func, parser_kwargs=None):
         """

benedict/serializers/abstract.py

@@ -1,10 +1,10 @@
-class AbstractSerializer(object):
+class AbstractSerializer:
     """
     This class describes an abstract serializer.
     """
 
     def __init__(self, extensions=None):
-        super(AbstractSerializer, self).__init__()
+        super().__init__()
         self._extensions = (extensions or []).copy()
 
     def decode(self, s, **kwargs):

benedict/serializers/base64.py

@@ -11,7 +11,7 @@ class Base64CoreSerializer(AbstractSerializer):
     """
 
     def __init__(self):
-        super(Base64CoreSerializer, self).__init__(
+        super().__init__(
             extensions=[
                 "b64",
                 "base64",
@@ -50,7 +50,7 @@ def encode(self, d, **kwargs):
 
 class Base64Serializer(Base64CoreSerializer):
     def __init__(self):
-        super(Base64Serializer, self).__init__()
+        super().__init__()
 
     def _pop_options(self, options):
         encoding = options.pop("encoding", "utf-8")
@@ -62,7 +62,7 @@ def _pop_options(self, options):
 
     def decode(self, s, **kwargs):
         serializer, encoding = self._pop_options(kwargs)
-        value = super(Base64Serializer, self).decode(s, encoding=encoding)
+        value = super().decode(s, encoding=encoding)
         if serializer:
             value = serializer.decode(value, **kwargs)
         return value
@@ -72,5 +72,5 @@ def encode(self, d, **kwargs):
         value = d
         if serializer:
             value = serializer.encode(value, **kwargs)
-        value = super(Base64Serializer, self).encode(value, encoding=encoding)
+        value = super().encode(value, encoding=encoding)
         return value

benedict/serializers/csv.py

@@ -11,7 +11,7 @@ class CSVSerializer(AbstractSerializer):
     """
 
     def __init__(self):
-        super(CSVSerializer, self).__init__(
+        super().__init__(
             extensions=[
                 "csv",
             ],