Internal copy of GitHub PR #1237.

pyupgrade --py37-plus **/*.py

Python f-strings are shorter, easier to read, and faster. https://www.scivision.dev/python-f-string-speed

This PR touches both internal and external files, so I merged it directly, but
we also need to import it so that the internal changes aren't reverted the next
time we do an export.

PiperOrigin-RevId: 457566465

Author: rchen152

pytype/abstract/_base.py

@@ -456,6 +456,6 @@ def _compute_template(val: Any):
       template.extend(mro.MergeSequences(seqs))
     except ValueError as e:
       raise abstract_utils.GenericTypeError(
-          val, "Illegal type parameter order in class %s" % val.name) from e
+          val, f"Illegal type parameter order in class {val.name}") from e
 
   return template

pytype/abstract/_classes.py

@@ -160,7 +160,7 @@ def type_param_check(self):
     for t in self.template:
       if t.full_name in self.all_formal_type_parameters:
         raise abstract_utils.GenericTypeError(
-            self, "Conflicting value for TypeVar %s" % t.full_name)
+            self, f"Conflicting value for TypeVar {t.full_name}")
 
   def collect_inner_cls_types(self, max_depth=5):
     """Collect all the type parameters from nested classes."""
@@ -242,7 +242,7 @@ def _convert_slots(self, slots_var):
     for s in names:
       if not isinstance(s, str):
         self.ctx.errorlog.bad_slots(self.ctx.vm.frames,
-                                    "Invalid __slot__ entry: %r" % str(s))
+                                    f"Invalid __slot__ entry: {str(s)!r}")
         return None
     return tuple(self._mangle(s) for s in names)
 
@@ -272,7 +272,7 @@ def instantiate(self, node, container=None):
       return super().instantiate(node, container)
 
   def __repr__(self):
-    return "InterpreterClass(%s)" % self.name
+    return f"InterpreterClass({self.name})"
 
   def __contains__(self, name):
     if name in self.members:
@@ -459,7 +459,7 @@ def _convert_member(self, name, member, subst=None):
     elif isinstance(member, pytd.Class):
       return self.ctx.convert.constant_to_var(member, subst=subst, node=node)
     else:
-      raise AssertionError("Invalid class member %s" % pytd_utils.Print(member))
+      raise AssertionError(f"Invalid class member {pytd_utils.Print(member)}")
 
   def _new_instance(self, container, node, args):
     if self.full_name == "builtins.tuple" and args.is_empty():
@@ -478,7 +478,7 @@ def instantiate(self, node, container=None):
         abstract_utils.AsInstance(self.pytd_cls), {}, node)
 
   def __repr__(self):
-    return "PyTDClass(%s)" % self.name
+    return f"PyTDClass({self.name})"
 
   def __contains__(self, name):
     return name in self._member_map
@@ -593,7 +593,7 @@ def __init__(self, base_cls, formal_type_parameters, ctx, template=None):
     self.type_param_check()
 
   def __repr__(self):
-    return "ParameterizedClass(cls=%r params=%s)" % (
+    return "ParameterizedClass(cls={!r} params={})".format(
         self.base_cls,
         self._formal_type_parameters)
 
@@ -787,7 +787,7 @@ def __init__(self, base_cls, formal_type_parameters, ctx, template=None):
     self.num_args = len(self.formal_type_parameters) - 2
 
   def __repr__(self):
-    return "CallableClass(%s)" % self.formal_type_parameters
+    return f"CallableClass({self.formal_type_parameters})"
 
   def get_formal_type_parameters(self):
     return {
@@ -848,7 +848,7 @@ def __init__(self, instance, ctx, template=None):
     self._instance = instance
 
   def __repr__(self):
-    return "LiteralClass(%s)" % self._instance
+    return f"LiteralClass({self._instance})"
 
   def __eq__(self, other):
     if isinstance(other, LiteralClass):
@@ -895,7 +895,7 @@ def __init__(self, base_cls, formal_type_parameters, ctx, template=None):
     self.slots = ()  # tuples don't have any writable attributes
 
   def __repr__(self):
-    return "TupleClass(%s)" % self.formal_type_parameters
+    return f"TupleClass({self.formal_type_parameters})"
 
   def compute_mro(self):
     # ParameterizedClass removes the base PyTDClass(tuple) from the mro; add it

pytype/abstract/_function_base.py

@@ -134,7 +134,7 @@ def _match_views(self, node, args, alias_map, match_all_views):
         else:
           # Add the name of the caller if possible.
           if hasattr(self, "parent"):
-            e.name = "%s.%s" % (self.parent.name, e.name)
+            e.name = f"{self.parent.name}.{e.name}"
           if match_all_views or self.ctx.options.strict_parameter_checks:
             raise e
           error = e
@@ -344,7 +344,7 @@ def call(self, node, func, args, alias_map=None):
           # match_args will try to prepend the parent's name to the error name.
           # Overwrite it with _callself instead, which may be more exact.
           _, _, e.name = e.name.rpartition(".")
-        e.name = "%s.%s" % (self._callself.data[0].name, e.name)
+        e.name = f"{self._callself.data[0].name}.{e.name}"
       raise
     finally:
       if abstract_utils.func_name_is_class_init(self.name):
@@ -505,4 +505,4 @@ def __init__(self, ctx, iterable):
     self.iterable = iterable
 
   def __repr__(self):
-    return "splat(%r)" % self.iterable.data
+    return f"splat({self.iterable.data!r})"

pytype/abstract/_instance_base.py

@@ -123,7 +123,7 @@ def argcount(self, node):
       return 0
 
   def __repr__(self):
-    return "<%s [%r]>" % (self.name, self.cls)
+    return f"<{self.name} [{self.cls!r}]>"
 
   def _get_class(self):
     return self.ctx.convert.unsolvable

pytype/abstract/_instances.py

@@ -269,7 +269,7 @@ def str_of_constant(self, printer):
                         for val in self.pyval)
     if self.tuple_length == 1:
       content += ","
-    return "(%s)" % content
+    return f"({content})"
 
   def _unique_parameters(self):
     parameters = super()._unique_parameters()

pytype/abstract/_pytd_function.py

@@ -444,7 +444,7 @@ def _match_args_sequentially(self, node, args, alias_map, match_all_views):
         if e > error:
           # Add the name of the caller if possible.
           if hasattr(self, "parent"):
-            e.name = "%s.%s" % (self.parent.name, e.name)
+            e.name = f"{self.parent.name}.{e.name}"
           error = e
       else:
         matched_signatures.append((sig, arg_dict, subst))
@@ -729,8 +729,7 @@ def _collect_mutated_parameters(cls, typ, mutated_type):
         not isinstance(mutated_type, pytd.GenericType) or
         typ.base_type != mutated_type.base_type or
         not isinstance(typ.base_type, pytd.ClassType)):
-      raise ValueError("Unsupported mutation:\n%r ->\n%r" %
-                       (typ, mutated_type))
+      raise ValueError(f"Unsupported mutation:\n{typ!r} ->\n{mutated_type!r}")
     return [zip(mutated_type.base_type.cls.template, mutated_type.parameters)]
 
   def _get_mutation(self, node, arg_dict, subst, retvar, variable):

pytype/abstract/_typing.py

@@ -63,7 +63,7 @@ def _build_value(self, node, inner, ellipses):
     raise NotImplementedError(self.__class__.__name__)
 
   def __repr__(self):
-    return "AnnotationClass(%s)" % self.name
+    return f"AnnotationClass({self.name})"
 
   def _get_class(self):
     return self.ctx.convert.type_type
@@ -77,7 +77,7 @@ def __init__(self, name, ctx, base_cls):
     self.base_cls = base_cls
 
   def __repr__(self):
-    return "AnnotationContainer(%s)" % self.name
+    return f"AnnotationContainer({self.name})"
 
   def _sub_annotation(
       self, annot: _base.BaseValue, subst: Mapping[str, _base.BaseValue]
@@ -244,7 +244,7 @@ def _build_value(self, node, inner, ellipses):
           for k, v in imports.items():
             added_imports[k] |= v
 
-      expr = "%s[%s]" % (self.base_cls.expr, ", ".join(printed_params))
+      expr = f"{self.base_cls.expr}[{', '.join(printed_params)}]"
       annot = LateAnnotation(expr, self.base_cls.stack, self.ctx,
                              imports=added_imports)
       self.ctx.vm.late_annotations[self.base_cls.expr].append(annot)
@@ -365,8 +365,8 @@ def __hash__(self):
                  self.contravariant))
 
   def __repr__(self):
-    return "TypeParameter(%r, constraints=%r, bound=%r, module=%r)" % (
-        self.name, self.constraints, self.bound, self.module)
+    return ("TypeParameter({!r}, constraints={!r}, bound={!r}, module={!r})"
+            .format(self.name, self.constraints, self.bound, self.module))
 
   def instantiate(self, node, container=None):
     var = self.ctx.program.NewVariable()
@@ -385,8 +385,8 @@ def instantiate(self, node, container=None):
 
   def update_official_name(self, name):
     if self.name != name:
-      message = "TypeVar(%r) must be stored as %r, not %r" % (
-          self.name, self.name, name)
+      message = (f"TypeVar({self.name!r}) must be stored as {self.name!r}, "
+                 f"not {name!r}")
       self.ctx.errorlog.invalid_typevar(self.ctx.vm.frames, message)
 
   def call(self, node, func, args, alias_map=None):
@@ -410,7 +410,7 @@ def call(self, node, func, args, alias_map=None):
       return node, self.ctx.convert.empty.to_variable(self.ctx.root_node)
 
   def __repr__(self):
-    return "TypeParameterInstance(%r)" % self.name
+    return f"TypeParameterInstance({self.name!r})"
 
   def __eq__(self, other):
     if isinstance(other, type(self)):
@@ -448,7 +448,7 @@ def __repr__(self):
       self._printing = True
       printed_contents = ", ".join(repr(o) for o in self.options)
       self._printing = False
-    return "%s[%s]" % (self.name, printed_contents)
+    return f"{self.name}[{printed_contents}]"
 
   def __eq__(self, other):
     if isinstance(other, type(self)):
@@ -596,7 +596,7 @@ def unflatten_expr(self):
     return self.expr
 
   def __repr__(self):
-    return "LateAnnotation(%r, resolved=%r)" % (
+    return "LateAnnotation({!r}, resolved={!r})".format(
         self.expr, self._type if self.resolved else None)
 
   # __hash__ and __eq__ need to be explicitly defined for Python to use them in

pytype/abstract/abstract_utils.py

@@ -306,7 +306,7 @@ def _merge_type(t0, t1, name, cls):
   # t1 is a base of t0
   if t1 in t0.mro:
     return t0
-  raise GenericTypeError(cls, "Conflicting value for TypeVar %s" % name)
+  raise GenericTypeError(cls, f"Conflicting value for TypeVar {name}")
 
 
 def parse_formal_type_parameters(

pytype/abstract/class_mixin.py

@@ -417,7 +417,7 @@ def _call_method(self, node, value, method_name, args):
     node, method = self.ctx.attribute_handler.get_attribute(
         node, value.data, method_name, value)
     if method:
-      call_repr = "%s.%s(..._)" % (self.name, method_name)
+      call_repr = f"{self.name}.{method_name}(..._)"
       log.debug("calling %s", call_repr)
       node, ret = function.call_function(self.ctx, node, method, args)
       log.debug("%s returned %r", call_repr, ret)

pytype/abstract/function.py

@@ -372,8 +372,7 @@ def _print_default(self, name):
   def __repr__(self):
     args = ", ".join(self._yield_arguments())
     ret = self._print_annot("return")
-    return "def {name}({args}) -> {ret}".format(
-        name=self.name, args=args, ret=ret if ret else "Any")
+    return f"def {self.name}({args}) -> {ret if ret else 'Any'}"
 
   def get_first_arg(self, callargs):
     return callargs.get(self.param_names[0]) if self.param_names else None
@@ -902,8 +901,8 @@ def match_all_args(ctx, node, func, args):
           break
         else:
           raise AssertionError(
-              "Mismatched parameter %s not found in passed_args" %
-              arg_name) from e
+              f"Mismatched parameter {arg_name} not found in passed_args"
+          ) from e
       else:
         # This is not an InvalidParameters error.
         raise