fix: resolve issues identified by pylint

Author: feeph

feeph/i2c/burst_handler.py

@@ -77,8 +77,7 @@ def read_register(self, register: int, byte_count: int = 1, max_tries: int = 5)
             except RuntimeError as e:
                 LH.warning("[%s] Unable to read register 0x%02X (%i/%i): %s", __name__, register, cur_try, max_tries, e)
                 time.sleep(0.001)
-        else:
-            raise RuntimeError(f"Unable to read register 0x{register:02X} after {cur_try} attempts. Giving up.")
+        raise RuntimeError(f"Unable to read register 0x{register:02X} after {cur_try} attempts. Giving up.")
 
     def write_register(self, register: int, value: int, byte_count: int = 1, max_tries: int = 3):
         """
@@ -91,10 +90,9 @@ def write_register(self, register: int, value: int, byte_count: int = 1, max_tri
         """
         _validate_register_address(register)
         ba = convert_uint_to_bytearry(value, byte_count)
-        buf = bytearray(1 + len(ba))
-        buf[0] = register
-        for i in range(len(ba)):
-            buf[1+i] = ba[i]
+        buf = bytearray([register])
+        for byte in ba:
+            buf.append(byte)
         for cur_try in range(1, 1 + max_tries):
             try:
                 self._i2c_bus.writeto(address=self._i2c_adr, buffer=buf)
@@ -106,8 +104,7 @@ def write_register(self, register: int, value: int, byte_count: int = 1, max_tri
             except RuntimeError as e:
                 LH.warning("[%s] Unable to read register 0x%02X (%i/%i): %s", __name__, register, cur_try, max_tries, e)
                 time.sleep(0.1)
-        else:
-            raise RuntimeError(f"Unable to read register 0x{register:02X} after {cur_try} attempts. Giving up.")
+        raise RuntimeError(f"Unable to read register 0x{register:02X} after {cur_try} attempts. Giving up.")
 
     # it is unclear if it's possible to have a multi-byte state registers
     # (a register write looks exactly like a multi-byte state write)
@@ -135,8 +132,7 @@ def get_state(self, byte_count: int = 1, max_tries: int = 5) -> int:
             except RuntimeError as e:
                 LH.warning("[%s] Unable to read state (%i/%i): %s", __name__, cur_try, max_tries, e)
                 time.sleep(0.001)
-        else:
-            raise RuntimeError(f"Unable to read state after {cur_try} attempts. Giving up.")
+        raise RuntimeError(f"Unable to read state after {cur_try} attempts. Giving up.")
 
     def set_state(self, value: int, byte_count: int = 1, max_tries: int = 3):
         """
@@ -158,10 +154,9 @@ def set_state(self, value: int, byte_count: int = 1, max_tries: int = 3):
                 LH.warning("[%s] Failed to write state (%i/%i): %s",  __name__, cur_try, max_tries, e)
                 time.sleep(0.1)
             except RuntimeError as e:
-                LH.warning("[%s] Unable to write state 0x%02X (%i/%i): %s", __name__, cur_try, max_tries, e)
+                LH.warning("[%s] Unable to write state (%i/%i): %s", __name__, cur_try, max_tries, e)
                 time.sleep(0.1)
-        else:
-            raise RuntimeError(f"Unable to write state after {cur_try} attempts. Giving up.")
+        raise RuntimeError(f"Unable to write state after {cur_try} attempts. Giving up.")
 
 
 class BurstHandler:
@@ -182,6 +177,8 @@ def __init__(self, i2c_bus: busio.I2C, i2c_adr: int, timeout_ms: int | None = 50
             self._timeout_ms = timeout_ms
         else:
             raise ValueError("Provided timeout is not a positive integer or 'None'!")
+        # register '_timestart_ns' - we will populate it later on
+        self._timestart_ns = 0
 
     def __enter__(self) -> BurstHandle:
         """

feeph/i2c/emulation.py

@@ -21,6 +21,11 @@ class EmulatedI2C(busio.I2C):
     (e.g. duplicated registers with multiple addresses)
     """
 
+    # We intentionally do not call super().init() because we don't want to
+    # call any of the hardware initialization code. We are only interested
+    # in being able to claim we are an instance of 'busio.I2C' in case
+    # something else tries to validate that or has logic tied to it.
+    # pylint: disable=super-init-not-called
     def __init__(self, state: dict[int, dict[int, int]], lock_chance: int = 100):
         """
         initialize a simulated I2C bus
@@ -39,7 +44,7 @@ def __init__(self, state: dict[int, dict[int, int]], lock_chance: int = 100):
 
     def try_lock(self) -> bool:
         # may randomly fail to acquire a lock
-        return (random.randint(0, 100) < self._lock_chance)
+        return random.randint(0, 100) < self._lock_chance
 
     def unlock(self):
         pass
@@ -48,6 +53,8 @@ def unlock(self):
     # being read/written since the register address must be positive in the
     # range 0 ≤ x ≤ 255.
 
+    # replicate the signature of busio.I2C
+    # pylint: disable=too-many-arguments
     def readfrom_into(self, address, buffer, *, start=0, end=None, stop=True):
         """
         read device state
@@ -59,9 +66,12 @@ def readfrom_into(self, address, buffer, *, start=0, end=None, stop=True):
         value = self._state[i2c_device_address][i2c_device_register]
         ba = convert_uint_to_bytearry(value, len(buffer))
         # copy computed result to output parameter
+        # pylint: disable=consider-using-enumerate
         for i in range(len(buffer)):
             buffer[i] = ba[i]
 
+    # replicate the signature of busio.I2C
+    # pylint: disable=too-many-arguments
     def writeto(self, address: int, buffer: bytearray, *, start=0, end=None):
         """
         write device state or register
@@ -93,5 +103,6 @@ def writeto_then_readfrom(self, address: int, buffer_out: bytearray, buffer_in:
         value = self._state[i2c_device_address][i2c_device_register]
         ba = convert_uint_to_bytearry(value, len(buffer_in))
         # copy computed result to output parameter
+        # pylint: disable=consider-using-enumerate
         for i in range(len(buffer_in)):
             buffer_in[i] = ba[i]

tests/test_burst_handler.py

@@ -8,6 +8,7 @@
 import feeph.i2c as sut  # sytem under test
 
 
+# pylint: disable=protected-access
 class TestBurstHandler(unittest.TestCase):
 
     def test_read_device_register(self):