diff --git a/gns3server/compute/base_node.py b/gns3server/compute/base_node.py
index 8bfbb70c7..033ef96d9 100644
--- a/gns3server/compute/base_node.py
+++ b/gns3server/compute/base_node.py
@@ -166,11 +166,7 @@ class BaseNode:
         if self._wrap_aux:
             self._internal_aux_port = self._manager.port_manager.get_free_tcp_port(self._project)
 
-        log.debug(
-            "{module}: {name} [{id}] initialized. Console port {console}".format(
-                module=self.manager.module_name, name=self.name, id=self.id, console=self._console
-            )
-        )
+        log.debug(f"{self.manager.module_name}: {self.name} [{self.id}] initialized. Console port {self._console}")
 
     def __del__(self):
 
@@ -255,11 +251,7 @@ class BaseNode:
         :param new_name: name
         """
 
-        log.info(
-            "{module}: {name} [{id}] renamed to {new_name}".format(
-                module=self.manager.module_name, name=self.name, id=self.id, new_name=new_name
-            )
-        )
+        log.info(f"{self.manager.module_name}: {self.name} [{self.id}] renamed to {new_name}")
         self._name = new_name
 
     @property
@@ -332,7 +324,7 @@ class BaseNode:
         Creates the node.
         """
 
-        log.debug("{module}: {name} [{id}] created".format(module=self.manager.module_name, name=self.name, id=self.id))
+        log.debug(f"{self.manager.module_name}: {self.name} [{self.id}] created")
 
     async def delete(self):
         """
@@ -410,9 +402,7 @@ class BaseNode:
         if self._closed:
             return False
 
-        log.debug(
-            "{module}: '{name}' [{id}]: is closing".format(module=self.manager.module_name, name=self.name, id=self.id)
-        )
+        log.debug(f"{self.manager.module_name}: '{self.name}' [{self.id}]: is closing")
 
         if self._console:
             self._manager.port_manager.release_tcp_port(self._console, self._project)
@@ -823,11 +813,7 @@ class BaseNode:
             else:
                 self._aux = self._manager.port_manager.reserve_tcp_port(aux, self._project)
 
-            log.info(
-                "{module}: '{name}' [{id}]: auxiliary console port set to {port}".format(
-                    module=self.manager.module_name, name=self.name, id=self.id, port=aux
-                )
-            )
+            log.info(f"{self.manager.module_name}: '{self.name}' [{self.id}]: auxiliary console port set to {aux}")
 
     @property
     def console(self):
@@ -868,11 +854,7 @@ class BaseNode:
             else:
                 self._console = self._manager.port_manager.reserve_tcp_port(console, self._project)
 
-            log.info(
-                "{module}: '{name}' [{id}]: console port set to {port}".format(
-                    module=self.manager.module_name, name=self.name, id=self.id, port=console
-                )
-            )
+            log.info(f"{self.manager.module_name}: '{self.name}' [{self.id}]: console port set to {console}")
 
     @property
     def console_type(self):
@@ -909,13 +891,7 @@ class BaseNode:
 
         self._console_type = console_type
         log.info(
-            "{module}: '{name}' [{id}]: console type set to {console_type} (console port is {console})".format(
-                module=self.manager.module_name,
-                name=self.name,
-                id=self.id,
-                console_type=console_type,
-                console=self.console,
-            )
+            f"{self.manager.module_name}: '{self.name}' [{self.id}]: console type set to {console_type} (console port is {self.console})"
         )
 
     @property
@@ -951,9 +927,7 @@ class BaseNode:
 
         self._aux_type = aux_type
         log.info(
-            "{module}: '{name}' [{id}]: console type set to {aux_type} (auxiliary console port is {aux})".format(
-                module=self.manager.module_name, name=self.name, id=self.id, aux_type=aux_type, aux=self.aux
-            )
+            f"{self.manager.module_name}: '{self.name}' [{self.id}]: console type set to {aux_type} (auxiliary console port is {self.aux})"
         )
 
     @property
@@ -1107,23 +1081,15 @@ class BaseNode:
             raise NodeError("Destination NIO is not UDP")
 
         await self._ubridge_send(
-            "bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
-                name=bridge_name, lport=source_nio.lport, rhost=source_nio.rhost, rport=source_nio.rport
-            )
+            f"bridge add_nio_udp {bridge_name} {source_nio.lport} {source_nio.rhost} {source_nio.rport}"
         )
 
         await self._ubridge_send(
-            "bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
-                name=bridge_name, lport=destination_nio.lport, rhost=destination_nio.rhost, rport=destination_nio.rport
-            )
+            f"bridge add_nio_udp {bridge_name} {destination_nio.lport} {destination_nio.rhost} {destination_nio.rport}"
         )
 
         if destination_nio.capturing:
-            await self._ubridge_send(
-                'bridge start_capture {name} "{pcap_file}"'.format(
-                    name=bridge_name, pcap_file=destination_nio.pcap_output_file
-                )
-            )
+            await self._ubridge_send(f'bridge start_capture {bridge_name} "{destination_nio.pcap_output_file}"')
 
         await self._ubridge_send(f"bridge start {bridge_name}")
         await self._ubridge_apply_filters(bridge_name, destination_nio.filters)
@@ -1237,7 +1203,7 @@ class BaseNode:
         # so allow up to 48 here.
         if not _MARKER_NAME_RE.match(name) or len(name) > 48:
             raise UbridgeError(f"Invalid marker name: {name!r}")
-        cmd = 'bridge add_packet_filter {bridge} {name} mark "{bpf}"'.format(bridge=bridge_name, name=name, bpf=bpf)
+        cmd = f'bridge add_packet_filter {bridge_name} {name} mark "{bpf}"'
         if tag is not None:
             cmd += f" tag {tag}"
         # Per-link attribution (contract §3.2): when one ubridge bridge serves
@@ -1250,7 +1216,7 @@ class BaseNode:
         linktype = self._marker_linktype(data_link_type)
         if linktype is not None:
             cmd += f" linktype {linktype}"
-        cmd += ' pcap "{path}"'.format(path=pcap_path)
+        cmd += f' pcap "{pcap_path}"'
         # Let BPF compile errors propagate — the marker is the user's intent, so a
         # bad expression must surface instead of being silently dropped.
         await self._ubridge_send(cmd)
@@ -1483,22 +1449,16 @@ class BaseNode:
 
         if sys.platform.startswith("linux") and block_host_traffic is False:
             # on Linux we use RAW sockets by default excepting if host traffic must be blocked
-            await self._ubridge_send(
-                'bridge add_nio_linux_raw {name} "{interface}"'.format(name=bridge_name, interface=ethernet_interface)
-            )
+            await self._ubridge_send(f'bridge add_nio_linux_raw {bridge_name} "{ethernet_interface}"')
         else:
             # on other platforms we just rely on the pcap library
-            await self._ubridge_send(
-                'bridge add_nio_ethernet {name} "{interface}"'.format(name=bridge_name, interface=ethernet_interface)
-            )
+            await self._ubridge_send(f'bridge add_nio_ethernet {bridge_name} "{ethernet_interface}"')
             source_mac = None
             for interface in interfaces():
                 if interface["name"] == ethernet_interface:
                     source_mac = interface["mac_address"]
             if source_mac:
-                await self._ubridge_send(
-                    'bridge set_pcap_filter {name} "not ether src {mac}"'.format(name=bridge_name, mac=source_mac)
-                )
+                await self._ubridge_send(f'bridge set_pcap_filter {bridge_name} "not ether src {source_mac}"')
                 log.info(f"PCAP filter applied on '{ethernet_interface}' for source MAC {source_mac}")
 
     def _create_local_udp_tunnel(self):
@@ -1516,9 +1476,7 @@ class BaseNode:
         source_nio = self.manager.create_nio(source_nio_settings)
         destination_nio = self.manager.create_nio(destination_nio_settings)
         log.info(
-            "{module}: '{name}' [{id}]:local UDP tunnel created between port {port1} and {port2}".format(
-                module=self.manager.module_name, name=self.name, id=self.id, port1=lport, port2=rport
-            )
+            f"{self.manager.module_name}: '{self.name}' [{self.id}]:local UDP tunnel created between port {lport} and {rport}"
         )
         return source_nio, destination_nio
 
@@ -1542,9 +1500,7 @@ class BaseNode:
         available_ram = int(psutil.virtual_memory().available / (1024 * 1024))
         percentage_left = 100 - psutil.virtual_memory().percent
         if requested_ram > available_ram:
-            message = '"{}" requires {}MB of RAM to run but there is only {}MB - {}% of RAM left on "{}"'.format(
-                self.name, requested_ram, available_ram, percentage_left, platform.node()
-            )
+            message = f'"{self.name}" requires {requested_ram}MB of RAM to run but there is only {available_ram}MB - {percentage_left}% of RAM left on "{platform.node()}"'
             self.project.emit("log.warning", {"message": message})
 
     def _get_custom_adapter_settings(self, adapter_number):
diff --git a/gns3server/compute/builtin/nodes/cloud.py b/gns3server/compute/builtin/nodes/cloud.py
index 5737a196d..c1cfdc251 100644
--- a/gns3server/compute/builtin/nodes/cloud.py
+++ b/gns3server/compute/builtin/nodes/cloud.py
@@ -298,19 +298,13 @@ class Cloud(BaseNode):
                 break
 
         if not port_info:
-            raise NodeError(
-                "Port {port_number} doesn't exist on cloud '{name}'".format(name=self.name, port_number=port_number)
-            )
+            raise NodeError(f"Port {port_number} doesn't exist on cloud '{self.name}'")
 
         bridge_name = f"{self._id}-{port_number}"
         await self._ubridge_send(f"bridge create {bridge_name}")
         if not isinstance(nio, NIOUDP):
             raise NodeError("Source NIO is not UDP")
-        await self._ubridge_send(
-            "bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
-                name=bridge_name, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
-            )
-        )
+        await self._ubridge_send(f"bridge add_nio_udp {bridge_name} {nio.lport} {nio.rhost} {nio.rport}")
 
         await self._ubridge_apply_filters(bridge_name, nio.filters)
         await self._ubridge_apply_markers(bridge_name, nio)
@@ -347,9 +341,7 @@ class Cloud(BaseNode):
             )
 
         if nio.capturing:
-            await self._ubridge_send(
-                'bridge start_capture {name} "{pcap_file}"'.format(name=bridge_name, pcap_file=nio.pcap_output_file)
-            )
+            await self._ubridge_send(f'bridge start_capture {bridge_name} "{nio.pcap_output_file}"')
 
         await self._ubridge_send(f"bridge start {bridge_name}")
 
@@ -370,14 +362,10 @@ class Cloud(BaseNode):
                     break
                 i += 1
 
-            await self._ubridge_send(
-                'bridge add_nio_tap "{name}" "{interface}"'.format(name=bridge_name, interface=tap)
-            )
-            await self._ubridge_send('brctl addif "{interface}" "{tap}"'.format(tap=tap, interface=interface))
+            await self._ubridge_send(f'bridge add_nio_tap "{bridge_name}" "{tap}"')
+            await self._ubridge_send(f'brctl addif "{interface}" "{tap}"')
         else:
-            await self._ubridge_send(
-                'bridge add_nio_linux_raw {name} "{interface}"'.format(name=bridge_name, interface=interface)
-            )
+            await self._ubridge_send(f'bridge add_nio_linux_raw {bridge_name} "{interface}"')
 
     async def _add_osx_ethernet(self, port_info, bridge_name):
         """
