Merge pull request #37 from adafruit/pylint-update

Ran black, updated to pylint 2.x

.github/workflows/build.yml

@@ -40,7 +40,7 @@ jobs:
         source actions-ci/install.sh
     - name: Pip install pylint, black, & Sphinx
       run: |
-        pip install --force-reinstall pylint==1.9.2 black==19.10b0 Sphinx sphinx-rtd-theme
+        pip install --force-reinstall pylint black==19.10b0 Sphinx sphinx-rtd-theme
     - name: Library version
       run: git describe --dirty --always --tags
     - name: PyLint

.pylintrc

@@ -119,7 +119,8 @@ spelling-store-unknown-words=no
 [MISCELLANEOUS]
 
 # List of note tags to take in consideration, separated by a comma.
-notes=FIXME,XXX,TODO
+# notes=FIXME,XXX,TODO
+notes=FIXME,XXX
 
 
 [TYPECHECK]

adafruit_register/i2c_bcd_alarm.py

@@ -35,6 +35,7 @@
 
 import time
 
+
 def _bcd2bin(value):
     """Convert binary coded decimal to Binary
 
@@ -50,9 +51,11 @@ def _bin2bcd(value):
     """
     return value + 6 * (value // 10)
 
+
 ALARM_COMPONENT_DISABLED = 0x80
 FREQUENCY = ["secondly", "minutely", "hourly", "daily", "weekly", "monthly"]
 
+
 class BCDAlarmTimeRegister:
     """
     Alarm date and time register using binary coded decimal structure.
@@ -80,8 +83,11 @@ class BCDAlarmTimeRegister:
     :param int weekday_start: 0 or 1 depending on the RTC's representation of the first day of the
       week (Monday)
     """
+
     # Defaults are based on alarm1 of the DS3231.
-    def __init__(self, register_address, has_seconds=True, weekday_shared=True, weekday_start=1):
+    def __init__(
+        self, register_address, has_seconds=True, weekday_shared=True, weekday_start=1
+    ):
         buffer_size = 5
         if weekday_shared:
             buffer_size -= 1
@@ -106,33 +112,33 @@ def __get__(self, obj, objtype=None):
                 frequency = "secondly"
             else:
                 frequency = "minutely"
-                seconds = _bcd2bin(self.buffer[1] & 0x7f)
+                seconds = _bcd2bin(self.buffer[1] & 0x7F)
             i = 2
         minute = 0
         if (self.buffer[i] & 0x80) == 0:
             frequency = "hourly"
-            minute = _bcd2bin(self.buffer[i] & 0x7f)
+            minute = _bcd2bin(self.buffer[i] & 0x7F)
 
         hour = 0
         if (self.buffer[i + 1] & 0x80) == 0:
             frequency = "daily"
-            hour = _bcd2bin(self.buffer[i + 1] & 0x7f)
+            hour = _bcd2bin(self.buffer[i + 1] & 0x7F)
 
         mday = None
         wday = None
         if (self.buffer[i + 2] & 0x80) == 0:
             # day of the month
             if not self.weekday_shared or (self.buffer[i + 2] & 0x40) == 0:
                 frequency = "monthly"
-                mday = _bcd2bin(self.buffer[i + 2] & 0x3f)
-            else: # weekday
+                mday = _bcd2bin(self.buffer[i + 2] & 0x3F)
+            else:  # weekday
                 frequency = "weekly"
-                wday = _bcd2bin(self.buffer[i + 2] & 0x3f) - self.weekday_start
+                wday = _bcd2bin(self.buffer[i + 2] & 0x3F) - self.weekday_start
 
         # weekday
         if not self.weekday_shared and (self.buffer[i + 3] & 0x80) == 0:
             frequency = "monthly"
-            mday = _bcd2bin(self.buffer[i + 3] & 0x7f)
+            mday = _bcd2bin(self.buffer[i + 3] & 0x7F)
 
         if mday is not None:
             wday = (mday - 2) % 7
@@ -143,7 +149,10 @@ def __get__(self, obj, objtype=None):
             wday = 6
             mday = 1
 
-        return (time.struct_time((2017, 1, mday, hour, minute, seconds, wday, mday, -1)), frequency)
+        return (
+            time.struct_time((2017, 1, mday, hour, minute, seconds, wday, mday, -1)),
+            frequency,
+        )
 
     def __set__(self, obj, value):
         if len(value) != 2:
@@ -163,18 +172,20 @@ def __set__(self, obj, value):
         # i is the index of the minute byte
         i = 2 if self.has_seconds else 1
 
-        if frequency > 0 and self.has_seconds: # minutely at least
+        if frequency > 0 and self.has_seconds:  # minutely at least
             self.buffer[1] = _bin2bcd(value[0].tm_sec)
 
-        if frequency > 1: # hourly at least
+        if frequency > 1:  # hourly at least
             self.buffer[i] = _bin2bcd(value[0].tm_min)
 
-        if frequency > 2: # daily at least
+        if frequency > 2:  # daily at least
             self.buffer[i + 1] = _bin2bcd(value[0].tm_hour)
 
         if value[1] == "weekly":
             if self.weekday_shared:
-                self.buffer[i + 2] = _bin2bcd(value[0].tm_wday + self.weekday_start) | 0x40
+                self.buffer[i + 2] = (
+                    _bin2bcd(value[0].tm_wday + self.weekday_start) | 0x40
+                )
             else:
                 self.buffer[i + 3] = _bin2bcd(value[0].tm_wday + self.weekday_start)
         elif value[1] == "monthly":

adafruit_register/i2c_bcd_datetime.py

@@ -34,6 +34,7 @@
 
 import time
 
+
 def _bcd2bin(value):
     """Convert binary coded decimal to Binary
 
@@ -49,6 +50,7 @@ def _bin2bcd(value):
     """
     return value + 6 * (value // 10)
 
+
 class BCDDateTimeRegister:
     """
     Date and time register using binary coded decimal structure.
@@ -66,6 +68,7 @@ class BCDDateTimeRegister:
     :param int weekday_start: 0 or 1 depending on the RTC's representation of the first day of the
         week
     """
+
     def __init__(self, register_address, weekday_first=True, weekday_start=1):
         self.buffer = bytearray(8)
         self.buffer[0] = register_address
@@ -79,22 +82,27 @@ def __get__(self, obj, objtype=None):
         # Read and return the date and time.
         with obj.i2c_device as i2c:
             i2c.write_then_readinto(self.buffer, self.buffer, out_end=1, in_start=1)
-        return time.struct_time((_bcd2bin(self.buffer[7]) + 2000,
-                                 _bcd2bin(self.buffer[6]),
-                                 _bcd2bin(self.buffer[5 - self.weekday_offset]),
-                                 _bcd2bin(self.buffer[3]),
-                                 _bcd2bin(self.buffer[2]),
-                                 _bcd2bin(self.buffer[1] & 0x7F),
-                                 _bcd2bin(self.buffer[4 + self.weekday_offset] -
-                                          self.weekday_start),
-                                 -1,
-                                 -1))
+        return time.struct_time(
+            (
+                _bcd2bin(self.buffer[7]) + 2000,
+                _bcd2bin(self.buffer[6]),
+                _bcd2bin(self.buffer[5 - self.weekday_offset]),
+                _bcd2bin(self.buffer[3]),
+                _bcd2bin(self.buffer[2]),
+                _bcd2bin(self.buffer[1] & 0x7F),
+                _bcd2bin(self.buffer[4 + self.weekday_offset] - self.weekday_start),
+                -1,
+                -1,
+            )
+        )
 
     def __set__(self, obj, value):
-        self.buffer[1] = _bin2bcd(value.tm_sec) & 0x7F   # format conversions
+        self.buffer[1] = _bin2bcd(value.tm_sec) & 0x7F  # format conversions
         self.buffer[2] = _bin2bcd(value.tm_min)
         self.buffer[3] = _bin2bcd(value.tm_hour)
-        self.buffer[4 + self.weekday_offset] = _bin2bcd(value.tm_wday + self.weekday_start)
+        self.buffer[4 + self.weekday_offset] = _bin2bcd(
+            value.tm_wday + self.weekday_start
+        )
         self.buffer[5 - self.weekday_offset] = _bin2bcd(value.tm_mday)
         self.buffer[6] = _bin2bcd(value.tm_mon)
         self.buffer[7] = _bin2bcd(value.tm_year - 2000)

adafruit_register/i2c_bit.py

@@ -32,6 +32,7 @@
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Register.git"
 
+
 class RWBit:
     """
     Single bit register that is readable and writeable.
@@ -44,31 +45,31 @@ class RWBit:
     :param bool lsb_first: Is the first byte we read from I2C the LSB? Defaults to true
 
     """
+
     def __init__(self, register_address, bit, register_width=1, lsb_first=True):
-        self.bit_mask = 1 << (bit%8) # the bitmask *within* the byte!
+        self.bit_mask = 1 << (bit % 8)  # the bitmask *within* the byte!
         self.buffer = bytearray(1 + register_width)
         self.buffer[0] = register_address
         if lsb_first:
             self.byte = bit // 8 + 1  # the byte number within the buffer
         else:
-            self.byte = register_width - (bit // 8) # the byte number within the buffer
+            self.byte = register_width - (bit // 8)  # the byte number within the buffer
 
     def __get__(self, obj, objtype=None):
         with obj.i2c_device as i2c:
-            i2c.write_then_readinto(self.buffer, self.buffer,
-                                    out_end=1, in_start=1)
+            i2c.write_then_readinto(self.buffer, self.buffer, out_end=1, in_start=1)
         return bool(self.buffer[self.byte] & self.bit_mask)
 
     def __set__(self, obj, value):
         with obj.i2c_device as i2c:
-            i2c.write_then_readinto(self.buffer, self.buffer,
-                                    out_end=1, in_start=1)
+            i2c.write_then_readinto(self.buffer, self.buffer, out_end=1, in_start=1)
             if value:
                 self.buffer[self.byte] |= self.bit_mask
             else:
                 self.buffer[self.byte] &= ~self.bit_mask
             i2c.write(self.buffer)
 
+
 class ROBit(RWBit):
     """Single bit register that is read only. Subclass of `RWBit`.
 
@@ -79,5 +80,6 @@ class ROBit(RWBit):
     :param int register_width: The number of bytes in the register. Defaults to 1.
 
     """
+
     def __set__(self, obj, value):
         raise AttributeError()

adafruit_register/i2c_bits.py

@@ -32,6 +32,7 @@
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Register.git"
 
+
 class RWBits:
     """
     Multibit register (less than a full byte) that is readable and writeable.
@@ -45,11 +46,13 @@ class RWBits:
     :param int register_width: The number of bytes in the register. Defaults to 1.
     :param bool lsb_first: Is the first byte we read from I2C the LSB? Defaults to true
     """
-    def __init__(self, num_bits, register_address, lowest_bit, # pylint: disable=too-many-arguments
-                 register_width=1, lsb_first=True):
-        self.bit_mask = ((1 << num_bits)-1)  << lowest_bit
-        #print("bitmask: ",hex(self.bit_mask))
-        if self.bit_mask >= 1 << (register_width*8):
+
+    def __init__(  # pylint: disable=too-many-arguments
+        self, num_bits, register_address, lowest_bit, register_width=1, lsb_first=True,
+    ):
+        self.bit_mask = ((1 << num_bits) - 1) << lowest_bit
+        # print("bitmask: ",hex(self.bit_mask))
+        if self.bit_mask >= 1 << (register_width * 8):
             raise ValueError("Cannot have more bits than register size")
         self.lowest_bit = lowest_bit
         self.buffer = bytearray(1 + register_width)
@@ -61,32 +64,33 @@ def __get__(self, obj, objtype=None):
             i2c.write_then_readinto(self.buffer, self.buffer, out_end=1, in_start=1)
         # read the number of bytes into a single variable
         reg = 0
-        order = range(len(self.buffer)-1, 0, -1)
+        order = range(len(self.buffer) - 1, 0, -1)
         if not self.lsb_first:
             order = reversed(order)
         for i in order:
             reg = (reg << 8) | self.buffer[i]
         return (reg & self.bit_mask) >> self.lowest_bit
 
     def __set__(self, obj, value):
-        value <<= self.lowest_bit    # shift the value over to the right spot
+        value <<= self.lowest_bit  # shift the value over to the right spot
         with obj.i2c_device as i2c:
             i2c.write_then_readinto(self.buffer, self.buffer, out_end=1, in_start=1)
             reg = 0
-            order = range(len(self.buffer)-1, 0, -1)
+            order = range(len(self.buffer) - 1, 0, -1)
             if not self.lsb_first:
                 order = range(1, len(self.buffer))
             for i in order:
                 reg = (reg << 8) | self.buffer[i]
-            #print("old reg: ", hex(reg))
+            # print("old reg: ", hex(reg))
             reg &= ~self.bit_mask  # mask off the bits we're about to change
-            reg |= value           # then or in our new value
-            #print("new reg: ", hex(reg))
+            reg |= value  # then or in our new value
+            # print("new reg: ", hex(reg))
             for i in reversed(order):
                 self.buffer[i] = reg & 0xFF
                 reg >>= 8
             i2c.write(self.buffer)
 
+
 class ROBits(RWBits):
     """
     Multibit register (less than a full byte) that is read-only. This must be
@@ -99,5 +103,6 @@ class ROBits(RWBits):
     :param type lowest_bit: The lowest bits index within the byte at ``register_address``
     :param int register_width: The number of bytes in the register. Defaults to 1.
     """
+
     def __set__(self, obj, value):
         raise AttributeError()

adafruit_register/i2c_struct.py

@@ -48,9 +48,10 @@ class Struct:
     :param int register_address: The register address to read the bit from
     :param type struct_format: The struct format string for this register.
     """
+
     def __init__(self, register_address, struct_format):
         self.format = struct_format
-        self.buffer = bytearray(1+struct.calcsize(self.format))
+        self.buffer = bytearray(1 + struct.calcsize(self.format))
         self.buffer[0] = register_address
 
     def __get__(self, obj, objtype=None):
@@ -74,19 +75,20 @@ class UnaryStruct:
     :param int register_address: The register address to read the bit from
     :param type struct_format: The struct format string for this register.
     """
+
     def __init__(self, register_address, struct_format):
         self.format = struct_format
         self.address = register_address
 
     def __get__(self, obj, objtype=None):
-        buf = bytearray(1+struct.calcsize(self.format))
+        buf = bytearray(1 + struct.calcsize(self.format))
         buf[0] = self.address
         with obj.i2c_device as i2c:
             i2c.write_then_readinto(buf, buf, out_end=1, in_start=1)
         return struct.unpack_from(self.format, buf, 1)[0]
 
     def __set__(self, obj, value):
-        buf = bytearray(1+struct.calcsize(self.format))
+        buf = bytearray(1 + struct.calcsize(self.format))
         buf[0] = self.address
         struct.pack_into(self.format, buf, 1, value)
         with obj.i2c_device as i2c:
@@ -103,5 +105,6 @@ class ROUnaryStruct(UnaryStruct):
     :param int register_address: The register address to read the bit from
     :param type struct_format: The struct format string for this register.
     """
+
     def __set__(self, obj, value):
         raise AttributeError()