Add pyupgrade pre-commit hook and run on all files (#736)

Author: dan98765

.pre-commit-config.yaml

@@ -17,6 +17,10 @@ repos:
         args:
         - --autofix
     -   id: flake8
+-   repo: https://github.com/asottile/pyupgrade
+    rev: v1.2.0
+    hooks:
+    -   id: pyupgrade
 -   repo: https://github.com/asottile/seed-isort-config
     rev: v1.0.0
     hooks:

graphene/pyutils/enum.py

@@ -170,7 +170,7 @@ def __new__(metacls, cls, bases, classdict):
                                                          first_enum)
         # save enum items into separate mapping so they don't get baked into
         # the new class
-        members = dict((k, classdict[k]) for k in classdict._member_names)
+        members = {k: classdict[k] for k in classdict._member_names}
         for name in classdict._member_names:
             del classdict[name]
 
@@ -192,14 +192,14 @@ def __new__(metacls, cls, bases, classdict):
                 _order_ += aliases
 
         # check for illegal enum names (any others?)
-        invalid_names = set(members) & set(['mro'])
+        invalid_names = set(members) & {'mro'}
         if invalid_names:
             raise ValueError('Invalid enum member name(s): %s' % (
                 ', '.join(invalid_names), ))
 
         # save attributes from super classes so we know if we can take
         # the shortcut of storing members in the class dict
-        base_attributes = set([a for b in bases for a in b.__dict__])
+        base_attributes = {a for b in bases for a in b.__dict__}
         # create our new Enum type
         enum_class = super(EnumMeta, metacls).__new__(metacls, cls, bases, classdict)
         enum_class._member_names_ = []               # names in random order
@@ -831,7 +831,7 @@ def _convert(cls, name, module, filter, source=None):
         source = vars(source)
     else:
         source = module_globals
-    members = dict((name, value) for name, value in source.items() if filter(name))
+    members = {name: value for name, value in source.items() if filter(name)}
     cls = cls(name, members, module=module)
     cls.__reduce_ex__ = _reduce_ex_by_name
     module_globals.update(cls.__members__)

graphene/pyutils/signature.py

@@ -52,7 +52,7 @@ def signature(obj):
     '''Get a signature object for the passed callable.'''
 
     if not callable(obj):
-        raise TypeError('{0!r} is not a callable object'.format(obj))
+        raise TypeError('{!r} is not a callable object'.format(obj))
 
     if isinstance(obj, types.MethodType):
         sig = signature(obj.__func__)
@@ -99,7 +99,7 @@ def signature(obj):
         try:
             ba = sig.bind_partial(*partial_args, **partial_keywords)
         except TypeError as ex:
-            msg = 'partial object {0!r} has incorrect arguments'.format(obj)
+            msg = 'partial object {!r} has incorrect arguments'.format(obj)
             raise ValueError(msg)
 
         for arg_name, arg_value in ba.arguments.items():
@@ -166,10 +166,10 @@ def signature(obj):
 
     if isinstance(obj, types.BuiltinFunctionType):
         # Raise a nicer error message for builtins
-        msg = 'no signature found for builtin function {0!r}'.format(obj)
+        msg = 'no signature found for builtin function {!r}'.format(obj)
         raise ValueError(msg)
 
-    raise ValueError('callable {0!r} is not supported by signature'.format(obj))
+    raise ValueError('callable {!r} is not supported by signature'.format(obj))
 
 
 class _void(object):
@@ -190,7 +190,7 @@ def __str__(self):
         return self._name
 
     def __repr__(self):
-        return '<_ParameterKind: {0!r}>'.format(self._name)
+        return '<_ParameterKind: {!r}>'.format(self._name)
 
 
 _POSITIONAL_ONLY = _ParameterKind(0, name='POSITIONAL_ONLY')
