mypy: use more f-strings

mypy/build.py

@@ -665,7 +665,7 @@ def dump_stats(self) -> None:
  if self.options.dump_build_stats:
  print("Stats:")
  for key, value in sorted(self.stats_summary().items()):
- print("{:24}{}".format(key + ":", value))
+ print(f"{key + ':':24}{value}")
 
  def use_fine_grained_cache(self) -> bool:
  return self.cache_enabled and self.options.use_fine_grained_cache
@@ -1083,7 +1083,7 @@ def read_deps_cache(manager: BuildManager,
  except FileNotFoundError:
  matched = False
  if not matched:
- manager.log('Invalid or missing fine-grained deps cache: {}'.format(meta['path']))
+ manager.log(f"Invalid or missing fine-grained deps cache: {meta['path']}")
  return None
 
  return module_deps_metas
@@ -1485,8 +1485,7 @@ def write_cache(id: str, path: str, tree: MypyFile,
 
  # Obtain file paths.
  meta_json, data_json, _ = get_cache_names(id, path, manager.options)
- manager.log('Writing {} {} {} {}'.format(
- id, path, meta_json, data_json))
+ manager.log(f'Writing {id} {path} {meta_json} {data_json}')
 
  # Update tree.path so that in bazel mode it's made relative (since
  # sometimes paths leak out).
@@ -1590,7 +1589,7 @@ def delete_cache(id: str, path: str, manager: BuildManager) -> None:
  # tracked separately.
  meta_path, data_path, _ = get_cache_names(id, path, manager.options)
  cache_paths = [meta_path, data_path]
- manager.log('Deleting {} {} {}'.format(id, path, " ".join(x for x in cache_paths if x)))
+ manager.log(f"Deleting {id} {path} {' '.join(x for x in cache_paths if x)}")
 
  for filename in cache_paths:
  try:
@@ -2490,7 +2489,7 @@ def find_module_and_diagnose(manager: BuildManager,
  and not options.custom_typeshed_dir):
  raise CompileError([
  f'mypy: "{os.path.relpath(result)}" shadows library module "{id}"',
- 'note: A user-defined top-level module with name "%s" is not supported' % id
+ f'note: A user-defined top-level module with name "{id}" is not supported'
  ])
  return (result, follow_imports)
  else:
@@ -2523,7 +2522,7 @@ def find_module_and_diagnose(manager: BuildManager,
  # If we can't find a root source it's always fatal.
  # TODO: This might hide non-fatal errors from
  # root sources processed earlier.
- raise CompileError(["mypy: can't find module '%s'" % id])
+ raise CompileError([f"mypy: can't find module '{id}'"])
  else:
  raise ModuleNotFound
 
@@ -2670,21 +2669,21 @@ def log_configuration(manager: BuildManager, sources: List[BuildSource]) -> None
  ]
 
  for conf_name, conf_value in configuration_vars:
- manager.log("{:24}{}".format(conf_name + ":", conf_value))
+ manager.log(f"{conf_name + ':':24}{conf_value}")
 
  for source in sources:
- manager.log("{:24}{}".format("Found source:", source))
+ manager.log(f"{'Found source:':24}{source}")
 
  # Complete list of searched paths can get very long, put them under TRACE
  for path_type, paths in manager.search_paths._asdict().items():
  if not paths:
- manager.trace("No %s" % path_type)
+ manager.trace(f"No {path_type}")
  continue
 
- manager.trace("%s:" % path_type)
+ manager.trace(f"{path_type}:")
 
  for pth in paths:
- manager.trace(" %s" % pth)
+ manager.trace(f" {pth}")
 
 
 # The driver
@@ -2720,7 +2719,7 @@ def dispatch(sources: List[BuildSource],
  if not graph:
  print("Nothing to do?!", file=stdout)
  return graph
- manager.log("Loaded graph with %d nodes (%.3f sec)" % (len(graph), t1 - t0))
+ manager.log(f"Loaded graph with {len(graph)} nodes ({t1 - t0:.3f} sec)")
  if manager.options.dump_graph:
  dump_graph(graph, stdout)
  return graph
@@ -3009,7 +3008,7 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
  scc.append('builtins')
  if manager.options.verbosity >= 2:
  for id in scc:
- manager.trace("Priorities for %s:" % id,
+ manager.trace(f"Priorities for {id}:",
  " ".join("%s:%d" % (x, graph[id].priorities[x])
  for x in graph[id].dependencies
  if x in ascc and x in graph[id].priorities))
@@ -3059,19 +3058,19 @@ def process_graph(graph: Graph, manager: BuildManager) -> None:
  # (on some platforms).
  if oldest_in_scc < newest_in_deps:
  fresh = False
- fresh_msg = "out of date by %.0f seconds" % (newest_in_deps - oldest_in_scc)
+ fresh_msg = f"out of date by {newest_in_deps - oldest_in_scc:.0f} seconds"
  else:
  fresh_msg = "fresh"
  elif undeps:
- fresh_msg = "stale due to changed suppression (%s)" % " ".join(sorted(undeps))
+ fresh_msg = f"stale due to changed suppression ({' '.join(sorted(undeps))})"
  elif stale_scc:
  fresh_msg = "inherently stale"
  if stale_scc != ascc:
- fresh_msg += " (%s)" % " ".join(sorted(stale_scc))
+ fresh_msg += f" ({' '.join(sorted(stale_scc))})"
  if stale_deps:
- fresh_msg += " with stale deps (%s)" % " ".join(sorted(stale_deps))
+ fresh_msg += f" with stale deps ({' '.join(sorted(stale_deps))})"
  else:
- fresh_msg = "stale due to deps (%s)" % " ".join(sorted(stale_deps))
+ fresh_msg = f"stale due to deps ({' '.join(sorted(stale_deps))})"
 
  # Initialize transitive_error for all SCC members from union
  # of transitive_error of dependencies.
@@ -3371,7 +3370,7 @@ def topsort(data: Dict[T, Set[T]]) -> Iterable[Set[T]]:
  data = {item: (dep - ready)
  for item, dep in data.items()
  if item not in ready}
- assert not data, "A cyclic dependency exists amongst %r" % data
+ assert not data, f"A cyclic dependency exists amongst {data!r}"
 
 
 def missing_stubs_file(cache_dir: str) -> str:
@@ -3388,7 +3387,7 @@ def record_missing_stub_packages(cache_dir: str, missing_stub_packages: Set[str]
  if missing_stub_packages:
  with open(fnam, 'w') as f:
  for pkg in sorted(missing_stub_packages):
- f.write('%s\n' % pkg)
+ f.write(f'{pkg}\n')
  else:
  if os.path.isfile(fnam):
  os.remove(fnam)

mypy/checker.py

@@ -886,7 +886,7 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
  self.msg.unimported_type_becomes_any("Return type", ret_type, fdef)
  for idx, arg_type in enumerate(fdef.type.arg_types):
  if has_any_from_unimported_type(arg_type):
- prefix = f"Argument {idx + 1} to \"{fdef.name}\""
+ prefix = f'Argument {idx + 1} to "{fdef.name}"'
  self.msg.unimported_type_becomes_any(prefix, arg_type, fdef)
  check_for_explicit_any(fdef.type, self.options, self.is_typeshed_stub,
  self.msg, context=fdef)
@@ -1918,9 +1918,7 @@ def check_final_enum(self, defn: ClassDef, base: TypeInfo) -> None:
  for sym in base.names.values():
  if self.is_final_enum_value(sym):
  self.fail(
- 'Cannot extend enum with existing members: "{}"'.format(
- base.name,
- ),
+ f'Cannot extend enum with existing members: "{base.name}"',
  defn,
  )
  break
@@ -2571,7 +2569,7 @@ def check_compatibility_super(self, lvalue: RefExpr, lvalue_type: Optional[Type]
  return self.check_subtype(compare_type, base_type, rvalue,
  message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
  'expression has type',
- 'base class "%s" defined the type as' % base.name,
+ f'base class "{base.name}" defined the type as',
  code=codes.ASSIGNMENT)
  return True
 

mypy/checkexpr.py

@@ -263,7 +263,7 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
  result = self.object_type()
  else:
  if isinstance(node, PlaceholderNode):
- assert False, 'PlaceholderNode %r leaked to checker' % node.fullname
+ assert False, f'PlaceholderNode {node.fullname!r} leaked to checker'
  # Unknown reference; use any type implicitly to avoid
  # generating extra type errors.
  result = AnyType(TypeOfAny.from_error)

mypy/checkstrformat.py

@@ -718,7 +718,7 @@ def check_mapping_str_interpolation(self, specifiers: List[ConversionSpecifier],
  self.chk.check_subtype(rep_type, expected_type, replacements,
  message_registry.INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION,
  'expression has type',
- 'placeholder with key \'%s\' has type' % specifier.key,
+ f'placeholder with key \'{specifier.key}\' has type',
  code=codes.STRING_FORMATTING)
  if specifier.conv_type == 's':
  self.check_s_special_cases(expr, rep_type, expr)

mypy/config_parser.py

@@ -211,10 +211,10 @@ def parse_config_file(options: Options, set_strict_flags: Callable[[], None],
 
  if 'mypy' not in parser:
  if filename or file_read not in defaults.SHARED_CONFIG_FILES:
- print("%s: No [mypy] section in config file" % file_read, file=stderr)
+ print(f"{file_read}: No [mypy] section in config file", file=stderr)
  else:
  section = parser['mypy']
- prefix = '{}: [{}]: '.format(file_read, 'mypy')
+ prefix = f"{file_read}: [mypy]: "
  updates, report_dirs = parse_section(
  prefix, options, set_strict_flags, section, config_types, stderr)
  for k, v in updates.items():
@@ -322,7 +322,7 @@ def destructure_overrides(toml_data: Dict[str, Any]) -> Dict[str, Any]:
  for module in modules:
  module_overrides = override.copy()
  del module_overrides['module']
- old_config_name = 'mypy-%s' % module
+ old_config_name = f'mypy-{module}'
  if old_config_name not in result:
  result[old_config_name] = module_overrides
  else:
@@ -447,7 +447,7 @@ def convert_to_boolean(value: Optional[Any]) -> bool:
  if not isinstance(value, str):
  value = str(value)
  if value.lower() not in configparser.RawConfigParser.BOOLEAN_STATES:
- raise ValueError('Not a boolean: %s' % value)
+ raise ValueError(f'Not a boolean: {value}')
  return configparser.RawConfigParser.BOOLEAN_STATES[value.lower()]
 
 
@@ -552,7 +552,7 @@ def get_config_module_names(filename: Optional[str], modules: List[str]) -> str:
  return ''
 
  if not is_toml(filename):
- return ", ".join("[mypy-%s]" % module for module in modules)
+ return ", ".join(f"[mypy-{module}]" for module in modules)
 
  return "module = ['%s']" % ("', '".join(sorted(modules)))
 

mypy/dmypy/client.py

@@ -273,7 +273,7 @@ def do_run(args: argparse.Namespace) -> None:
  response = request(args.status_file, 'run', version=__version__, args=args.flags)
  # If the daemon signals that a restart is necessary, do it
  if 'restart' in response:
- print('Restarting: {}'.format(response['restart']))
+ print(f"Restarting: {response['restart']}")
  restart_server(args, allow_sources=True)
  response = request(args.status_file, 'run', version=__version__, args=args.flags)
 
@@ -300,7 +300,7 @@ def do_status(args: argparse.Namespace) -> None:
  if args.verbose or 'error' in response:
  show_stats(response)
  if 'error' in response:
- fail("Daemon is stuck; consider %s kill" % sys.argv[0])
+ fail(f"Daemon is stuck; consider {sys.argv[0]} kill")
  print("Daemon is up and running")
 
 
@@ -311,7 +311,7 @@ def do_stop(args: argparse.Namespace) -> None:
  response = request(args.status_file, 'stop', timeout=5)
  if 'error' in response:
  show_stats(response)
- fail("Daemon is stuck; consider %s kill" % sys.argv[0])
+ fail(f"Daemon is stuck; consider {sys.argv[0]} kill")
  else:
  print("Daemon stopped")
 
@@ -389,7 +389,7 @@ def check_output(response: Dict[str, Any], verbose: bool,
  try:
  out, err, status_code = response['out'], response['err'], response['status']
  except KeyError:
- fail("Response: %s" % str(response))
+ fail(f"Response: {str(response)}")
  sys.stdout.write(out)
  sys.stdout.flush()
  sys.stderr.write(err)

mypy/dmypy_server.py

@@ -264,7 +264,7 @@ def run_command(self, command: str, data: Dict[str, object]) -> Dict[str, object
  key = 'cmd_' + command
  method = getattr(self.__class__, key, None)
  if method is None:
- return {'error': "Unrecognized command '%s'" % command}
+ return {'error': f"Unrecognized command '{command}'"}
  else:
  if command not in {'check', 'recheck', 'run'}:
  # Only the above commands use some error formatting.

mypy/dmypy_util.py

@@ -27,5 +27,5 @@ def receive(connection: IPCBase) -> Any:
  except Exception as e:
  raise OSError("Data received is not valid JSON") from e
  if not isinstance(data, dict):
- raise OSError("Data received is not a dict (%s)" % str(type(data)))
+ raise OSError(f"Data received is not a dict ({type(data)})")
  return data

mypy/fastparse.py

@@ -56,7 +56,7 @@
  if sys.version_info >= (3, 8):
  import ast as ast3
  assert 'kind' in ast3.Constant._fields, \
- "This 3.8.0 alpha (%s) is too old; 3.8.0a3 required" % sys.version.split()[0]
+ f"This 3.8.0 alpha ({sys.version.split()[0]}) is too old; 3.8.0a3 required"
  # TODO: Num, Str, Bytes, NameConstant, Ellipsis are deprecated in 3.8.
  # TODO: Index, ExtSlice are deprecated in 3.9.
  from ast import (

mypy/main.py

@@ -791,9 +791,9 @@ def add_invertible_flag(flag: str,
  description='Generate a report in the specified format.')
  for report_type in sorted(defaults.REPORTER_NAMES):
  if report_type not in {'memory-xml'}:
- report_group.add_argument('--%s-report' % report_type.replace('_', '-'),
+ report_group.add_argument(f"--{report_type.replace('_', '-')}-report",
  metavar='DIR',
- dest='special-opts:%s_report' % report_type)
+ dest=f'special-opts:{report_type}_report')
 
  other_group = parser.add_argument_group(
  title='Miscellaneous')
@@ -918,7 +918,7 @@ def add_invertible_flag(flag: str,
  # Don't explicitly test if "config_file is not None" for this check.
  # This lets `--config-file=` (an empty string) be used to disable all config files.
  if config_file and not os.path.exists(config_file):
- parser.error("Cannot find config file '%s'" % config_file)
+ parser.error(f"Cannot find config file '{config_file}'")
 
  options = Options()
 
@@ -989,8 +989,7 @@ def set_strict_flags() -> None:
 
  invalid_codes = (enabled_codes | disabled_codes) - valid_error_codes
  if invalid_codes:
- parser.error("Invalid error code(s): %s" %
- ', '.join(sorted(invalid_codes)))
+ parser.error(f"Invalid error code(s): {', '.join(sorted(invalid_codes))}")
 
  options.disabled_error_codes |= {error_codes[code] for code in disabled_codes}
  options.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
@@ -1090,17 +1089,17 @@ def process_package_roots(fscache: Optional[FileSystemCache],
  package_root = []
  for root in options.package_root:
  if os.path.isabs(root):
- parser.error("Package root cannot be absolute: %r" % root)
+ parser.error(f"Package root cannot be absolute: {root!r}")
  drive, root = os.path.splitdrive(root)
  if drive and drive != current_drive:
- parser.error("Package root must be on current drive: %r" % (drive + root))
+ parser.error(f"Package root must be on current drive: {drive + root!r}")
  # Empty package root is always okay.
  if root:
  root = os.path.relpath(root) # Normalize the heck out of it.
  if not root.endswith(os.sep):
  root = root + os.sep
  if root.startswith(dotdotslash):
- parser.error("Package root cannot be above current directory: %r" % root)
+ parser.error(f"Package root cannot be above current directory: {root!r}")
  if root in trivial_paths:
  root = ''
  package_root.append(root)
@@ -1119,9 +1118,9 @@ def process_cache_map(parser: argparse.ArgumentParser,
  for i in range(0, n, 3):
  source, meta_file, data_file = special_opts.cache_map[i:i + 3]
  if source in options.cache_map:
- parser.error("Duplicate --cache-map source %s)" % source)
+ parser.error(f"Duplicate --cache-map source {source})")
  if not source.endswith('.py') and not source.endswith('.pyi'):
- parser.error("Invalid --cache-map source %s (triple[0] must be *.py[i])" % source)
+ parser.error(f"Invalid --cache-map source {source} (triple[0] must be *.py[i])")
  if not meta_file.endswith('.meta.json'):
  parser.error("Invalid --cache-map meta_file %s (triple[1] must be *.meta.json)" %
  meta_file)
@@ -1140,7 +1139,7 @@ def maybe_write_junit_xml(td: float, serious: bool, messages: List[str], options
 
 def fail(msg: str, stderr: TextIO, options: Options) -> NoReturn:
  """Fail with a serious error."""
- stderr.write('%s\n' % msg)
+ stderr.write(f'{msg}\n')
  maybe_write_junit_xml(0.0, serious=True, messages=[msg], options=options)
  sys.exit(2)
 

mypy/memprofile.py

@@ -33,23 +33,23 @@ def collect_memory_stats() -> Tuple[Dict[str, int],
  n = type(obj).__name__
  if hasattr(obj, '__dict__'):
  # Keep track of which class a particular __dict__ is associated with.
- inferred[id(obj.__dict__)] = '%s (__dict__)' % n
+ inferred[id(obj.__dict__)] = f'{n} (__dict__)'
  if isinstance(obj, (Node, Type)): # type: ignore
  if hasattr(obj, '__dict__'):
  for x in obj.__dict__.values():
  if isinstance(x, list):
  # Keep track of which node a list is associated with.
- inferred[id(x)] = '%s (list)' % n
+ inferred[id(x)] = f'{n} (list)'
  if isinstance(x, tuple):
  # Keep track of which node a list is associated with.
- inferred[id(x)] = '%s (tuple)' % n
+ inferred[id(x)] = f'{n} (tuple)'
 
  for k in get_class_descriptors(type(obj)):
  x = getattr(obj, k, None)
  if isinstance(x, list):
- inferred[id(x)] = '%s (list)' % n
+ inferred[id(x)] = f'{n} (list)'
  if isinstance(x, tuple):
- inferred[id(x)] = '%s (tuple)' % n
+ inferred[id(x)] = f'{n} (tuple)'
 
  freqs: Dict[str, int] = {}
  memuse: Dict[str, int] = {}