@@ -423,17 +411,13 @@ class Cloud(BaseNode):
         if port_number in self._nios:
             raise NodeError(f"Port {port_number} isn't free")
 
-        log.debug(
-            'Cloud "{name}" [{id}]: NIO {nio} bound to port {port}'.format(
-                name=self._name, id=self._id, nio=nio, port=port_number
-            )
-        )
+        log.debug(f'Cloud "{self._name}" [{self._id}]: NIO {nio} bound to port {port_number}')
         try:
             await self.start()
             await self._add_ubridge_connection(nio, port_number)
             self._nios[port_number] = nio
         except (NodeError, UbridgeError) as e:
-            log.error('Cannot add NIO on cloud "{name}": {error}'.format(name=self._name, error=e))
+            log.error(f'Cannot add NIO on cloud "{self._name}": {e}')
             await self._stop_ubridge()
             self.status = "stopped"
             self._nios[port_number] = nio
@@ -479,11 +463,7 @@ class Cloud(BaseNode):
         if isinstance(nio, NIOUDP):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)
 
-        log.debug(
-            'Cloud "{name}" [{id}]: NIO {nio} removed from port {port}'.format(
-                name=self._name, id=self._id, nio=nio, port=port_number
-            )
-        )
+        log.debug(f'Cloud "{self._name}" [{self._id}]: NIO {nio} removed from port {port_number}')
 
         del self._nios[port_number]
         if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
