Apply ruff/pyupgrade rule UP032

UP032 Use f-string instead of `format` call

Author: DimitriPapadopoulos

distributed/cli/dask_ssh.py

@@ -189,11 +189,7 @@ def main(
     import distributed
 
     print("\n---------------------------------------------------------------")
-    print(
-        "                 Dask.distributed v{version}\n".format(
-            version=distributed.__version__
-        )
-    )
+    print(f"                 Dask.distributed v{distributed.__version__}\n")
     print(f"Worker nodes: {len(hostnames)}")
     for i, host in enumerate(hostnames):
         print(f"  {i}: {host}")

distributed/client.py

@@ -1121,9 +1121,7 @@ def __init__(
                 security = getattr(self.cluster, "security", None)
         elif address is not None and not isinstance(address, str):
             raise TypeError(
-                "Scheduler address must be a string or a Cluster instance, got {}".format(
-                    type(address)
-                )
+                f"Scheduler address must be a string or a Cluster instance, got {type(address)}"
             )
 
         # If connecting to an address and no explicit security is configured, attempt
@@ -1375,10 +1373,7 @@ def __repr__(self):
             return text
 
         elif self.scheduler is not None:
-            return "<{}: scheduler={!r}>".format(
-                self.__class__.__name__,
-                self.scheduler.address,
-            )
+            return f"<{self.__class__.__name__}: scheduler={self.scheduler.address!r}>"
         else:
             return f"<{self.__class__.__name__}: No scheduler connected>"
 
@@ -5892,8 +5887,8 @@ def count(self):
             return len(self.futures) + len(self.queue.queue)
 
     def __repr__(self):
-        return "<as_completed: waiting={} done={}>".format(
-            len(self.futures), len(self.queue.queue)
+        return (
+            f"<as_completed: waiting={len(self.futures)} done={len(self.queue.queue)}>"
         )
 
     def __iter__(self):

distributed/dashboard/components/nvml.py

@@ -151,9 +151,8 @@ def update(self):
             "escaped_worker": [url_escape(w) for w in worker],
         }
 
-        self.memory_figure.title.text = "GPU Memory: {} / {}".format(
-            format_bytes(sum(memory)),
-            format_bytes(memory_total),
+        self.memory_figure.title.text = (
+            f"GPU Memory: {format_bytes(sum(memory))} / {format_bytes(memory_total)}"
         )
         self.memory_figure.x_range.end = memory_max
 

distributed/deploy/old_ssh.py

@@ -208,16 +208,12 @@ def communicate():
 def start_scheduler(
     logdir, addr, port, ssh_username, ssh_port, ssh_private_key, remote_python=None
 ):
-    cmd = "{python} -m distributed.cli.dask_scheduler --port {port}".format(
-        python=remote_python or sys.executable, port=port
-    )
+    cmd = f"{remote_python or sys.executable} -m distributed.cli.dask_scheduler --port {port}"
 
     # Optionally re-direct stdout and stderr to a logfile
     if logdir is not None:
         cmd = f"mkdir -p {logdir} && {cmd}"
-        cmd += "&> {logdir}/dask_scheduler_{addr}:{port}.log".format(
-            addr=addr, port=port, logdir=logdir
-        )
+        cmd += f"&> {logdir}/dask_scheduler_{addr}:{port}.log"
 
     # Format output labels we can prepend to each line of output, and create
     # a 'status' key to keep track of jobs that terminate prematurely.
@@ -297,16 +293,12 @@ def start_worker(
     )
 
     if local_directory is not None:
-        cmd += " --local-directory {local_directory}".format(
-            local_directory=local_directory
-        )
+        cmd += f" --local-directory {local_directory}"
 
     # Optionally redirect stdout and stderr to a logfile
     if logdir is not None:
         cmd = f"mkdir -p {logdir} && {cmd}"
-        cmd += "&> {logdir}/dask_scheduler_{addr}.log".format(
-            addr=worker_addr, logdir=logdir
-        )
+        cmd += f"&> {logdir}/dask_scheduler_{worker_addr}.log"
 
     label = f"worker {worker_addr}"
 
@@ -402,9 +394,7 @@ def __init__(
             )
             print(
                 bcolors.WARNING + "Output will be redirected to logfiles "
-                'stored locally on individual worker nodes under "{logdir}".'.format(
-                    logdir=logdir
-                )
+                f'stored locally on individual worker nodes under "{logdir}".'
                 + bcolors.ENDC
             )
         self.logdir = logdir

distributed/deploy/ssh.py

@@ -137,15 +137,11 @@ async def start(self):
 
         result = await self.connection.run("uname")
         if result.exit_status == 0:
-            set_env = 'env DASK_INTERNAL_INHERIT_CONFIG="{}"'.format(
-                dask.config.serialize(dask.config.global_config)
-            )
+            set_env = f'env DASK_INTERNAL_INHERIT_CONFIG="{dask.config.serialize(dask.config.global_config)}"'
         else:
             result = await self.connection.run("cmd /c ver")
             if result.exit_status == 0:
-                set_env = "set DASK_INTERNAL_INHERIT_CONFIG={} &&".format(
-                    dask.config.serialize(dask.config.global_config)
-                )
+                set_env = f"set DASK_INTERNAL_INHERIT_CONFIG={dask.config.serialize(dask.config.global_config)} &&"
             else:
                 raise Exception(
                     "Worker failed to set DASK_INTERNAL_INHERIT_CONFIG variable "
@@ -237,15 +233,11 @@ async def start(self):
 
         result = await self.connection.run("uname")
         if result.exit_status == 0:
-            set_env = 'env DASK_INTERNAL_INHERIT_CONFIG="{}"'.format(
-                dask.config.serialize(dask.config.global_config)
-            )
+            set_env = f'env DASK_INTERNAL_INHERIT_CONFIG="{dask.config.serialize(dask.config.global_config)}"'
         else:
             result = await self.connection.run("cmd /c ver")
             if result.exit_status == 0:
-                set_env = "set DASK_INTERNAL_INHERIT_CONFIG={} &&".format(
-                    dask.config.serialize(dask.config.global_config)
-                )
+                set_env = f"set DASK_INTERNAL_INHERIT_CONFIG={dask.config.serialize(dask.config.global_config)} &&"
             else:
                 raise Exception(
                     "Scheduler failed to set DASK_INTERNAL_INHERIT_CONFIG variable "

distributed/http/proxy.py

@@ -97,8 +97,8 @@ def initialize(self, dask_server=None, extra=None):
 
         def get(self, port, host, proxied_path):
             worker_url = f"{host}:{port}/{proxied_path}"
-            msg = """
-                <p> Try navigating to <a href=http://{}>{}</a> for your worker dashboard </p>
+            msg = f"""
+                <p> Try navigating to <a href=http://{worker_url}>{worker_url}</a> for your worker dashboard </p>
 
                 <p>
                 Dask tried to proxy you to that page through your
@@ -116,10 +116,7 @@ def get(self, port, host, proxied_path):
                 but less common in production clusters.  Your IT administrators
                 will know more
                 </p>
-            """.format(
-                worker_url,
-                worker_url,
-            )
+            """
             self.write(msg)
 
 

distributed/scheduler.py

@@ -8552,44 +8552,33 @@ def profile_to_figure(state: object) -> object:
         import distributed
 
         # HTML
-        html = """
+        html = f"""
         <h1> Dask Performance Report </h1>
 
         <i> Select different tabs on the top for additional information </i>
 
-        <h2> Duration: {time} </h2>
+        <h2> Duration: {format_time(stop - start)} </h2>
         <h2> Tasks Information </h2>
         <ul>
-         <li> number of tasks: {ntasks} </li>
+         <li> number of tasks: {total_tasks} </li>
          {tasks_timings}
         </ul>
 
         <h2> Scheduler Information </h2>
         <ul>
-          <li> Address: {address} </li>
-          <li> Workers: {nworkers} </li>
-          <li> Threads: {threads} </li>
-          <li> Memory: {memory} </li>
-          <li> Dask Version: {dask_version} </li>
-          <li> Dask.Distributed Version: {distributed_version} </li>
+          <li> Address: {self.address} </li>
+          <li> Workers: {len(self.workers)} </li>
+          <li> Threads: {sum(ws.nthreads for ws in self.workers.values())} </li>
+          <li> Memory: {format_bytes(sum(ws.memory_limit for ws in self.workers.values()))} </li>
+          <li> Dask Version: {dask.__version__} </li>
+          <li> Dask.Distributed Version: {distributed.__version__} </li>
         </ul>
 
         <h2> Calling Code </h2>
         <pre>
 {code}
         </pre>
-        """.format(
-            time=format_time(stop - start),
-            ntasks=total_tasks,
-            tasks_timings=tasks_timings,
-            address=self.address,
-            nworkers=len(self.workers),
-            threads=sum(ws.nthreads for ws in self.workers.values()),
-            memory=format_bytes(sum(ws.memory_limit for ws in self.workers.values())),
-            code=code,
-            dask_version=dask.__version__,
-            distributed_version=distributed.__version__,
-        )
+        """
         html = Div(text=html, styles=_STYLES)
 
         html = TabPanel(child=html, title="Summary")

distributed/utils.py

@@ -246,8 +246,8 @@ def get_ip_interface(ifname):
     if ifname not in net_if_addrs:
         allowed_ifnames = list(net_if_addrs.keys())
         raise ValueError(
-            "{!r} is not a valid network interface. "
-            "Valid network interfaces are: {}".format(ifname, allowed_ifnames)
+            f"{ifname!r} is not a valid network interface. "
+            f"Valid network interfaces are: {allowed_ifnames}"
         )
 
     for info in net_if_addrs[ifname]: