Apply ruff/pyupgrade rule UP032

DimitriPapadopoulos · DimitriPapadopoulos · commit 8593ba1f7a93 · 2025-10-26T22:59:38.000+01:00
UP032 Use f-string instead of `format` call
diff --git a/examples/bench/echoclient.py b/examples/bench/echoclient.py
@@ -45,7 +45,7 @@
         addr = args.addr.split(':')
         addr[1] = int(addr[1])
         addr = tuple(addr)
-    print('will connect to: {}'.format(addr))
+    print(f'will connect to: {addr}')
 
     MSGSIZE = args.msize
     REQSIZE = MSGSIZE * args.mpr
diff --git a/examples/bench/echoserver.py b/examples/bench/echoserver.py
@@ -139,7 +139,7 @@ async def print_debug(loop):
         addr[1] = int(addr[1])
         addr = tuple(addr)
 
-    print('serving on: {}'.format(addr))
+    print(f'serving on: {addr}')
 
     server_context = None
     if args.ssl:
diff --git a/examples/bench/rlserver.py b/examples/bench/rlserver.py
@@ -71,7 +71,7 @@ async def print_debug(loop):
         addr = tuple(addr)
 
     print('readline performance test')
-    print('serving on: {}'.format(addr))
+    print(f'serving on: {addr}')
 
     print('using asyncio/streams')
     if unix:
diff --git a/setup.py b/setup.py
@@ -26,7 +26,7 @@
 MODULES_CFLAGS = [os.getenv('UVLOOP_OPT_CFLAGS', '-O2')]
 _ROOT = pathlib.Path(__file__).parent
 LIBUV_DIR = str(_ROOT / 'vendor' / 'libuv')
-LIBUV_BUILD_DIR = str(_ROOT / 'build' / 'libuv-{}'.format(MACHINE))
+LIBUV_BUILD_DIR = str(_ROOT / 'build' / f'libuv-{MACHINE}')
 
 
 def _libuv_build_env():
@@ -118,15 +118,12 @@ def finalize_options(self):
                 import Cython
             except ImportError:
                 raise RuntimeError(
-                    'please install {} to compile uvloop from source'.format(
-                        CYTHON_DEPENDENCY))
+                    f'please install {CYTHON_DEPENDENCY} to compile uvloop from source')
 
             cython_dep = pkg_resources.Requirement.parse(CYTHON_DEPENDENCY)
             if Cython.__version__ not in cython_dep:
                 raise RuntimeError(
-                    'uvloop requires {}, got Cython=={}'.format(
-                        CYTHON_DEPENDENCY, Cython.__version__
-                    ))
+                    f'uvloop requires {CYTHON_DEPENDENCY}, got Cython=={Cython.__version__}')
 
             from Cython.Build import cythonize
 
@@ -183,7 +180,7 @@ def build_libuv(self):
             njobs = len(os.sched_getaffinity(0))
         except AttributeError:
             njobs = os.cpu_count()
-        j_flag = '-j{}'.format(njobs or 1)
+        j_flag = f'-j{njobs or 1}'
         c_flag = "CFLAGS={}".format(env['CFLAGS'])
         subprocess.run(
             ['make', j_flag, c_flag],
diff --git a/tests/test_aiohttp.py b/tests/test_aiohttp.py
@@ -95,7 +95,7 @@ async def on_shutdown(app):
         async def client():
             async with aiohttp.ClientSession() as client:
                 async with client.ws_connect(
-                        'http://127.0.0.1:{}'.format(port)) as ws:
+                        f'http://127.0.0.1:{port}') as ws:
                     await ws.send_str("hello")
                     async for msg in ws:
                         assert msg.data == "hello"
diff --git a/tests/test_context.py b/tests/test_context.py
@@ -61,9 +61,7 @@ def get_buffer(self, sizehint):
         if self.buffered_ctx is None:
             self.buffered_ctx = self.cvar.get()
         elif self.cvar.get() != self.buffered_ctx:
-            self.data_received_fut.set_exception(ValueError("{} != {}".format(
-                self.buffered_ctx, self.cvar.get(),
-            )))
+            self.data_received_fut.set_exception(ValueError(f"{self.buffered_ctx} != {self.cvar.get()}"))
         return bytearray(65536)
 
     def buffer_updated(self, nbytes):
@@ -72,9 +70,7 @@ def buffer_updated(self, nbytes):
                 self.data_received_fut.set_result(self.cvar.get())
             else:
                 self.data_received_fut.set_exception(
-                    ValueError("{} != {}".format(
-                        self.buffered_ctx, self.cvar.get(),
-                    ))
+                    ValueError(f"{self.buffered_ctx} != {self.cvar.get()}")
                 )
 
 
@@ -202,16 +198,16 @@ def fut_on_done(fut):
             for j in range(2):
                 fut = self.loop.create_future()
                 fut.add_done_callback(fut_on_done)
-                cvar.set('yes{}'.format(j))
+                cvar.set(f'yes{j}')
                 self.loop.call_soon(fut.set_result, None)
                 await fut
-                self.assertEqual(cvar.get(), 'yes{}'.format(j))
+                self.assertEqual(cvar.get(), f'yes{j}')
 
                 for i in range(3):
                     # Test that task passed its context to add_done_callback:
-                    cvar.set('yes{}-{}'.format(i, j))
+                    cvar.set(f'yes{i}-{j}')
                     await asyncio.sleep(0.001)