@@ -501,9 +481,7 @@ class Cloud(BaseNode):
         """
 
         if not [port["port_number"] for port in self._ports_mapping if port_number == port["port_number"]]:
-            raise NodeError(
-                "Port {port_number} doesn't exist on cloud '{name}'".format(name=self.name, port_number=port_number)
-            )
+            raise NodeError(f"Port {port_number} doesn't exist on cloud '{self.name}'")
 
         if port_number not in self._nios:
             raise NodeError(f"Port {port_number} is not connected")
@@ -526,14 +504,8 @@ class Cloud(BaseNode):
             raise NodeError(f"Packet capture is already activated on port {port_number}")
         nio.start_packet_capture(output_file)
         bridge_name = f"{self._id}-{port_number}"
-        await self._ubridge_send(
-            'bridge start_capture {name} "{output_file}"'.format(name=bridge_name, output_file=output_file)
-        )
-        log.debug(
-            "Cloud '{name}' [{id}]: starting packet capture on port {port_number}".format(
-                name=self.name, id=self.id, port_number=port_number
-            )
-        )
+        await self._ubridge_send(f'bridge start_capture {bridge_name} "{output_file}"')
+        log.debug(f"Cloud '{self.name}' [{self.id}]: starting packet capture on port {port_number}")
 
     async def stop_capture(self, port_number):
         """
@@ -549,8 +521,4 @@ class Cloud(BaseNode):
         bridge_name = f"{self._id}-{port_number}"
         await self._ubridge_send(f"bridge stop_capture {bridge_name}")
 
-        log.debug(
-            "Cloud'{name}' [{id}]: stopping packet capture on port {port_number}".format(
-                name=self.name, id=self.id, port_number=port_number
-            )
-        )
+        log.debug(f"Cloud'{self.name}' [{self.id}]: stopping packet capture on port {port_number}")
diff --git a/gns3server/compute/builtin/nodes/ethernet_switch.py b/gns3server/compute/builtin/nodes/ethernet_switch.py
index 759f8a638..929325976 100644
--- a/gns3server/compute/builtin/nodes/ethernet_switch.py
+++ b/gns3server/compute/builtin/nodes/ethernet_switch.py
@@ -310,17 +310,13 @@ class EthernetSwitch(BaseNode):
         if not isinstance(nio, NIOUDP):
             raise NodeError("Ethernet switch ports only support UDP NIOs")
 
-        log.debug(
-            'Ethernet switch "{name}" [{id}]: NIO {nio} bound to port {port}'.format(
-                name=self._name, id=self._id, nio=nio, port=port_number
-            )
-        )
+        log.debug(f'Ethernet switch "{self._name}" [{self._id}]: NIO {nio} bound to port {port_number}')
         try:
             await self.start()
             await self._add_ubridge_connection(nio, port_number)
             self._nios[port_number] = nio
         except (NodeError, UbridgeError) as e:
-            log.error('Cannot add NIO on Ethernet switch "{name}": {error}'.format(name=self._name, error=e))
+            log.error(f'Cannot add NIO on Ethernet switch "{self._name}": {e}')
             await self._stop_ubridge()
             self.status = "stopped"
             self._nios[port_number] = nio
@@ -347,19 +343,11 @@ class EthernetSwitch(BaseNode):
         # VLAN membership for this port's access/trunk/qinq mode
         await self._apply_port_vlan(port_settings, tap)
         # GNS3 link endpoint
-        await self._ubridge_send(
-            "bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
-                name=ubridge_bridge, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
-            )
-        )
+        await self._ubridge_send(f"bridge add_nio_udp {ubridge_bridge} {nio.lport} {nio.rhost} {nio.rport}")
         await self._ubridge_apply_filters(ubridge_bridge, nio.filters)
         await self._ubridge_apply_markers(ubridge_bridge, nio)
         if nio.capturing:
-            await self._ubridge_send(
-                'bridge start_capture {name} "{output_file}"'.format(
-                    name=ubridge_bridge, output_file=nio.pcap_output_file
-                )
-            )
+            await self._ubridge_send(f'bridge start_capture {ubridge_bridge} "{nio.pcap_output_file}"')
         await self._ubridge_send(f"bridge start {ubridge_bridge}")
         self._tap_by_port[port_number] = tap
 
@@ -397,11 +385,7 @@ class EthernetSwitch(BaseNode):
         if isinstance(nio, NIOUDP):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)
 
-        log.debug(
-            'Ethernet switch "{name}" [{id}]: NIO {nio} removed from port {port}'.format(
-                name=self._name, id=self._id, nio=nio, port=port_number
-            )
-        )
+        log.debug(f'Ethernet switch "{self._name}" [{self._id}]: NIO {nio} removed from port {port_number}')
         del self._nios[port_number]
         if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
             await self._delete_ubridge_connection(port_number)
