package-wide: replace format/% notation with f-strings with manual help

These changes are a mixture of manual adjustment while considering
flynt's suggestions in aggressive mode (-a).

No change in behavior intended.

Signed-off-by: Bastian Krause <bst@pengutronix.de>

Author: Bastian-Krause

labgrid/binding.py

@@ -91,8 +91,7 @@ def check_active(cls, func):
         def wrapper(self, *_args, **_kwargs):
             if self.state is not BindingState.active:
                 raise StateError(
-                    '{} has not been activated, {} cannot be called in state "{}"'.format(
-                        self, func.__qualname__, self.state.name)
+                    f'{self} has not been activated, {func.__qualname__} cannot be called in state "{self.state.name}"'  # pylint: disable=line-too-long
                 )
             return func(self, *_args, **_kwargs)
 

labgrid/consoleloggingreporter.py

@@ -64,8 +64,8 @@ def get_logfile(self, event):
 
             if source.name:
                 log.write(
-                    "Labgrid Console Logfile for {} {}\n".
-                    format(source.target.name, source.name).encode("utf-8")
+                    f"Labgrid Console Logfile for {source.target.name} {source.name}\n"
+                    .encode("utf-8")
                 )
             else:
                 log.write(

labgrid/driver/bareboxdriver.py

@@ -83,13 +83,11 @@ def _run(self, cmd: str, *, timeout: int = 30, codec: str = "utf-8", decodeerror
         marker = gen_marker()
         # hide marker from expect
         hidden_marker = f'"{marker[:4]}""{marker[4:]}"'
-        cmp_command = '''echo -o /cmd {cmd}; echo {marker}; sh /cmd; echo {marker} $?;'''.format(
-            cmd=shlex.quote(cmd), marker=hidden_marker)
+        cmp_command = f'''echo -o /cmd {shlex.quote(cmd)}; echo {hidden_marker}; sh /cmd; echo {hidden_marker} $?;'''  # pylint: disable=line-too-long
         if self._status == 1:
             self.console.sendline(cmp_command)
             _, _, match, _ = self.console.expect(
-                r'{marker}(.*){marker}\s+(\d+)\s+.*{prompt}'.format(
-                    marker=marker, prompt=self.prompt),
+                rf'{marker}(.*){marker}\s+(\d+)\s+.*{self.prompt}',
                 timeout=timeout)
             # Remove VT100 Codes and split by newline
             data = self.re_vt100.sub('', match.group(1).decode('utf-8')).split('\r\n')[1:-1]
@@ -185,8 +183,9 @@ def _await_prompt(self):
                     self.console.sendline("")
 
                 if timeout.expired:
-                    raise TIMEOUT("Timeout of {} seconds exceeded during waiting for login"
-                                  .format(self.login_timeout))
+                    raise TIMEOUT(
+                        f"Timeout of {self.login_timeout} seconds exceeded during waiting for login"  # pylint: disable=line-too-long
+                    )
 
             last_before = before
 

labgrid/driver/manualswitchdriver.py

@@ -27,11 +27,7 @@ def set(self, status):
             description = self.name
 
         self.target.interact(
-            "Set {description} for target {name} to {status} and press enter".format(
-                description=description,
-                name=self.target.name,
-                status="ON" if status else "OFF",
-            )
+            f"Set {description} for target {self.target.name} to {'ON' if status else 'OFF'} and press enter"  # pylint: disable=line-too-long
         )
         self.status = status
 

labgrid/driver/onewiredriver.py

@@ -21,8 +21,8 @@ def __attrs_post_init__(self):
         self._onewire = None
         if "PIO" not in self.port.path:
             raise InvalidConfigError(
-                "Invalid OneWire path {} (needs to be in the form of ??.????????????/PIO.?)"
-                .format(self.port.path))
+                f"Invalid OneWire path {self.port.path} (needs to be in the form of ??.????????????/PIO.?)"  # pylint: disable=line-too-long
+            )
 
     def on_activate(self):
         # we can only forward if the backend knows which port to use

labgrid/driver/powerdriver.py

@@ -346,8 +346,7 @@ def __attrs_post_init__(self):
         self._port = None
 
     def _build_url(self, cmd):
-        res = "http://{}:{}/power/control/{}?hostname={}&port={}".format(
-            self._host, self._port, cmd, self.port.pdu, self.port.index)
+        res = f"http://{self._host}:{self._port}/power/control/{cmd}?hostname={self.port.pdu}&port={self.port.index}"  # pylint: disable=line-too-long
         if cmd == 'reboot':
             res += f"&delay={math.ceil(self.delay)}"
         return res

labgrid/driver/qemudriver.py

@@ -133,8 +133,7 @@ def on_activate(self):
         if self.rootfs is not None:
             self._cmd.append("-fsdev")
             self._cmd.append(
-                "local,id=rootfs,security_model=none,path={}".format(
-                    self.target.env.config.get_path(self.rootfs)))
+                f"local,id=rootfs,security_model=none,path={self.target.env.config.get_path(self.rootfs)}")  # pylint: disable=line-too-long
             self._cmd.append("-device")
             self._cmd.append(
                 "virtio-9p-device,fsdev=rootfs,mount_tag=/dev/root")
