Lint!

Author: tannewt

adafruit_imageload/__init__.py

@@ -41,11 +41,10 @@ def load(filename, *, bitmap=None, palette=None):
        palette is the desired pallete type. The constructor should take the number of colors and
        support assignment to indices via [].
     """
-    with open(filename, "rb") as f:
-        header = f.read(3)
+    with open(filename, "rb") as file:
+        header = file.read(3)
         if header.startswith(b"BM"):
             from . import bmp
-            f.seek(0)
-            return bmp.load(f, bitmap=bitmap, palette=palette)
-        else:
-            raise RuntimeError("Unsupported image format")
+            file.seek(0)
+            return bmp.load(file, bitmap=bitmap, palette=palette)
+        raise RuntimeError("Unsupported image format")

adafruit_imageload/bmp/__init__.py

@@ -32,25 +32,33 @@
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ImageLoad.git"
 
-def load(f, *, bitmap=None, palette=None):
-    f.seek(10)
-    data_start = int.from_bytes(f.read(4), 'little')
+def load(file, *, bitmap=None, palette=None):
+    """Loads a bmp image from the open ``file``.
+
+       Returns tuple of bitmap object and palette object.
+
+       :param object bitmap: Type to store bitmap data. Must have API similar to `displayio.Bitmap`.
+         Will be skipped if None
+       :param object palette: Type to store the palette. Must have API similar to
+         `displayio.Palette`. Will be skipped if None"""
+    file.seek(10)
+    data_start = int.from_bytes(file.read(4), 'little')
     # f.seek(14)
-    # bmp_header_length = int.from_bytes(f.read(4), 'little')
+    # bmp_header_length = int.from_bytes(file.read(4), 'little')
     # print(bmp_header_length)
-    f.seek(18)
-    width = int.from_bytes(f.read(4), 'little')
-    height = int.from_bytes(f.read(4), 'little')
-    f.seek(28)
-    color_depth = int.from_bytes(f.read(2), 'little')
-    f.seek(46)
-    colors = int.from_bytes(f.read(4), 'little')
-
-    compute_palette = False
+    file.seek(18)
+    width = int.from_bytes(file.read(4), 'little')
+    height = int.from_bytes(file.read(4), 'little')
+    file.seek(28)
+    color_depth = int.from_bytes(file.read(2), 'little')
+    file.seek(46)
+    colors = int.from_bytes(file.read(4), 'little')
+
     if colors == 0 and color_depth >= 16:
         raise NotImplementedError("True color BMP unsupported")
     else:
         if colors == 0:
             colors = 2 ** color_depth
         from . import indexed
-        return indexed.load(f, width, height, data_start, colors, color_depth, bitmap=bitmap, palette=palette)
+        return indexed.load(file, width, height, data_start, colors, color_depth, bitmap=bitmap,
+                            palette=palette)

adafruit_imageload/bmp/indexed.py

@@ -32,38 +32,45 @@
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ImageLoad.git"
 
-import math
+def load(file, width, height, data_start, colors, color_depth, *, bitmap=None, palette=None):
+    """Loads indexed bitmap data into bitmap and palette objects.
 
-def load(f, width, height, data_start, colors, color_depth, *, bitmap=None, palette=None):
+       :param file file: The open bmp file
+       :param int width: Image width in pixels
+       :param int height: Image height in pixels
+       :param int data_start: Byte location where the data starts (after headers)
+       :param int colors: Number of distinct colors in the image
+       :param int color_depth: Number of bits used to store a value"""
+    # pylint: disable=too-many-arguments,too-many-locals
     if palette:
         palette = palette(colors)
 
-        f.seek(data_start - colors * 4)
-        for color in range(colors):
-            c = f.read(4)
-            palette[color] = c
+        file.seek(data_start - colors * 4)
+        for value in range(colors):
+            palette[value] = file.read(4)
 
     if bitmap:
         minimum_color_depth = 1
         while colors > 2 ** minimum_color_depth:
             minimum_color_depth *= 2
 
         bitmap = bitmap(width, height, colors)
-        f.seek(data_start)
+        file.seek(data_start)
         line_size = width // (8 // color_depth)
         if line_size % 4 != 0:
             line_size += (4 - line_size % 4)
 
         chunk = bytearray(line_size)
+        mask = (1 << minimum_color_depth) - 1
 
-        for y in range(height-1,-1,-1):
-            f.readinto(chunk)
+        for y in range(height - 1, -1, -1):
+            file.readinto(chunk)
             pixels_per_byte = 8 // color_depth
             offset = y * width
 
             for x in range(width):
-                ci = x // pixels_per_byte
-                pixel = (chunk[ci] >> (8 - color_depth*(x % pixels_per_byte + 1))) & ((1 << minimum_color_depth) - 1)
+                i = x // pixels_per_byte
+                pixel = (chunk[i] >> (8 - color_depth*(x % pixels_per_byte + 1))) & mask
                 bitmap[offset + x] = pixel
 
     return bitmap, palette