@@ -512,11 +496,7 @@ class EthernetSwitch(BaseNode):
         if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
             ubridge_bridge = self._ubridge_bridge_name(port_number)
             await self._ubridge_send(f'bridge start_capture {ubridge_bridge} "{output_file}"')
-        log.debug(
-            'Ethernet switch "{name}" [{id}]: starting packet capture on port {port}'.format(
-                name=self.name, id=self.id, port=port_number
-            )
-        )
+        log.debug(f'Ethernet switch "{self.name}" [{self.id}]: starting packet capture on port {port_number}')
 
     async def stop_capture(self, port_number):
         """
@@ -532,8 +512,4 @@ class EthernetSwitch(BaseNode):
         if self._ubridge_hypervisor and self._ubridge_hypervisor.is_running():
             ubridge_bridge = self._ubridge_bridge_name(port_number)
             await self._ubridge_send(f"bridge stop_capture {ubridge_bridge}")
-        log.debug(
-            'Ethernet switch "{name}" [{id}]: stopping packet capture on port {port}'.format(
-                name=self.name, id=self.id, port=port_number
-            )
-        )
+        log.debug(f'Ethernet switch "{self.name}" [{self.id}]: stopping packet capture on port {port_number}')
diff --git a/gns3server/compute/builtin/nodes/nat.py b/gns3server/compute/builtin/nodes/nat.py
index ce5a4b77e..158f337ee 100644
--- a/gns3server/compute/builtin/nodes/nat.py
+++ b/gns3server/compute/builtin/nodes/nat.py
@@ -44,8 +44,8 @@ class Nat(Cloud):
                 nat_interface = "virbr0"
             if allowed_interfaces and nat_interface not in allowed_interfaces:
                 raise NodeError(
-                    "NAT interface {} is not allowed be used on this server. "
-                    "Please check the server configuration file.".format(nat_interface)
+                    f"NAT interface {nat_interface} is not allowed be used on this server. "
+                    "Please check the server configuration file."
                 )
             if nat_interface not in [interface["name"] for interface in gns3server.utils.interfaces.interfaces()]:
                 raise NodeError(f"NAT interface {nat_interface} is missing, please install libvirt")
@@ -56,8 +56,8 @@ class Nat(Cloud):
                 nat_interface = "vmnet8"
             if allowed_interfaces and nat_interface not in allowed_interfaces:
                 raise NodeError(
-                    "NAT interface {} is not allowed be used on this server. "
-                    "Please check the server configuration file.".format(nat_interface)
+                    f"NAT interface {nat_interface} is not allowed be used on this server. "
+                    "Please check the server configuration file."
                 )
             interfaces = list(
                 filter(
diff --git a/gns3server/compute/project_manager.py b/gns3server/compute/project_manager.py
index 1bcbae019..d99247201 100644
--- a/gns3server/compute/project_manager.py
+++ b/gns3server/compute/project_manager.py
@@ -91,9 +91,7 @@ class ProjectManager:
             return
         # send a warning if used disk space is >= 90%
         if used_disk_space >= 90:
-            message = 'Only {:.2f}% or less of free disk space detected in "{}" on "{}"'.format(
-                100 - used_disk_space, project.path, platform.node()
-            )
+            message = f'Only {100 - used_disk_space:.2f}% or less of free disk space detected in "{project.path}" on "{platform.node()}"'
             log.warning(message)
             project.emit("log.warning", {"message": message})
 
diff --git a/gns3server/compute/ubridge/ubridge_hypervisor.py b/gns3server/compute/ubridge/ubridge_hypervisor.py
index 6256f0142..5b26e6db1 100644
--- a/gns3server/compute/ubridge/ubridge_hypervisor.py
+++ b/gns3server/compute/ubridge/ubridge_hypervisor.py
@@ -188,9 +188,7 @@ class UBridgeHypervisor:
             await self._writer.drain()
         except OSError as e:
             raise UbridgeError(
-                "Lost communication with {endpoint} when sending command '{command}': {error}, uBridge process running: {run}".format(
-                    endpoint=self.endpoint, command=command, error=e, run=self.is_running()
-                )
+                f"Lost communication with {self.endpoint} when sending command '{command}': {e}, uBridge process running: {self.is_running()}"
             )
 
         # Now retrieve the result
@@ -215,9 +213,7 @@ class UBridgeHypervisor:
                 if not chunk:
                     if retries > max_retries:
                         raise UbridgeError(
-                            "No data returned from {endpoint} after sending command '{command}', uBridge process running: {run}".format(
-                                endpoint=self.endpoint, command=command, run=self.is_running()
-                            )
+                            f"No data returned from {self.endpoint} after sending command '{command}', uBridge process running: {self.is_running()}"
                         )
                     else:
                         retries += 1
@@ -227,9 +223,7 @@ class UBridgeHypervisor:
                 buf += chunk.decode("utf-8")
             except OSError as e:
                 raise UbridgeError(
-                    "Lost communication with {endpoint} after sending command '{command}': {error}, uBridge process running: {run}".format(
-                        endpoint=self.endpoint, command=command, error=e, run=self.is_running()
-                    )
+                    f"Lost communication with {self.endpoint} after sending command '{command}': {e}, uBridge process running: {self.is_running()}"
                 )
 
             # If the buffer doesn't end in '\n' then we can't be done
@@ -238,9 +232,7 @@ class UBridgeHypervisor:
                     continue
             except IndexError:
                 raise UbridgeError(
-                    "Could not communicate with {endpoint} after sending command '{command}', uBridge process running: {run}".format(
-                        endpoint=self.endpoint, command=command, run=self.is_running()
-                    )
+                    f"Could not communicate with {self.endpoint} after sending command '{command}', uBridge process running: {self.is_running()}"
                 )
 
             data += buf.split("\r\n")
diff --git a/gns3server/compute/virtualbox/virtualbox_vm.py b/gns3server/compute/virtualbox/virtualbox_vm.py
index d5d747503..0876e2553 100644
--- a/gns3server/compute/virtualbox/virtualbox_vm.py
+++ b/gns3server/compute/virtualbox/virtualbox_vm.py
@@ -234,7 +234,7 @@ class VirtualBoxVM(BaseNode):
 
         linked_vbox_file = self._linked_vbox_file()
         if not os.path.exists(linked_vbox_file):
-            raise VirtualBoxError("Cannot find VirtualBox linked node file: {}".format(linked_vbox_file))
+            raise VirtualBoxError(f"Cannot find VirtualBox linked node file: {linked_vbox_file}")
 
         try:
             tree = ET.parse(linked_vbox_file)
@@ -402,11 +402,7 @@ class VirtualBoxVM(BaseNode):
             self.status = "suspended"
             log.info(f"VirtualBox VM '{self.name}' [{self.id}] suspended")
         else:
-            log.warning(
-                "VirtualBox VM '{name}' [{id}] cannot be suspended, current state: {state}".format(
-                    name=self.name, id=self.id, state=vm_state
-                )
-            )
+            log.warning(f"VirtualBox VM '{self.name}' [{self.id}] cannot be suspended, current state: {vm_state}")
 
     async def resume(self):
         """