-                    self.assertEqual(cvar.get(), 'yes{}-{}'.format(i, j))
+                    self.assertEqual(cvar.get(), f'yes{i}-{j}')
 
         task = self.loop.create_task(main())
         self.loop.run_until_complete(task)
diff --git a/tests/test_process.py b/tests/test_process.py
@@ -192,7 +192,7 @@ async def test():
                 stdout=subprocess.PIPE)
 
             pid = proc.pid
-            expected_result = '{}\n'.format(pid).encode()
+            expected_result = f'{pid}\n'.encode()
 
             out, err = await proc.communicate()
             self.assertEqual(out, expected_result)
diff --git a/tests/test_process_spawning.py b/tests/test_process_spawning.py
@@ -100,8 +100,8 @@ def spawn_process():
                 t.start()
                 t.join(timeout=10.0)
                 if t.is_alive():
-                    raise Exception('process freeze detected at {}'
-                                    .format(iteration))
+                    raise Exception(f'process freeze detected at {iteration}'
+                                    )
 
             return True
 
diff --git a/tests/test_signals.py b/tests/test_signals.py
@@ -297,8 +297,7 @@ def handler_hup():
 
     def test_signals_invalid_signal(self):
         with self.assertRaisesRegex(RuntimeError,
-                                    'sig {} cannot be caught'.format(
-                                        signal.SIGKILL)):
+                                    f'sig {signal.SIGKILL} cannot be caught'):
 
             self.loop.add_signal_handler(signal.SIGKILL, lambda *a: None)
 
diff --git a/tests/test_sourcecode.py b/tests/test_sourcecode.py
@@ -33,7 +33,7 @@ def test_flake8(self):
                 output += '\n'
                 output += ex.stderr.decode()
                 raise AssertionError(
-                    'flake8 validation failed: {}\n{}'.format(ex, output)
+                    f'flake8 validation failed: {ex}\n{output}'
                 ) from None
 
     def test_mypy(self):
@@ -66,5 +66,5 @@ def test_mypy(self):
             output += '\n'
             output += ex.stderr.decode()
             raise AssertionError(
-                'mypy validation failed: {}\n{}'.format(ex, output)
+                f'mypy validation failed: {ex}\n{output}'
             ) from None
diff --git a/tests/test_tcp.py b/tests/test_tcp.py
@@ -2788,7 +2788,7 @@ async def test():
             except AssertionError as e:
                 self.assertEqual(str(e), 'ResourceWarning not triggered')
             else:
-                self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
+                self.fail(f'Unexpected ResourceWarning: {cm.warning}')
 
     def test_handshake_timeout_handler_leak(self):
         if self.implementation == 'asyncio':
diff --git a/tests/test_unix.py b/tests/test_unix.py
@@ -177,8 +177,7 @@ def test_create_unix_server_2(self):
                 f.write('x')
 
             with self.assertRaisesRegex(
-                    OSError, "Address '{}' is already in use".format(
-                        sock_name)):
+                    OSError, f"Address '{sock_name}' is already in use"):
 
                 self.loop.run_until_complete(
                     self.loop.create_unix_server(object, sock_name))
diff --git a/uvloop/__init__.py b/uvloop/__init__.py
@@ -58,7 +58,7 @@ async def wrapper():
 
             if not __asyncio.iscoroutine(main):
                 raise ValueError(
-                    "a coroutine was expected, got {!r}".format(main)
+                    f"a coroutine was expected, got {main!r}"
                 )
 
             loop = loop_factory()
diff --git a/uvloop/_testbase.py b/uvloop/_testbase.py
@@ -35,8 +35,7 @@ def __init__(self, name):
 
     def __setitem__(self, key, value):
         if key in self.data:
-            raise RuntimeError('duplicate test {}.{}'.format(
-                self.name, key))
+            raise RuntimeError(f'duplicate test {self.name}.{key}')
         super().__setitem__(key, value)
 
 
@@ -53,9 +52,8 @@ def __new__(mcls, name, bases, dct):
             for base in bases:
                 if hasattr(base, test_name):
                     raise RuntimeError(
-                        'duplicate test {}.{} (also defined in {} '
-                        'parent class)'.format(
-                            name, test_name, base.__name__))
+                        f'duplicate test {name}.{test_name} (also defined in {base.__name__} '
+                        'parent class)')
 
         return super().__new__(mcls, name, bases, dict(dct))
 
@@ -142,14 +140,14 @@ def tearDown(self):
                                   handle_name=h_name):
                     self.assertEqual(
                         h_cnt, 0,
-                        'alive {} after test'.format(h_name))
+                        f'alive {h_name} after test')
 
             for h_name, h_cnt in self.loop._debug_handles_total.items():
                 with self.subTest('Total/closed handles',
                                   handle_name=h_name):
                     self.assertEqual(
                         h_cnt, self.loop._debug_handles_closed[h_name],
-                        'total != closed for {}'.format(h_name))
+                        f'total != closed for {h_name}')
 
         asyncio.set_event_loop(None)
         asyncio.set_event_loop_policy(None)
@@ -389,7 +387,7 @@ def __getattr__(self, name):
         return getattr(self.__sock, name)
 
     def __repr__(self):
-        return '<{} {!r}>'.format(type(self).__name__, self.__sock)
+        return f'<{type(self).__name__} {self.__sock!r}>'
 
 
 class SocketThread(threading.Thread):