@@ -145,8 +144,7 @@ def on_activate(self):
         if self.flash is not None:
             self._cmd.append("-drive")
             self._cmd.append(
-                "if=pflash,format=raw,file={},id=nor0".format(
-                    self.target.env.config.get_image_path(self.flash)))
+                f"if=pflash,format=raw,file={self.target.env.config.get_image_path(self.flash)},id=nor0")  # pylint: disable=line-too-long
         if self.bios is not None:
             self._cmd.append("-bios")
             self._cmd.append(
@@ -201,8 +199,9 @@ def on(self):
             self.qmp = QMPMonitor(self._child.stdout, self._child.stdin)
         except QMPError as exc:
             if self._child.poll() is not None:
-                raise IOError("QEMU process terminated with exit code {}"
-                              .format(self._child.returncode)) from exc
+                raise IOError(
+                    f"QEMU process terminated with exit code {self._child.returncode}"
+                ) from exc
             raise
 
         self.status = 1

labgrid/driver/quartushpsdriver.py

@@ -57,8 +57,9 @@ def _get_cable_number(self):
             regex = rf".*(\d+)\) .* \[{re.escape(self.interface.path)}]\n(.*)\n"
             jtag_mapping = re.search(regex, stdout.decode("utf-8"), re.MULTILINE)
             if jtag_mapping is None:
-                raise ExecutionError("Could not get cable number for USB path {}"
-                                     .format(self.interface.path))
+                raise ExecutionError(
+                    f"Could not get cable number for USB path {self.interface.path}"
+                )
 
             cable_number, first_chain = jtag_mapping.groups()
             try:

labgrid/driver/shelldriver.py

@@ -99,9 +99,10 @@ def _run(self, cmd, *, timeout=30.0, codec="utf-8", decodeerrors="strict"):
         # hide marker from expect
         cmp_command = f'''MARKER='{marker[:4]}''{marker[4:]}' run {shlex.quote(cmd)}'''
         self.console.sendline(cmp_command)
-        _, _, match, _ = self.console.expect(r'{marker}(.*){marker}\s+(\d+)\s+{prompt}'.format(
-            marker=marker, prompt=self.prompt
-        ), timeout=timeout)
+        _, _, match, _ = self.console.expect(
+            rf'{marker}(.*){marker}\s+(\d+)\s+{self.prompt}',
+            timeout=timeout
+        )
         # Remove VT100 Codes, split by newline and remove surrounding newline
         data = self.re_vt100.sub('', match.group(1).decode(codec, decodeerrors)).split('\r\n')
         if data and not data[-1]:
@@ -198,7 +199,7 @@ def _check_prompt(self):
         self.console.sendline(f"echo '{marker[:4]}''{marker[4:]}'")
         try:
             self.console.expect(
-                r"{marker}\s+{prompt}".format(marker=marker, prompt=self.prompt),
+                rf"{marker}\s+{self.prompt}",
                 timeout=5
             )
             self._status = 1

labgrid/driver/smallubootdriver.py

@@ -86,7 +86,7 @@ def _run(self, cmd: str, *, timeout: int = 30, codec: str = "utf-8", decodeerror
         # handle it's error message as an echo-output.
         # additionally we are not able to get the command's return code and
         # will always return 0.
-        cmp_command = "echo{marker}; {cmd}; echo{marker}".format(marker=marker, cmd=cmd)
+        cmp_command = f"echo{marker}; {cmd}; echo{marker}"
 
         self.console.sendline(cmp_command)
         _, before, _, _ = self.console.expect(self.prompt, timeout=timeout)

labgrid/driver/sshdriver.py

@@ -137,16 +137,14 @@ def _start_own_master_once(self, timeout):
                     proxy_error = open(self.tmpdir+'/proxy-stderr').read().strip()
                     if proxy_error:
                         raise ExecutionError(
-                            "Failed to connect to {} with {}: error from SSH ProxyCommand: {}".
-                            format(self.networkservice.address, " ".join(args), proxy_error),
+                            f"Failed to connect to {self.networkservice.address} with {' '.join(args)}: error from SSH ProxyCommand: {proxy_error}",  # pylint: disable=line-too-long
                             stdout=stdout,
                         )
                 except FileNotFoundError:
                     pass
 
                 raise ExecutionError(
-                    "Failed to connect to {} with {}: return code {}".
-                    format(self.networkservice.address, " ".join(args), return_value),
+                    f"Failed to connect to {self.networkservice.address} with {' '.join(args)}: return code {return_value}",  # pylint: disable=line-too-long
                     stdout=stdout,
                 )
         except subprocess.TimeoutExpired:
@@ -275,7 +273,7 @@ def forward_local_port(self, remoteport, localport=None):
         if localport is None:
             localport = get_free_port()
 
-        forward = "-L%d:localhost:%d" % (localport, remoteport)
+        forward = f"-L{localport:d}:localhost:{remoteport:d}"
         with self._forward(forward):
             yield localport
 
@@ -297,7 +295,7 @@ def forward_remote_port(self, remoteport, localport):
         if not self._check_keepalive():
             raise ExecutionError("Keepalive no longer running")
 
-        forward = "-R%d:localhost:%d" % (remoteport, localport)
+        forward = f"-R{remoteport:d}:localhost:{localport:d}"
         with self._forward(forward):
             yield
 
@@ -442,12 +440,7 @@ def get(self, filename, destination="."):
 
     def _cleanup_own_master(self):
         """Exit the controlmaster and delete the tmpdir"""
-        complete_cmd = "ssh -x -o ControlPath={cpath} -O exit -p {port} -l {user} {host}".format(
-            cpath=self.control,
-            port=self.networkservice.port,
-            user=self.networkservice.username,
-            host=self.networkservice.address
-        ).split(' ')
+        complete_cmd = f"ssh -x -o ControlPath={self.control} -O exit -p {self.networkservice.port} -l {self.networkservice.username} {self.networkservice.address}".split(' ')  # pylint: disable=line-too-long
         res = subprocess.call(
             complete_cmd,
             stdin=subprocess.DEVNULL,

labgrid/driver/ubootdriver.py

@@ -73,13 +73,7 @@ def _run(self, cmd: str, *, timeout: int = 30, codec: str = "utf-8", decodeerror
         # TODO: use codec, decodeerrors
         # TODO: Shell Escaping for the U-Boot Shell
         marker = gen_marker()
-        cmp_command = """echo '{}''{}'; {}; echo "$?"; echo '{}''{}';""".format(
-            marker[:4],
-            marker[4:],
-            cmd,
-            marker[:4],
-            marker[4:],
-        )
+        cmp_command = f"""echo '{marker[:4]}''{marker[4:]}'; {cmd}; echo "$?"; echo '{marker[:4]}''{marker[4:]}';"""  # pylint: disable=line-too-long
         if self._status == 1:
             self.console.sendline(cmp_command)
             _, before, _, _ = self.console.expect(self.prompt, timeout=timeout)

labgrid/driver/usbtmc/keysight_dsox2000.py

@@ -1,20 +1,20 @@
 def get_channel_info(driver, channel):
     info = {}
-    info['BWLIMIT'] = driver.get_bool(":CHANnel%i:BWLimit?" % channel)
-    info['COUPLING'] = driver.get_str(":CHANnel%i:COUPling?" % channel).strip()
-    info['LABEL'] = driver.get_str(":CHANnel%i:LABel?" % channel)
-    info['PROBE'] = driver.get_decimal(":CHANnel%i:PROBe?" % channel)
-    info['PROBE:HEAD'] = driver.get_str(":CHANnel%i:PROBe:HEAD?" % channel).strip()
-    info['PROBE:ID'] = driver.get_str(":CHANnel%i:PROBe:ID?" % channel).strip()
-    info['PROBE:SKEW'] = driver.get_decimal(":CHANnel%i:PROBe:SKEW?" % channel)
-    info['PROBE:STYPE'] = driver.get_str(":CHANnel%i:PROBe:STYPe?" % channel).strip()
-    info['RANGE'] = driver.get_decimal(":CHANnel%i:RANGe?" % channel)
-    info['SCALE'] = driver.get_decimal(":CHANnel%i:SCALe?" % channel)
-    info['UNITS'] = driver.get_str(":CHANnel%i:UNITS?" % channel).strip()
+    info['BWLIMIT'] = driver.get_bool(f":CHANnel{channel:d}:BWLimit?")
+    info['COUPLING'] = driver.get_str(f":CHANnel{channel:d}:COUPling?").strip()
+    info['LABEL'] = driver.get_str(f":CHANnel{channel:d}:LABel?")
+    info['PROBE'] = driver.get_decimal(f":CHANnel{channel:d}:PROBe?")
+    info['PROBE:HEAD'] = driver.get_str(f":CHANnel{channel:d}:PROBe:HEAD?").strip()
+    info['PROBE:ID'] = driver.get_str(f":CHANnel{channel:d}:PROBe:ID?").strip()
+    info['PROBE:SKEW'] = driver.get_decimal(f":CHANnel{channel:d}:PROBe:SKEW?")
+    info['PROBE:STYPE'] = driver.get_str(f":CHANnel{channel:d}:PROBe:STYPe?").strip()
+    info['RANGE'] = driver.get_decimal(f":CHANnel{channel:d}:RANGe?")
+    info['SCALE'] = driver.get_decimal(f":CHANnel{channel:d}:SCALe?")
+    info['UNITS'] = driver.get_str(f":CHANnel{channel:d}:UNITS?").strip()
     return info
 
 def get_channel_values(driver, channel):
-    driver.command(":MEASURE:SOURCE CHANNEL%i" % channel)
+    driver.command(f":MEASURE:SOURCE CHANNEL{channel:d}")
     info = {}
     info['DUTYCYCLE'] = driver.get_decimal(":MEASURE:DUTYcycle?")
     info['FREQUENCY'] = driver.get_decimal(":MEASURE:FREQuency?")

labgrid/driver/usbtmc/tektronix_tds2000.py

@@ -1,16 +1,16 @@
 def get_channel_info(driver, channel):
     info = {}
-    info['SELECTED'] = driver.get_str("SELect:CH%i?" % channel).strip()
-    info['BWLIMIT'] = driver.get_str(":CH%i:BANdwidth?" % channel).strip()
-    info['COUPLING'] = driver.get_str(":CH%i:COUPling?" % channel).strip()
-    info['INVERT'] = driver.get_str(":CH%i:INVert?" % channel).strip()
-    info['POSITION'] = driver.get_decimal(":CH%i:POSition?" % channel)
-    info['PROBE'] = driver.get_decimal(":CH%i:PRObe?" % channel)
-    info['SCALE'] = driver.get_decimal(":CH%i:SCAle?" % channel)
+    info['SELECTED'] = driver.get_str(f"SELect:CH{channel:d)}?").strip()
+    info['BWLIMIT'] = driver.get_str(f":CH{channel:d}:BANdwidth?").strip()
+    info['COUPLING'] = driver.get_str(f":CH{channel:d}:COUPling?").strip()
+    info['INVERT'] = driver.get_str(f":CH{channel:d}:INVert?").strip()
+    info['POSITION'] = driver.get_decimal(f":CH{channel:d}:POSition?")
+    info['PROBE'] = driver.get_decimal(f":CH{channel:d}:PRObe?")
+    info['SCALE'] = driver.get_decimal(f":CH{channel:d}:SCAle?")
     return info
 
 def get_channel_values(driver, channel):
-    driver.command(":MEASUrement:IMMed:SOUrce1 CH%i" % channel)
+    driver.command(f":MEASUrement:IMMed:SOUrce1 CH{channel:d}")
     info = {}
     driver.command(":MEASUrement:IMMed:TYPe MEAN")
     info['MEAN'] = driver.get_decimal(":MEASUrement:IMMed:VALue?")

labgrid/driver/usbvideodriver.py

@@ -42,8 +42,9 @@ def select_caps(self, hint=None):
         for name, caps in variants:
             if name == variant:
                 return caps
-        raise InvalidConfigError("Unkown video format {} for device {:04x}:{:04x}".format(
-            variant, self.video.vendor_id, self.video.model_id))
+        raise InvalidConfigError(
+            f"Unkown video format {variant} for device {self.video.vendor_id:04x}:{self.video.model_id:04x}"  # pylint: disable=line-too-long
+        )
 
     def get_pipeline(self, path, caps, controls=None):
         match = (self.video.vendor_id, self.video.model_id)

labgrid/factory.py

@@ -123,7 +123,8 @@ def make_resource(self, target, resource, name, args):
             r = cls(target, name, **args)
         except TypeError as e:
             raise InvalidConfigError(
-                f"failed to create {resource} for target '{target}' using {args} ") from e
+                f"failed to create {resource} for target '{target}' using {args} "
+            ) from e
         return r
 
     def make_driver(self, target, driver, name, args):

labgrid/pytestplugin/hooks.py

@@ -76,9 +76,11 @@ def pytest_collection_modifyitems(config, items):
         missing_feature = want_feature - have_feature
         if missing_feature:
             if len(missing_feature) == 1:
-                skip = pytest.mark.skip(reason="Skipping because feature \"{}\" is not supported"
-                                        .format(missing_feature))
+                skip = pytest.mark.skip(
+                    reason=f'Skipping because feature "{missing_feature}" is not supported'
+                )
             else:
-                skip = pytest.mark.skip(reason="Skipping because features \"{}\" are not supported"
-                                        .format(missing_feature))
+                skip = pytest.mark.skip(
+                    reason=f'Skipping because features "{missing_feature}" are not supported'
+                )
             item.add_marker(skip)