@@ -511,9 +507,7 @@ class VirtualBoxVM(BaseNode):
                             os.path.join(self.working_dir, self._vmname, "Snapshots", os.path.basename(value))
                         ):
                             log.info(
-                                "VirtualBox VM '{name}' [{id}] detaching HDD {controller} {port} {device}".format(
-                                    name=self.name, id=self.id, controller=controller, port=port, device=device
-                                )
+                                f"VirtualBox VM '{self.name}' [{self.id}] detaching HDD {controller} {port} {device}"
                             )
                             hdd_table.append(
                                 {
@@ -530,11 +524,7 @@ class VirtualBoxVM(BaseNode):
                     with open(hdd_info_file, "w", encoding="utf-8") as f:
                         json.dump(hdd_table, f, indent=4)
                 except OSError as e:
-                    log.warning(
-                        "VirtualBox VM '{name}' [{id}] could not write HHD info file: {error}".format(
-                            name=self.name, id=self.id, error=e.strerror
-                        )
-                    )
+                    log.warning(f"VirtualBox VM '{self.name}' [{self.id}] could not write HHD info file: {e.strerror}")
 
         return hdd_table
 
@@ -739,15 +729,11 @@ class VirtualBoxVM(BaseNode):
                 log.warning(f"Could not find system property '{max_adapter_string}' for chipset {chipset}")
 
         log.info(
-            "VirtualBox VM '{name}' [{id}] can have a maximum of {max} network adapters for chipset {chipset}".format(
-                name=self.name, id=self.id, max=self._maximum_adapters, chipset=chipset.upper()
-            )
+            f"VirtualBox VM '{self.name}' [{self.id}] can have a maximum of {self._maximum_adapters} network adapters for chipset {chipset.upper()}"
         )
         if adapters > self._maximum_adapters:
             raise VirtualBoxError(
-                "The configured {} chipset limits the VM to {} network adapters. The chipset can be changed outside GNS3 in the VirtualBox VM settings.".format(
-                    chipset.upper(), self._maximum_adapters
-                )
+                f"The configured {chipset.upper()} chipset limits the VM to {self._maximum_adapters} network adapters. The chipset can be changed outside GNS3 in the VirtualBox VM settings."
             )
 
         self._ethernet_adapters.clear()
@@ -755,11 +741,7 @@ class VirtualBoxVM(BaseNode):
             self._ethernet_adapters[adapter_number] = EthernetAdapter()
 
         self._adapters = len(self._ethernet_adapters)
-        log.info(
-            "VirtualBox VM '{name}' [{id}] has changed the number of Ethernet adapters to {adapters}".format(
-                name=self.name, id=self.id, adapters=adapters
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}] has changed the number of Ethernet adapters to {adapters}")
 
     @property
     def use_any_adapter(self):
@@ -804,11 +786,7 @@ class VirtualBoxVM(BaseNode):
         """
 
         self._adapter_type = adapter_type
-        log.info(
-            "VirtualBox VM '{name}' [{id}]: adapter type changed to {adapter_type}".format(
-                name=self.name, id=self.id, adapter_type=adapter_type
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}]: adapter type changed to {adapter_type}")
 
     async def _get_vm_info(self):
         """
@@ -1076,11 +1054,7 @@ class VirtualBoxVM(BaseNode):
         try:
             adapter = self._ethernet_adapters[adapter_number]
         except KeyError:
-            raise VirtualBoxError(
-                "Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
 
         # check if trying to connect to a nat, bridged, host-only or any other special adapter
         nic_attachments = await self._get_nic_attachements(self._maximum_adapters)
@@ -1088,10 +1062,8 @@ class VirtualBoxVM(BaseNode):
         if attachment in ("nat", "bridged", "intnet", "hostonly", "natnetwork"):
             if not self._use_any_adapter:
                 raise VirtualBoxError(
-                    "Attachment '{attachment}' is already configured on adapter {adapter_number}. "
-                    "Please remove it or allow VirtualBox VM '{name}' to use any adapter.".format(
-                        attachment=attachment, adapter_number=adapter_number, name=self.name
-                    )
+                    f"Attachment '{attachment}' is already configured on adapter {adapter_number}. "
+                    f"Please remove it or allow VirtualBox VM '{self.name}' to use any adapter."
                 )
             elif self.is_running():
                 # dynamically configure an UDP tunnel attachment if the VM is already running
@@ -1109,19 +1081,11 @@ class VirtualBoxVM(BaseNode):
                     f"VBOX-{self._id}-{adapter_number}", self._local_udp_tunnels[adapter_number][1], nio
                 )
             except KeyError:
-                raise VirtualBoxError(
-                    "Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
-                        name=self.name, adapter_number=adapter_number
-                    )
-                )
+                raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
             await self._control_vm(f"setlinkstate{adapter_number + 1} on")
 
         adapter.add_nio(0, nio)
-        log.info(
-            "VirtualBox VM '{name}' [{id}]: {nio} added to adapter {adapter_number}".format(
-                name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}]: {nio} added to adapter {adapter_number}")
 
     async def adapter_update_nio_binding(self, adapter_number, nio):
         """
@@ -1141,11 +1105,7 @@ class VirtualBoxVM(BaseNode):
                 else:
                     await self._control_vm(f"setlinkstate{adapter_number + 1} on")
             except IndexError:
-                raise VirtualBoxError(
-                    'Adapter {adapter_number} does not exist on VirtualBox VM "{name}"'.format(
-                        name=self._name, adapter_number=adapter_number
-                    )
-                )
+                raise VirtualBoxError(f'Adapter {adapter_number} does not exist on VirtualBox VM "{self._name}"')
 
     async def adapter_remove_nio_binding(self, adapter_number):
         """
@@ -1159,11 +1119,7 @@ class VirtualBoxVM(BaseNode):
         try:
             adapter = self._ethernet_adapters[adapter_number]
         except KeyError:
-            raise VirtualBoxError(
-                "Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
 
         await self.stop_capture(adapter_number)
         if self.is_running():
@@ -1177,11 +1133,7 @@ class VirtualBoxVM(BaseNode):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)
         adapter.remove_nio(0)
 
-        log.info(
-            "VirtualBox VM '{name}' [{id}]: {nio} removed from adapter {adapter_number}".format(
-                name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}]: {nio} removed from adapter {adapter_number}")
         return nio
 
     def get_nio(self, adapter_number):
@@ -1196,11 +1148,7 @@ class VirtualBoxVM(BaseNode):
         try:
             adapter = self.ethernet_adapters[adapter_number]
         except KeyError:
-            raise VirtualBoxError(
-                "Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VirtualBoxError(f"Adapter {adapter_number} doesn't exist on VirtualBox VM '{self.name}'")
 
         nio = adapter.get_nio(0)
 
@@ -1235,11 +1183,7 @@ class VirtualBoxVM(BaseNode):
                 )
             )
 
