Enforce ruff/pyupgrade rule UP032

UP032 Use f-string instead of `format` call

Author: DimitriPapadopoulos

pkg_resources/__init__.py

@@ -492,7 +492,7 @@ def compatible_platforms(provided: str | None, required: str | None) -> bool:
             provDarwin = darwinVersionString.match(provided)
             if provDarwin:
                 dversion = int(provDarwin.group(1))
-                macosversion = "{}.{}".format(reqMac.group(1), reqMac.group(2))
+                macosversion = f"{reqMac.group(1)}.{reqMac.group(2)}"
                 if (
                     dversion == 7
                     and macosversion >= "10.3"
@@ -1316,7 +1316,7 @@ def __iadd__(self, other: Distribution | Environment) -> Self:
                 for dist in other[project]:
                     self.add(dist)
         else:
-            raise TypeError("Can't add {!r} to environment".format(other))
+            raise TypeError(f"Can't add {other!r} to environment")
         return self
 
     def __add__(self, other: Distribution | Environment) -> Self:
@@ -1699,7 +1699,7 @@ def get_metadata(self, name: str) -> str:
         except UnicodeDecodeError as exc:
             # Include the path in the error message to simplify
             # troubleshooting, and without changing the exception type.
-            exc.reason += ' in {} file at path: {}'.format(name, path)
+            exc.reason += f' in {name} file at path: {path}'
             raise
 
     def get_metadata_lines(self, name: str) -> Iterator[str]:
@@ -2018,15 +2018,15 @@ def _zipinfo_name(self, fspath):
             return ''
         if fspath.startswith(self.zip_pre):
             return fspath[len(self.zip_pre) :]
-        raise AssertionError("{} is not a subpath of {}".format(fspath, self.zip_pre))
+        raise AssertionError(f"{fspath} is not a subpath of {self.zip_pre}")
 
     def _parts(self, zip_path):
         # Convert a zipfile subpath into an egg-relative path part list.
         # pseudo-fs path
         fspath = self.zip_pre + zip_path
         if fspath.startswith(self.egg_root + os.sep):
             return fspath[len(self.egg_root) + 1 :].split(os.sep)
-        raise AssertionError("{} is not a subpath of {}".format(fspath, self.egg_root))
+        raise AssertionError(f"{fspath} is not a subpath of {self.egg_root}")
 
     @property
     def zipinfo(self):
@@ -2729,15 +2729,15 @@ def __init__(
         self.dist = dist
 
     def __str__(self) -> str:
-        s = "{} = {}".format(self.name, self.module_name)
+        s = f"{self.name} = {self.module_name}"
         if self.attrs:
             s += ':' + '.'.join(self.attrs)
         if self.extras:
             s += ' [{}]'.format(','.join(self.extras))
         return s
 
     def __repr__(self) -> str:
-        return "EntryPoint.parse({!r})".format(str(self))
+        return f"EntryPoint.parse({str(self)!r})"
 
     @overload
     def load(
@@ -3049,9 +3049,7 @@ def version(self):
             version = self._get_version()
             if version is None:
                 path = self._get_metadata_path_for_display(self.PKG_INFO)
-                msg = ("Missing 'Version:' header and/or {} file at path: {}").format(
-                    self.PKG_INFO, path
-                )
+                msg = (f"Missing 'Version:' header and/or {self.PKG_INFO} file at path: {path}")
                 raise ValueError(msg, self) from e
 
             return version
@@ -3108,7 +3106,7 @@ def requires(self, extras: Iterable[str] = ()) -> list[Requirement]:
                 deps.extend(dm[safe_extra(ext)])
             except KeyError as e:
                 raise UnknownExtra(
-                    "{} has no such extra feature {!r}".format(self, ext)
+                    f"{self} has no such extra feature {ext!r}"
                 ) from e
         return deps
 
@@ -3150,19 +3148,15 @@ def activate(self, path: list[str] | None = None, replace: bool = False) -> None
 
     def egg_name(self):
         """Return what this distribution's standard .egg filename should be"""
-        filename = "{}-{}-py{}".format(
-            to_filename(self.project_name),
-            to_filename(self.version),
-            self.py_version or PY_MAJOR,
-        )
+        filename = f"{to_filename(self.project_name)}-{to_filename(self.version)}-py{self.py_version or PY_MAJOR}"
 
         if self.platform:
             filename += '-' + self.platform
         return filename
 
     def __repr__(self) -> str:
         if self.location:
-            return "{} ({})".format(self, self.location)
+            return f"{self} ({self.location})"
         else:
             return str(self)
 
@@ -3172,7 +3166,7 @@ def __str__(self) -> str:
         except ValueError:
             version = None
         version = version or "[unknown version]"
-        return "{} {}".format(self.project_name, version)
+        return f"{self.project_name} {version}"
 
     def __getattr__(self, attr: str):
         """Delegate all unrecognized public attributes to .metadata provider"""
@@ -3200,17 +3194,17 @@ def from_filename(
     def as_requirement(self):
         """Return a ``Requirement`` that matches this distribution exactly"""
         if isinstance(self.parsed_version, packaging.version.Version):
-            spec = "{}=={}".format(self.project_name, self.parsed_version)
+            spec = f"{self.project_name}=={self.parsed_version}"
         else:
-            spec = "{}==={}".format(self.project_name, self.parsed_version)
+            spec = f"{self.project_name}==={self.parsed_version}"
 
         return Requirement.parse(spec)
 
     def load_entry_point(self, group: str, name: str) -> _ResolvedEntryPoint:
         """Return the `name` entry point of `group` or raise ImportError"""
         ep = self.get_entry_info(group, name)
         if ep is None:
-            raise ImportError("Entry point {!r} not found".format((group, name)))
+            raise ImportError(f"Entry point {(group, name)!r} not found")
         return ep.load()
 
     @overload
@@ -3327,8 +3321,8 @@ def check_version_conflict(self):
             ):
                 continue
             issue_warning(
-                "Module {} was already imported from {}, but {} is being added"
-                " to sys.path".format(modname, fn, self.location),
+                f"Module {modname} was already imported from {fn}, but {self.location} is being added"
+                " to sys.path",
             )
 
     def has_version(self) -> bool:
@@ -3512,7 +3506,7 @@ def __hash__(self) -> int:
         return self.__hash
 
     def __repr__(self) -> str:
-        return "Requirement.parse({!r})".format(str(self))
+        return f"Requirement.parse({str(self)!r})"
 
     @staticmethod
     def parse(s: str | Iterable[str]) -> Requirement:

pkg_resources/tests/test_pkg_resources.py

@@ -214,8 +214,8 @@ def test_get_metadata__bad_utf8(tmpdir):
         "codec can't decode byte 0xe9 in position 1: "
         'invalid continuation byte in METADATA file at path: '
     )
-    assert expected in actual, 'actual: {}'.format(actual)
-    assert actual.endswith(metadata_path), 'actual: {}'.format(actual)
+    assert expected in actual, f'actual: {actual}'
+    assert actual.endswith(metadata_path), f'actual: {actual}'
 
 
 def make_distribution_no_version(tmpdir, basename):
@@ -252,12 +252,10 @@ def test_distribution_version_missing(
     """
     Test Distribution.version when the "Version" header is missing.
     """
-    basename = 'foo.{}'.format(suffix)
+    basename = f'foo.{suffix}'
     dist, dist_dir = make_distribution_no_version(tmpdir, basename)
 
-    expected_text = ("Missing 'Version:' header and/or {} file at path: ").format(
-        expected_filename
-    )
+    expected_text = (f"Missing 'Version:' header and/or {expected_filename} file at path: ")
     metadata_path = os.path.join(dist_dir, expected_filename)
 
     # Now check the exception raised when the "version" attribute is accessed.

ruff.toml

@@ -35,7 +35,6 @@ ignore = [
 	"TRY003", # raise-vanilla-args, avoid multitude of exception classes
 	"TRY301", # raise-within-try, it's handy
 	"UP015", # redundant-open-modes, explicit is preferred
-	"UP032", # temporarily disabled
 	"UP038", # Using `X | Y` in `isinstance` call is slower and more verbose https://github.com/astral-sh/ruff/issues/7871
 	# Only enforcing return type annotations for public functions
 	"ANN202", # missing-return-type-private-function

setuptools/__init__.py

@@ -182,7 +182,7 @@ def _ensure_stringlike(self, option, what, default=None):
             return default
         elif not isinstance(val, str):
             raise DistutilsOptionError(
-                "'{}' must be a {} (got `{}`)".format(option, what, val)
+                f"'{option}' must be a {what} (got `{val}`)"
             )
         return val
 
@@ -210,7 +210,7 @@ def ensure_string_list(self, option: str) -> None:
                 ok = False
             if not ok:
                 raise DistutilsOptionError(
-                    "'{}' must be a list of strings (got {!r})".format(option, val)
+                    f"'{option}' must be a list of strings (got {val!r})"
                 )
 
     @overload

setuptools/_core_metadata.py

@@ -150,7 +150,7 @@ def write_pkg_file(self, file):  # noqa: C901  # is too complex (14)  # FIXME
     version = self.get_metadata_version()
 
     def write_field(key, value):
-        file.write("{}: {}\n".format(key, value))
+        file.write(f"{key}: {value}\n")
 
     write_field('Metadata-Version', str(version))
     write_field('Name', self.get_name())
@@ -209,7 +209,7 @@ def write_field(key, value):
 
     long_description = self.get_long_description()
     if long_description:
-        file.write("\n{}".format(long_description))
+        file.write(f"\n{long_description}")
         if not long_description.endswith("\n"):
             file.write("\n")
 

setuptools/_imp.py

@@ -29,7 +29,7 @@ def find_module(module, paths=None):
     """Just like 'imp.find_module()', but with package support"""
     spec = find_spec(module, paths)
     if spec is None:
-        raise ImportError("Can't find {}".format(module))
+        raise ImportError(f"Can't find {module}")
     if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
         spec = importlib.util.spec_from_loader('__init__.py', spec.loader)
 
@@ -76,12 +76,12 @@ def find_module(module, paths=None):
 def get_frozen_object(module, paths=None):
     spec = find_spec(module, paths)
     if not spec:
-        raise ImportError("Can't find {}".format(module))
+        raise ImportError(f"Can't find {module}")
     return spec.loader.get_code(module)
 
 
 def get_module(module, paths, info):
     spec = find_spec(module, paths)
     if not spec:
-        raise ImportError("Can't find {}".format(module))
+        raise ImportError(f"Can't find {module}")
     return module_from_spec(spec)

setuptools/archive_util.py

@@ -62,7 +62,7 @@ def unpack_archive(
         else:
             return
     else:
-        raise UnrecognizedFormat("Not a recognized archive type: {}".format(filename))
+        raise UnrecognizedFormat(f"Not a recognized archive type: {filename}")
 
 
 def unpack_directory(filename, extract_dir, progress_filter=default_filter) -> None:
@@ -71,7 +71,7 @@ def unpack_directory(filename, extract_dir, progress_filter=default_filter) -> N
     Raises ``UnrecognizedFormat`` if `filename` is not a directory
     """
     if not os.path.isdir(filename):
-        raise UnrecognizedFormat("{} is not a directory".format(filename))
+        raise UnrecognizedFormat(f"{filename} is not a directory")
 
     paths = {
         filename: ('', extract_dir),
@@ -101,7 +101,7 @@ def unpack_zipfile(filename, extract_dir, progress_filter=default_filter) -> Non
     """
 
     if not zipfile.is_zipfile(filename):
-        raise UnrecognizedFormat("{} is not a zip file".format(filename))
+        raise UnrecognizedFormat(f"{filename} is not a zip file")
 
     with zipfile.ZipFile(filename) as z:
         _unpack_zipfile_obj(z, extract_dir, progress_filter)
@@ -198,7 +198,7 @@ def unpack_tarfile(filename, extract_dir, progress_filter=default_filter) -> boo
         tarobj = tarfile.open(filename)
     except tarfile.TarError as e:
         raise UnrecognizedFormat(
-            "{} is not a compressed or uncompressed tar file".format(filename)
+            f"{filename} is not a compressed or uncompressed tar file"
         ) from e
 
     for member, final_dst in _iter_open_tar(

setuptools/command/alias.py

@@ -55,7 +55,7 @@ def run(self) -> None:
                 print("setup.py alias", format_alias(alias, aliases))
                 return
             else:
-                print("No alias definition found for {!r}".format(alias))
+                print(f"No alias definition found for {alias!r}")
                 return
         else:
             alias = self.args[0]
@@ -73,5 +73,5 @@ def format_alias(name, aliases):
     elif source == config_file('local'):
         source = ''
     else:
-        source = '--filename={!r}'.format(source)
+        source = f'--filename={source!r}'
     return source + name + ' ' + command

setuptools/command/bdist_egg.py

@@ -264,7 +264,7 @@ def zap_pyfiles(self):
                     m = re.match(pattern, name)
                     path_new = os.path.join(base, os.pardir, m.group('name') + '.pyc')
                     log.info(
-                        "Renaming file from [{}] to [{}]".format(path_old, path_new)
+                        f"Renaming file from [{path_old}] to [{path_new}]"
                     )
                     try:
                         os.remove(path_new)

setuptools/command/build_clib.py

@@ -29,9 +29,9 @@ def build_libraries(self, libraries) -> None:
             sources = build_info.get('sources')
             if sources is None or not isinstance(sources, (list, tuple)):
                 raise DistutilsSetupError(
-                    "in 'libraries' option (library '{}'), "
+                    f"in 'libraries' option (library '{lib_name}'), "
                     "'sources' must be present and must be "
-                    "a list of source filenames".format(lib_name)
+                    "a list of source filenames"
                 )
             sources = sorted(list(sources))
 
@@ -43,9 +43,9 @@ def build_libraries(self, libraries) -> None:
             obj_deps = build_info.get('obj_deps', dict())
             if not isinstance(obj_deps, dict):
                 raise DistutilsSetupError(
-                    "in 'libraries' option (library '{}'), "
+                    f"in 'libraries' option (library '{lib_name}'), "
                     "'obj_deps' must be a dictionary of "
-                    "type 'source: list'".format(lib_name)
+                    "type 'source: list'"
                 )
             dependencies = []
 
@@ -54,9 +54,9 @@ def build_libraries(self, libraries) -> None:
             global_deps = obj_deps.get('', list())
             if not isinstance(global_deps, (list, tuple)):
                 raise DistutilsSetupError(
-                    "in 'libraries' option (library '{}'), "
+                    f"in 'libraries' option (library '{lib_name}'), "
                     "'obj_deps' must be a dictionary of "
-                    "type 'source: list'".format(lib_name)
+                    "type 'source: list'"
                 )
 
             # Build the list to be used by newer_pairwise_group
@@ -67,9 +67,9 @@ def build_libraries(self, libraries) -> None:
                 extra_deps = obj_deps.get(source, list())
                 if not isinstance(extra_deps, (list, tuple)):
                     raise DistutilsSetupError(
-                        "in 'libraries' option (library '{}'), "
+                        f"in 'libraries' option (library '{lib_name}'), "
                         "'obj_deps' must be a dictionary of "
-                        "type 'source: list'".format(lib_name)
+                        "type 'source: list'"
                     )
                 src_deps.extend(extra_deps)
                 dependencies.append(src_deps)