Adding f-strings to device classes

.flake8

@@ -1,7 +1,7 @@
 [flake8]
 docstring_style=sphinx
 max-line-length = 127
-ignore = D400, Q000, P101, S311,  PLW, PLC, PLR
+ignore = D400, Q000, S311,  PLW, PLC, PLR
 per-file-ignores =
     buildhat/__init__.py:F401
 exclude = docs/conf.py, docs/sphinxcontrib/cmtinc-buildhat.py, docs/sphinx_selective_exclude/*.py

buildhat/color.py

@@ -210,4 +210,4 @@ def wait_for_new_color(self):
 
     def on(self):
         """Turn on the sensor and LED"""
-        self._write("port {} ; plimit 1 ; set -1\r".format(self.port))
+        self._write(f"port {self.port} ; plimit 1 ; set -1\r")

buildhat/colordistance.py

@@ -189,4 +189,4 @@ def wait_for_new_color(self):
 
     def on(self):
         """Turn on the sensor and LED"""
-        self._write("port {} ; plimit 1 ; set -1\r".format(self.port))
+        self._write(f"port {self.port} ; plimit 1 ; set -1\r")

buildhat/devices.py

@@ -62,8 +62,7 @@ def __init__(self, port):
             self._typeid in Device._device_names
             and Device._device_names[self._typeid][0] != type(self).__name__  # noqa: W503
         ) or self._typeid == -1:
-            raise DeviceError('There is not a {} connected to port {} (Found {})'.format(type(self).__name__,
-                                                                                         port, self.name))
+            raise DeviceError(f'There is not a {type(self).__name__} connected to port {port} (Found {self.name})')
         Device._used[p] = True
 
     @staticmethod
@@ -186,7 +185,7 @@ def isconnected(self):
 
     def reverse(self):
         """Reverse polarity"""
-        self._write("port {} ; plimit 1 ; set -1\r".format(self.port))
+        self._write(f"port {self.port} ; plimit 1 ; set -1\r")
 
     def get(self):
         """Extract information from device
@@ -202,7 +201,7 @@ def get(self):
             idx = self._combimode
         else:
             raise DeviceError("Not in simple or combimode")
-        self._write("port {} ; selonce {}\r".format(self.port, idx))
+        self._write(f"port {self.port} ; selonce {idx}\r")
         # wait for data
         with Device._instance.portcond[self.port]:
             Device._instance.portcond[self.port].wait()
@@ -218,13 +217,13 @@ def mode(self, modev):
             self._combimode = 0
             modestr = ""
             for t in modev:
-                modestr += "{} {} ".format(t[0], t[1])
-            self._write("port {} ; combi {} {}\r".format(self.port, self._combimode, modestr))
+                modestr += f"{t[0]} {t[1]} "
+            self._write(f"port {self.port} ; combi {self._combimode} {modestr}\r")
             self._simplemode = -1
         else:
             # Remove combi mode
             if self._combimode != -1:
-                self._write("port {} ; combi {}\r".format(self.port, self._combimode))
+                self._write(f"port {self.port} ; combi {self._combimode}\r")
             self._combimode = -1
             self._simplemode = int(modev)
 
@@ -240,26 +239,27 @@ def select(self):
             idx = self._combimode
         else:
             raise DeviceError("Not in simple or combimode")
-        self._write("port {} ; select {}\r".format(self.port, idx))
+        self._write(f"port {self.port} ; select {idx}\r")
 
     def on(self):
         """Turn on sensor"""
-        self._write("port {} ; plimit 1 ; on\r".format(self.port))
+        self._write(f"port {self.port} ; plimit 1 ; on\r")
 
     def off(self):
         """Turn off sensor"""
-        self._write("port {} ; off\r".format(self.port))
+        self._write(f"port {self.port} ; off\r")
 
     def deselect(self):
         """Unselect data from mode"""
-        self._write("port {} ; select\r".format(self.port))
+        self._write(f"port {self.port} ; select\r")
 
     def _write(self, cmd):
         self.isconnected()
         Device._instance.write(cmd.encode())
 
     def _write1(self, data):
-        self._write("port {} ; write1 {}\r".format(self.port, ' '.join('{:x}'.format(h) for h in data)))
+        hexstr = ' '.join(f'{h:x}' for h in data)
+        self._write(f"port {self.port} ; write1 {hexstr}\r")
 
     def callback(self, func):
         """Set callback function

buildhat/distance.py

@@ -164,4 +164,4 @@ def eyes(self, *args):
 
     def on(self):
         """Turn on the sensor"""
-        self._write("port {} ; set -1\r".format(self.port))
+        self._write(f"port {self.port} ; set -1\r")

buildhat/hat.py

@@ -54,7 +54,7 @@ def get_vin(self):
     def _set_led(self, intmode):
         if isinstance(intmode, int) and intmode >= -1 and intmode <= 3:
             self.led_status = intmode
-            Device._instance.write("ledmode {}\r".format(intmode).encode())
+            Device._instance.write(f"ledmode {intmode}\r".encode())
 
     def set_leds(self, color="voltage"):
         """Set the two LEDs on or off on the BuildHAT.

buildhat/light.py

@@ -30,4 +30,4 @@ def brightness(self, brightness):
         """
         if not (brightness >= 0 and brightness <= 100):
             raise LightError("Need brightness arg, of 0 to 100")
-        self._write("port {} ; on ; plimit {}\r".format(self.port, brightness / 100.0))
+        self._write(f"port {self.port} ; on ; plimit {brightness / 100.0}\r")

buildhat/motors.py

@@ -54,12 +54,12 @@ def start(self, speed=None):
             if not (speed >= -100 and speed <= 100):
                 raise MotorError("Invalid Speed")
         self._currentspeed = speed
-        cmd = "port {} ; pwm ; set {}\r".format(self.port, speed / 100)
+        cmd = f"port {self.port} ; pwm ; set {speed / 100}\r"
         self._write(cmd)
 
     def stop(self):
         """Stop motor"""
-        cmd = "port {} ; off\r".format(self.port)
+        cmd = f"port {self.port} ; off\r"
         self._write(cmd)
         self._currentspeed = 0
 
@@ -71,7 +71,7 @@ def plimit(self, plimit):
         """
         if not (plimit >= 0 and plimit <= 1):
             raise MotorError("plimit should be 0 to 1")
-        self._write("port {} ; plimit {}\r".format(self.port, plimit))
+        self._write(f"port {self.port} ; plimit {plimit}\r")
 
     def bias(self, bias):
         """Bias motor
@@ -81,7 +81,7 @@ def bias(self, bias):
         """
         if not (bias >= 0 and bias <= 1):
             raise MotorError("bias should be 0 to 1")
-        self._write("port {} ; bias {}\r".format(self.port, bias))
+        self._write(f"port {self.port} ; bias {bias}\r")
 
 
 class MotorRunmode(Enum):
@@ -192,8 +192,8 @@ def _run_positional_ramp(self, pos, newpos, speed):
         # Collapse speed range to -5 to 5
         speed *= 0.05
         dur = abs((newpos - pos) / speed)
-        cmd = "port {}; combi 0 1 0 2 0 3 0 ; select 0 ; pid {} 0 1 s4 0.0027777778 0 5 0 .1 3 ; set ramp {} {} {} 0\r".format(
-              self.port, self.port, pos, newpos, dur)
+        cmd = (f"port {self.port}; combi 0 1 0 2 0 3 0 ; select 0 ; pid {self.port} 0 1 s4 0.0027777778 0 5 0 .1 3 ; "
+               f"set ramp {pos} {newpos} {dur} 0\r")
         self._write(cmd)
         with self._hat.rampcond[self.port]:
             self._hat.rampcond[self.port].wait()
@@ -248,8 +248,8 @@ def run_to_position(self, degrees, speed=None, blocking=True, direction="shortes
 
     def _run_for_seconds(self, seconds, speed):
         self._runmode = MotorRunmode.SECONDS
-        cmd = "port {} ; combi 0 1 0 2 0 3 0 ; select 0 ; pid {} 0 0 s1 1 0 0.003 0.01 0 100; set pulse {} 0.0 {} 0\r".format(
-              self.port, self.port, speed, seconds)
+        cmd = (f"port {self.port} ; combi 0 1 0 2 0 3 0 ; select 0 ; pid {self.port} 0 0 s1 1 0 0.003 0.01 0 100; "
+               f"set pulse {speed} 0.0 {seconds} 0\r")
         self._write(cmd)
         with self._hat.pulsecond[self.port]:
             self._hat.pulsecond[self.port].wait()
@@ -296,10 +296,10 @@ def start(self, speed=None):
         else:
             if not (speed >= -100 and speed <= 100):
                 raise MotorError("Invalid Speed")
-        cmd = "port {} ; set {}\r".format(self.port, speed)
+        cmd = f"port {self.port} ; set {speed}\r"
         if self._runmode == MotorRunmode.NONE:
-            cmd = "port {} ; combi 0 1 0 2 0 3 0 ; select 0 ; pid {} 0 0 s1 1 0 0.003 0.01 0 100; set {}\r".format(
-                  self.port, self.port, speed)
+            cmd = (f"port {self.port} ; combi 0 1 0 2 0 3 0 ; select 0 ; pid {self.port} 0 0 s1 1 0 0.003 0.01 0 100; "
+                   f"set {speed}\r")
         self._runmode = MotorRunmode.FREE
         self._currentspeed = speed
         self._write(cmd)
@@ -372,7 +372,7 @@ def plimit(self, plimit):
         """
         if not (plimit >= 0 and plimit <= 1):
             raise MotorError("plimit should be 0 to 1")
-        self._write("port {} ; plimit {}\r".format(self.port, plimit))
+        self._write(f"port {self.port} ; plimit {plimit}\r")
 
     def bias(self, bias):
         """Bias motor
@@ -382,7 +382,7 @@ def bias(self, bias):
         """
         if not (bias >= 0 and bias <= 1):
             raise MotorError("bias should be 0 to 1")
-        self._write("port {} ; bias {}\r".format(self.port, bias))
+        self._write(f"port {self.port} ; bias {bias}\r")
 
     def pwm(self, pwmv):
         """PWM motor
@@ -392,11 +392,11 @@ def pwm(self, pwmv):
         """
         if not (pwmv >= -1 and pwmv <= 1):
             raise MotorError("pwm should be -1 to 1")
-        self._write("port {} ; pwm ; set {}\r".format(self.port, pwmv))
+        self._write(f"port {self.port} ; pwm ; set {pwmv}\r")
 
     def coast(self):
         """Coast motor"""
-        self._write("port {} ; coast\r".format(self.port))
+        self._write(f"port {self.port} ; coast\r")
 
     def float(self):
         """Float motor"""

buildhat/serinterface.py

@@ -191,13 +191,13 @@ def loadfirmware(self, firmware, signature):
             sig = f.read()
         self.write(b"clear\r")
         self.getprompt()
-        self.write("load {} {}\r".format(len(firm), self.checksum(firm)).encode())
+        self.write(f"load {len(firm)} {self.checksum(firm)}\r".encode())
         time.sleep(0.1)
         self.write(b"\x02", replace="0x02")
         self.write(firm, replace="--firmware file--")
         self.write(b"\x03\r", replace="0x03")
         self.getprompt()
-        self.write("signature {}\r".format(len(sig)).encode())
+        self.write(f"signature {len(sig)}\r".encode())
         time.sleep(0.1)
         self.write(b"\x02", replace="0x02")
         self.write(sig, replace="--signature file--")
@@ -239,9 +239,9 @@ def write(self, data, log=True, replace=""):
         self.ser.write(data)
         if not self.fin and log:
             if replace != "":
-                logging.info("> {}".format(replace))
+                logging.info(f"> {replace}")
             else:
-                logging.info("> {}".format(data.decode('utf-8', 'ignore').strip()))
+                logging.info(f"> {data.decode('utf-8', 'ignore').strip()}")
 
     def read(self):
         """Read data from the serial port of Build HAT
@@ -254,7 +254,7 @@ def read(self):
         except serial.SerialException:
             pass
         if line != "":
-            logging.info("< {}".format(line))
+            logging.info(f"< {line}")
         return line
 
     def shutdown(self):
@@ -269,11 +269,11 @@ def shutdown(self):
             for p in range(4):
                 conn = self.connections[p]
                 if conn.typeid != 64:
-                    turnoff += "port {} ; pwm ; coast ; off ;".format(p)
+                    turnoff += f"port {p} ; pwm ; coast ; off ;"
                 else:
-                    self.write("port {} ; write1 {}\r".format(p, ' '.join('{:x}'.format(h)
-                                                              for h in [0xc2, 0, 0, 0, 0, 0, 0, 0, 0, 0])).encode())
-            self.write("{}\r".format(turnoff).encode())
+                    hexstr = ' '.join(f'{h:x}' for h in [0xc2, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+                    self.write(f"port {p} ; write1 {hexstr}\r".encode())
+            self.write(f"{turnoff}\r".encode())
             self.write(b"port 0 ; select ; port 1 ; select ; port 2 ; select ; port 3 ; select ; echo 0\r")
 
     def callbackloop(self, q):
@@ -311,7 +311,7 @@ def loop(self, cond, uselist, q):
                     typeid = int(line[2 + len(BuildHAT.CONNECTED):], 16)
                     self.connections[portid].update(typeid, True)
                     if typeid == 64:
-                        self.write("port {} ; on\r".format(portid).encode())
+                        self.write(f"port {portid} ; on\r".encode())
                     if uselist:
                         count += 1
                 elif cmp(msg, BuildHAT.CONNECTEDPASSIVE):