-        log.info(
-            "VirtualBox VM '{name}' [{id}]: starting packet capture on adapter {adapter_number}".format(
-                name=self.name, id=self.id, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}]: starting packet capture on adapter {adapter_number}")
 
     async def stop_capture(self, adapter_number):
         """
@@ -1256,8 +1200,4 @@ class VirtualBoxVM(BaseNode):
         if self.ubridge:
             await self._ubridge_send("bridge stop_capture {name}".format(name=f"VBOX-{self._id}-{adapter_number}"))
 
-        log.info(
-            "VirtualBox VM '{name}' [{id}]: stopping packet capture on adapter {adapter_number}".format(
-                name=self.name, id=self.id, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VirtualBox VM '{self.name}' [{self.id}]: stopping packet capture on adapter {adapter_number}")
diff --git a/gns3server/compute/vmware/__init__.py b/gns3server/compute/vmware/__init__.py
index 7aa615927..cc480688e 100644
--- a/gns3server/compute/vmware/__init__.py
+++ b/gns3server/compute/vmware/__init__.py
@@ -241,12 +241,12 @@ class VMware(BaseManager):
                 for line in f.read().splitlines():
                     match = re.search(r"VNET_([0-9]+)_HOSTONLY_SUBNET\s+(.*)", line)
                     if match:
-                        vmnet = "vmnet{}".format(match.group(1))
+                        vmnet = f"vmnet{match.group(1)}"
                         if vmnet in vmnet_interfaces.keys():
                             vmnet_interfaces[vmnet]["subnet"] = match.group(2)
                     match = re.search(r"VNET_([0-9]+)_HOSTONLY_NETMASK\s+(.*)", line)
                     if match:
-                        vmnet = "vmnet{}".format(match.group(1))
+                        vmnet = f"vmnet{match.group(1)}"
                         if vmnet in vmnet_interfaces.keys():
                             vmnet_interfaces[vmnet]["netmask"] = match.group(2)
 
@@ -305,7 +305,7 @@ class VMware(BaseManager):
 
     def refresh_vmnet_list(self, ubridge=True):
 
-        log.debug("Refreshing VMnet list with uBridge={}".format(ubridge))
+        log.debug(f"Refreshing VMnet list with uBridge={ubridge}")
 
         if ubridge:
             # VMnet host adapters must be present when uBridge is used
@@ -315,7 +315,7 @@ class VMware(BaseManager):
             self._vmnets_info = vmnet_interfaces.copy()
             vmnet_interfaces = list(vmnet_interfaces.keys())
 
-        log.debug("Found {} VMnet interfaces".format(len(vmnet_interfaces)))
+        log.debug(f"Found {len(vmnet_interfaces)} VMnet interfaces")
         # remove vmnets already in use
         for vmware_vm in self._nodes.values():
             for used_vmnet in vmware_vm.vmnets:
@@ -326,7 +326,7 @@ class VMware(BaseManager):
         # remove vmnets that are not managed
         for vmnet in vmnet_interfaces.copy():
             if vmnet in vmnet_interfaces and self.is_managed_vmnet(vmnet) is False:
-                log.debug("{} is not managed by GNS3".format(vmnet))
+                log.debug(f"{vmnet} is not managed by GNS3")
                 vmnet_interfaces.remove(vmnet)
 
         self._vmnets = vmnet_interfaces
@@ -677,9 +677,7 @@ class VMware(BaseManager):
                     default_vm_path = pairs["prefvmx.defaultvmpath"]
                     if not os.path.isdir(default_vm_path):
                         raise VMwareError(
-                            'Could not find or access the default VM directory: "{default_vm_path}". Please change "prefvmx.defaultvmpath={default_vm_path}" in "{vmware_preferences_path}"'.format(
-                                default_vm_path=default_vm_path, vmware_preferences_path=vmware_preferences_path
-                            )
+                            f'Could not find or access the default VM directory: "{default_vm_path}". Please change "prefvmx.defaultvmpath={default_vm_path}" in "{vmware_preferences_path}"'
                         )
                     vmware_vms = self._get_vms_from_directory(default_vm_path)
 
diff --git a/gns3server/compute/vmware/vmware_vm.py b/gns3server/compute/vmware/vmware_vm.py
index f4636f55a..db54fa55f 100644
--- a/gns3server/compute/vmware/vmware_vm.py
+++ b/gns3server/compute/vmware/vmware_vm.py
@@ -361,18 +361,12 @@ class VMwareVM(BaseNode):
                 await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)
             else:
                 # special case on macOS, we cannot bind VMnet interfaces using the libpcap
-                await self._ubridge_send(
-                    'bridge add_nio_fusion_vmnet {name} "{interface}"'.format(name=vnet, interface=vmnet_interface)
-                )
+                await self._ubridge_send(f'bridge add_nio_fusion_vmnet {vnet} "{vmnet_interface}"')
         else:
             await self._add_ubridge_ethernet_connection(vnet, vmnet_interface, block_host_traffic)
 
         if isinstance(nio, NIOUDP):
-            await self._ubridge_send(
-                "bridge add_nio_udp {name} {lport} {rhost} {rport}".format(
-                    name=vnet, lport=nio.lport, rhost=nio.rhost, rport=nio.rport
-                )
-            )
+            await self._ubridge_send(f"bridge add_nio_udp {vnet} {nio.lport} {nio.rhost} {nio.rport}")
 
         if nio.capturing:
             await self._ubridge_send(f'bridge start_capture {vnet} "{nio.pcap_output_file}"')
@@ -418,9 +412,7 @@ class VMwareVM(BaseNode):
             raise VMwareError(f"vnet {vnet} not in VMX file")
         if not self._ubridge_hypervisor:
             raise VMwareError("Cannot start the packet capture: uBridge is not running")
-        await self._ubridge_send(
-            'bridge start_capture {name} "{output_file}"'.format(name=vnet, output_file=output_file)
-        )
+        await self._ubridge_send(f'bridge start_capture {vnet} "{output_file}"')
 
     async def _stop_ubridge_capture(self, adapter_number):
         """