@@ -238,7 +238,7 @@ def __init__(self, name, kind, default=_empty, annotation=_empty,
 
         if default is not _empty:
             if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
-                msg = '{0} parameters cannot have default values'.format(kind)
+                msg = '{} parameters cannot have default values'.format(kind)
                 raise ValueError(msg)
         self._default = default
         self._annotation = annotation
@@ -251,7 +251,7 @@ def __init__(self, name, kind, default=_empty, annotation=_empty,
         else:
             name = str(name)
             if kind != _POSITIONAL_ONLY and not re.match(r'[a-z_]\w*$', name, re.I):
-                msg = '{0!r} is not a valid parameter name'.format(name)
+                msg = '{!r} is not a valid parameter name'.format(name)
                 raise ValueError(msg)
             self._name = name
 
@@ -302,15 +302,15 @@ def __str__(self):
         if kind == _POSITIONAL_ONLY:
             if formatted is None:
                 formatted = ''
-            formatted = '<{0}>'.format(formatted)
+            formatted = '<{}>'.format(formatted)
 
         # Add annotation and default value
         if self._annotation is not _empty:
-            formatted = '{0}:{1}'.format(formatted,
+            formatted = '{}:{}'.format(formatted,
                                        formatannotation(self._annotation))
 
         if self._default is not _empty:
-            formatted = '{0}={1}'.format(formatted, repr(self._default))
+            formatted = '{}={}'.format(formatted, repr(self._default))
 
         if kind == _VAR_POSITIONAL:
             formatted = '*' + formatted
@@ -320,11 +320,11 @@ def __str__(self):
         return formatted
 
     def __repr__(self):
-        return '<{0} at {1:#x} {2!r}>'.format(self.__class__.__name__,
+        return '<{} at {:#x} {!r}>'.format(self.__class__.__name__,
                                            id(self), self.name)
 
     def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        msg = "unhashable type: '{}'".format(self.__class__.__name__)
         raise TypeError(msg)
 
     def __eq__(self, other):
@@ -421,7 +421,7 @@ def kwargs(self):
         return kwargs
 
     def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        msg = "unhashable type: '{}'".format(self.__class__.__name__)
         raise TypeError(msg)
 
     def __eq__(self, other):
@@ -489,7 +489,7 @@ def __init__(self, parameters=None, return_annotation=_empty,
                         param = param.replace(name=name)
 
                     if name in params:
-                        msg = 'duplicate parameter name: {0!r}'.format(name)
+                        msg = 'duplicate parameter name: {!r}'.format(name)
                         raise ValueError(msg)
                     params[name] = param
             else:
@@ -504,7 +504,7 @@ def from_function(cls, func):
         '''Constructs Signature for the given python function'''
 
         if not isinstance(func, types.FunctionType):
-            raise TypeError('{0!r} is not a Python function'.format(func))
+            raise TypeError('{!r} is not a Python function'.format(func))
 
         Parameter = cls._parameter_cls
 
@@ -599,7 +599,7 @@ def replace(self, parameters=_void, return_annotation=_void):
                           return_annotation=return_annotation)
 
     def __hash__(self):
-        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        msg = "unhashable type: '{}'".format(self.__class__.__name__)
         raise TypeError(msg)
 
     def __eq__(self, other):
@@ -608,8 +608,8 @@ def __eq__(self, other):
                 len(self.parameters) != len(other.parameters)):
             return False
 
-        other_positions = dict((param, idx)
-                           for idx, param in enumerate(other.parameters.keys()))
+        other_positions = {param: idx
+                           for idx, param in enumerate(other.parameters.keys())}
 
         for idx, (param_name, param) in enumerate(self.parameters.items()):
             if param.kind == _KEYWORD_ONLY:
@@ -799,10 +799,10 @@ def __str__(self):
 
             result.append(formatted)
 
-        rendered = '({0})'.format(', '.join(result))
+        rendered = '({})'.format(', '.join(result))
 
         if self.return_annotation is not _empty:
             anno = formatannotation(self.return_annotation)
-            rendered += ' -> {0}'.format(anno)
+            rendered += ' -> {}'.format(anno)
 
         return rendered

graphene/types/base.py

@@ -18,7 +18,7 @@ def __setattr__(self, name, value):
         if not self._frozen:
             super(BaseOptions, self).__setattr__(name, value)
         else:
-            raise Exception("Can't modify frozen Options {0}".format(self))
+            raise Exception("Can't modify frozen Options {}".format(self))
 
     def __repr__(self):
         return "<{} name={}>".format(self.__class__.__name__, repr(self.name))