@@ -694,11 +686,7 @@ class VMwareVM(BaseNode):
             self._ethernet_adapters[adapter_number] = EthernetAdapter()
 
         self._adapters = len(self._ethernet_adapters)
-        log.info(
-            "VMware VM '{name}' [{id}] has changed the number of Ethernet adapters to {adapters}".format(
-                name=self.name, id=self.id, adapters=adapters
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}] has changed the number of Ethernet adapters to {adapters}")
 
     @property
     def adapter_type(self):
@@ -719,11 +707,7 @@ class VMwareVM(BaseNode):
         """
 
         self._adapter_type = adapter_type
-        log.info(
-            "VMware VM '{name}' [{id}]: adapter type changed to {adapter_type}".format(
-                name=self.name, id=self.id, adapter_type=adapter_type
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}]: adapter type changed to {adapter_type}")
 
     @property
     def use_any_adapter(self):
@@ -760,11 +744,7 @@ class VMwareVM(BaseNode):
         try:
             adapter = self._ethernet_adapters[adapter_number]
         except IndexError:
-            raise VMwareError(
-                "Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
 
         self._read_vmx_file()
         # check if trying to connect to a nat, bridged or host-only adapter
@@ -778,28 +758,20 @@ class VMwareVM(BaseNode):
             ):
                 if await self.is_running():
                     raise VMwareError(
-                        "Attachment '{attachment}' is configured on network adapter {adapter_number}. "
-                        "Please stop VMware VM '{name}' to link to this adapter and allow GNS3 to change the attachment type.".format(
-                            attachment=self._vmx_pairs[connection_type], adapter_number=adapter_number, name=self.name
-                        )
+                        f"Attachment '{self._vmx_pairs[connection_type]}' is configured on network adapter {adapter_number}. "
+                        f"Please stop VMware VM '{self.name}' to link to this adapter and allow GNS3 to change the attachment type."
                     )
                 else:
                     raise VMwareError(
-                        "Attachment '{attachment}' is already configured on network adapter {adapter_number}. "
-                        "Please remove it or allow VMware VM '{name}' to use any adapter.".format(
-                            attachment=self._vmx_pairs[connection_type], adapter_number=adapter_number, name=self.name
-                        )
+                        f"Attachment '{self._vmx_pairs[connection_type]}' is already configured on network adapter {adapter_number}. "
+                        f"Please remove it or allow VMware VM '{self.name}' to use any adapter."
                     )
 
         adapter.add_nio(0, nio)
         if self._started and self._ubridge_hypervisor:
             await self._add_ubridge_connection(nio, adapter_number)
 
-        log.info(
-            "VMware VM '{name}' [{id}]: {nio} added to adapter {adapter_number}".format(
-                name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}]: {nio} added to adapter {adapter_number}")
 
     async def adapter_update_nio_binding(self, adapter_number, nio):
         """
@@ -813,11 +785,7 @@ class VMwareVM(BaseNode):
             try:
                 await self._update_ubridge_connection(adapter_number, nio)
             except IndexError:
-                raise VMwareError(
-                    'Adapter {adapter_number} does not exist on VMware VM "{name}"'.format(
-                        name=self._name, adapter_number=adapter_number
-                    )
-                )
+                raise VMwareError(f'Adapter {adapter_number} does not exist on VMware VM "{self._name}"')
 
     async def adapter_remove_nio_binding(self, adapter_number):
         """
@@ -831,11 +799,7 @@ class VMwareVM(BaseNode):
         try:
             adapter = self._ethernet_adapters[adapter_number]
         except IndexError:
-            raise VMwareError(
-                "Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
 
         await self.stop_capture(adapter_number)
         nio = adapter.get_nio(0)
@@ -845,11 +809,7 @@ class VMwareVM(BaseNode):
         if self._started and self._ubridge_hypervisor:
             await self._delete_ubridge_connection(adapter_number)
 
-        log.info(
-            "VMware VM '{name}' [{id}]: {nio} removed from adapter {adapter_number}".format(
-                name=self.name, id=self.id, nio=nio, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}]: {nio} removed from adapter {adapter_number}")
 
         return nio
 
@@ -865,11 +825,7 @@ class VMwareVM(BaseNode):
         try:
             adapter = self.ethernet_adapters[adapter_number]
         except KeyError:
-            raise VMwareError(
-                "Adapter {adapter_number} doesn't exist on VMware VM '{name}'".format(
-                    name=self.name, adapter_number=adapter_number
-                )
-            )
+            raise VMwareError(f"Adapter {adapter_number} doesn't exist on VMware VM '{self.name}'")
 
         nio = adapter.get_nio(0)
         if not nio:
@@ -984,11 +940,7 @@ class VMwareVM(BaseNode):
         if self._started:
             await self._start_ubridge_capture(adapter_number, output_file)
 
-        log.info(
-            "VMware VM '{name}' [{id}]: starting packet capture on adapter {adapter_number}".format(
-                name=self.name, id=self.id, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}]: starting packet capture on adapter {adapter_number}")
 
     async def stop_capture(self, adapter_number):
         """
@@ -1005,8 +957,4 @@ class VMwareVM(BaseNode):
         if self._started:
             await self._stop_ubridge_capture(adapter_number)
 
-        log.info(
-            "VMware VM '{name}' [{id}]: stopping packet capture on adapter {adapter_number}".format(
-                name=self.name, id=self.id, adapter_number=adapter_number
-            )
-        )
+        log.info(f"VMware VM '{self.name}' [{self.id}]: stopping packet capture on adapter {adapter_number}")
diff --git a/gns3server/compute/vpcs/vpcs_vm.py b/gns3server/compute/vpcs/vpcs_vm.py
index af0acf72e..ec3dd88eb 100644
--- a/gns3server/compute/vpcs/vpcs_vm.py
+++ b/gns3server/compute/vpcs/vpcs_vm.py
@@ -384,21 +384,13 @@ class VPCSVM(BaseNode):
         """
 
         if not self._ethernet_adapter.port_exists(port_number):
-            raise VPCSError(
-                "Port {port_number} doesn't exist on adapter {adapter}".format(
-                    adapter=self._ethernet_adapter, port_number=port_number
-                )
-            )
+            raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
 
         if self.is_running():
             await self.add_ubridge_udp_connection(f"VPCS-{self._id}", self._local_udp_tunnel[1], nio)
 
         self._ethernet_adapter.add_nio(port_number, nio)
-        log.info(
-            'VPCS "{name}" [{id}]: {nio} added to port {port_number}'.format(
-                name=self._name, id=self.id, nio=nio, port_number=port_number
-            )
-        )
+        log.info(f'VPCS "{self._name}" [{self.id}]: {nio} added to port {port_number}')
 
         return nio
 
@@ -411,11 +403,7 @@ class VPCSVM(BaseNode):
         """
 
         if not self._ethernet_adapter.port_exists(port_number):
-            raise VPCSError(
-                "Port {port_number} doesn't exist on adapter {adapter}".format(
-                    adapter=self._ethernet_adapter, port_number=port_number
-                )
-            )
+            raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
         if self.is_running():
             await self.update_ubridge_udp_connection(f"VPCS-{self._id}", self._local_udp_tunnel[1], nio)
 
@@ -429,11 +417,7 @@ class VPCSVM(BaseNode):
         """
 
         if not self._ethernet_adapter.port_exists(port_number):
-            raise VPCSError(
-                "Port {port_number} doesn't exist on adapter {adapter}".format(
-                    adapter=self._ethernet_adapter, port_number=port_number
-                )
-            )
+            raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
 
         await self.stop_capture(port_number)
         if self.is_running():
@@ -444,11 +428,7 @@ class VPCSVM(BaseNode):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)
         self._ethernet_adapter.remove_nio(port_number)
 
-        log.info(
-            'VPCS "{name}" [{id}]: {nio} removed from port {port_number}'.format(
-                name=self._name, id=self.id, nio=nio, port_number=port_number
-            )
-        )
+        log.info(f'VPCS "{self._name}" [{self.id}]: {nio} removed from port {port_number}')
         return nio
 
     def get_nio(self, port_number):
@@ -461,11 +441,7 @@ class VPCSVM(BaseNode):
         """
 
         if not self._ethernet_adapter.port_exists(port_number):
-            raise VPCSError(
-                "Port {port_number} doesn't exist on adapter {adapter}".format(
-                    adapter=self._ethernet_adapter, port_number=port_number
-                )
-            )
+            raise VPCSError(f"Port {port_number} doesn't exist on adapter {self._ethernet_adapter}")
         nio = self._ethernet_adapter.get_nio(port_number)
         if not nio:
             raise VPCSError(f"Port {port_number} is not connected")
@@ -489,11 +465,7 @@ class VPCSVM(BaseNode):
                 'bridge start_capture {name} "{output_file}"'.format(name=f"VPCS-{self._id}", output_file=output_file)
             )
 
-        log.info(
-            "VPCS '{name}' [{id}]: starting packet capture on port {port_number}".format(
-                name=self.name, id=self.id, port_number=port_number
-            )
-        )
+        log.info(f"VPCS '{self.name}' [{self.id}]: starting packet capture on port {port_number}")
 
     async def stop_capture(self, port_number):
         """
@@ -510,11 +482,7 @@ class VPCSVM(BaseNode):
         if self.ubridge:
             await self._ubridge_send("bridge stop_capture {name}".format(name=f"VPCS-{self._id}"))
 
-        log.info(
-            "VPCS '{name}' [{id}]: stopping packet capture on port {port_number}".format(
-                name=self.name, id=self.id, port_number=port_number
-            )
-        )
+        log.info(f"VPCS '{self.name}' [{self.id}]: stopping packet capture on port {port_number}")
 
     def _build_command(self):
         """