fix some style issues

bin/make_lock.py

@@ -2,7 +2,6 @@
 
 import sys
 import argparse
-import re
 from abc import ABCMeta, abstractmethod
 import os
 
@@ -36,6 +35,7 @@
                 help="Check for consistency and print"
                 "the bitmaps to stdout")
 
+
 class Bitmap(object):
     def __init__(self, width, height, buf=None):
         self.width = width
@@ -53,10 +53,10 @@ def __str__(self):
         lines = []
         for i in range(self.height):
             lines.append(''.join(
-                    'o' if bit else '.'
-                    for byte in self.buffer[i*self.pitch:(i+1)*self.pitch]
-                    for bit in ((byte >> j) & 0x1 for j in range(8))
-                    )[:self.width])
+                'o' if bit else '.'
+                for byte in self.buffer[i*self.pitch:(i+1)*self.pitch]
+                for bit in ((byte >> j) & 0x1 for j in range(8))
+            )[:self.width])
         return '\n'.join(lines)
 
     def wipe(self):
@@ -136,6 +136,7 @@ def __xor__(self, other):
         cpy |= other
         return cpy
 
+
 class ColorHandlerMeta(ABCMeta):
 
     def __new__(cls, name, bases, dict):
@@ -156,6 +157,7 @@ def _register_subclass(cls, sub_class, marked):
         else:
             cls._register_recurse(sub_class, marked)
 
+
 class ColorHandler(metaclass=ColorHandlerMeta):
     MODES = {}
 
@@ -205,6 +207,7 @@ def make_transparency_filter(self):
         else:
             return lambda x: False
 
+
 class PColorHander(ColorHandler):
     MODE = ['P']
 
@@ -215,6 +218,7 @@ def make_transparency_filter(self):
         else:
             return lambda x: False
 
+
 class OneColorHandler(ColorHandler):
     MODE = ['1']
 
@@ -230,7 +234,7 @@ def __init__(self, palette):
         self._palette = bytearray(palette.palette)
 
     def __getitem__(self, item):
-        return tuple(self._palette[i] for i in range(3*item, 3*item+3))
+        return tuple(self._palette[i] for i in range(3*item, 3*item + 3))
 
 
 class LockMaker(object):
@@ -252,7 +256,6 @@ def __init__(self, args):
         else:
             self.uni_image = True
 
-
         self._guess_size()
         self._guess_hotspot()
         self._guess_colors()
@@ -312,13 +315,10 @@ def _guess_hotspot(self):
 
     def _guess_colors(self):
         image_has_colors = False
-        bg_hist = self._histogram(self._bg_bitmap_raw)
-        if not self.uni_image:
-            fg_hist = self._histogram(self._fg_bitmap_raw)
 
         if self.uni_image:
+            bg_hist = self._histogram(self._bg_bitmap_raw)
             mode = self._bg_bitmap_raw.mode
-            info = self._bg_bitmap_raw.info
 
             bg_color_handler = ColorHandler.make(self._bg_bitmap_raw)
             tr_filter = bg_color_handler.make_transparency_filter()
@@ -371,7 +371,6 @@ def _guess_colors(self):
                 sys.exit(1)
         else:
             mode = self._bg_bitmap_raw.mode
-            info = self._bg_bitmap_raw.info
 
             mode_fg = self._fg_bitmap_raw.mode
             if mode_fg != mode:
@@ -402,8 +401,8 @@ def _guess_colors(self):
         else:
             if self.uni_image:
                 self.stroke_border = True
-            self.fg_color = (255,255,255)
-            self.bg_color = (0,0,0)
+            self.fg_color = (255, 255, 255)
+            self.bg_color = (0, 0, 0)
 
     def _histogram(self, PIL_img):
         hist = {}
@@ -424,13 +423,13 @@ def _stroke(self, PIL_img, bitmap, filter, wipe=True):
         for i in range(self.width):
             for j in range(self.height):
                 if filter(data[i, j]):
-                    bitmap[i,j] = 1
+                    bitmap[i, j] = 1
 
     def _stroke_border(self):
         def action(i, j, di, dj, in_img):
-            if self._bg_bitmap[i,j]:
+            if self._bg_bitmap[i, j]:
                 if not in_img:
-                    self._fg_bitmap[i,j] = 1
+                    self._fg_bitmap[i, j] = 1
                 return True
             else:
                 if in_img:
@@ -441,13 +440,12 @@ def finish(i, j, in_img):
             if in_img:
                 self._fg_bitmap[i, j] = 1
 
-
         # stroke vertically
         for i in range(self.width):
             in_img = False
             for j in range(self.height):
                 in_img = action(i, j, 0, 1, in_img)
-            finish(i, j,  in_img)
+            finish(i, j, in_img)
 
         # stroke horizontally
         for j in range(self.height):
@@ -500,6 +498,6 @@ def bg_bitmap(self):
             "y_hot": 1,
             "fg_bitmap": fg_bitmap,
             "bg_bitmap": bg_bitmap,
-            "bg_color": (0,0,0),
-            "fg_color": (0,0,0)
+            "bg_color": (0, 0, 0),
+            "fg_color": (0, 0, 0)
         }, f)

bin/pyxtrlock

@@ -5,7 +5,7 @@ import os
 import sys
 import time
 import getpass
-from ctypes import byref, cast, sizeof
+from ctypes import byref, cast
 from ctypes import POINTER, c_int, c_uint32, c_char
 
 from xdg.BaseDirectory import load_data_paths
@@ -116,8 +116,10 @@ xcb.map_window(conn, window)
 
 for i in range(100):
     try:
-        status = xcb.grab_keyboard_sync(conn, 0, window, xcb.CURRENT_TIME,
-                                        xcb.GRAB_MODE_ASYNC, xcb.GRAB_MODE_ASYNC)
+        status = xcb.grab_keyboard_sync(conn, 0, window,
+                                        xcb.CURRENT_TIME,
+                                        xcb.GRAB_MODE_ASYNC,
+                                        xcb.GRAB_MODE_ASYNC)
 
         if status == xcb.GrabSuccess:
             break

pyxtrlock/__init__.py

@@ -1,6 +1,5 @@
 
 import sys
-import os
 
 
 def panic(*message_parts, exit_code=1):

pyxtrlock/cursor_file.py

@@ -9,6 +9,7 @@
 
 MAX_CURSOR_SIZE = 512
 
+
 def _check_size(w, h, data):
     pitch = (w + 7) // 8
     size = pitch * h
@@ -45,7 +46,7 @@ def load_cursor(f):
     res = {}
 
     for attr in INTEGER_ATTRIBUTES:
-        if not (isinstance(cursor[attr], int)  and
+        if not (isinstance(cursor[attr], int) and
                 0 <= cursor[attr] <= MAX_CURSOR_SIZE):
             raise ValueError("{} must be integer".format(attr))
         res[attr] = cursor[attr]

pyxtrlock/utils.py

@@ -1,6 +1,7 @@
 from ctypes import cdll
 from ctypes.util import find_library
 
+
 def check_and_load_library(libname):
     handle = find_library(libname)
     if handle is None:

pyxtrlock/xcb.py

@@ -1,6 +1,7 @@
 from ctypes import *
 from pyxtrlock.utils import check_and_load_library
 
+
 class XCBError(Exception):
     """Raised on XCBErrors.
 
@@ -86,6 +87,7 @@ class Cookie(Structure):
         ("sequence", c_uint)
     ]
 
+
 VoidCookie = Cookie
 AllocNamedColorCookie = Cookie
 AllocColorCookie = Cookie
@@ -117,6 +119,7 @@ class AllocNamedColorReply(Structure):
         ("visual_blue", c_uint16)
     ]
 
+
 class AllocColorReply(Structure):
     _fields_ = [
         ("response_type", c_uint8),
@@ -167,6 +170,7 @@ def __str__(self):
                                ','.join(str(getattr(self, field))
                                         for field, _ in self._fields_))
 
+
 class GenericEvent(Structure):
     _fields_ = [
         ("response_type", c_uint8),
@@ -176,9 +180,11 @@ class GenericEvent(Structure):
         ("full_sequence", c_uint32)
     ]
 
+
 Keycode = c_uint8
 Timestamp = c_uint32
 
+
 class KeyPressEvent(Structure):
     _fields_ = [
         ("response_type", c_uint8),
@@ -198,7 +204,6 @@ class KeyPressEvent(Structure):
     ]
 
 
-
 GrabKeyboardReply = GrabReply
 GrabPointerReply = GrabReply
 
@@ -321,6 +326,7 @@ def alloc_named_color_sync(conn, colormap, color_string):
     free(res)
     return ret
 
+
 def alloc_color_sync(conn, colormap, r, g, b):
     """Synchronously allocate a color
 
@@ -349,6 +355,7 @@ def alloc_color_sync(conn, colormap, r, g, b):
     free(res)
     return ret
 
+
 request_check = libxcb.xcb_request_check
 request_check.argtypes = [POINTER(Connection), VoidCookie]
 request_check.restype = POINTER(GenericError)
@@ -387,14 +394,17 @@ def create_cursor_sync(conn, source, mask, fg, bg, x, y):
 
     return cursor
 
+
 map_window = libxcb.xcb_map_window
 map_window.argtypes = [POINTER(Connection), Window]
 map_window.restype = VoidCookie
 
+
 flush = libxcb.xcb_flush
 flush.argtypes = [POINTER(Connection)]
 flush.restype = c_int
 
+
 grab_keyboard = libxcb.xcb_grab_keyboard
 grab_keyboard.argtypes = [
     POINTER(Connection),    # connection
@@ -406,6 +416,7 @@ def create_cursor_sync(conn, source, mask, fg, bg, x, y):
 ]
 grab_keyboard.restype = GrabKeyboardCookie
 
+
 grab_keyboard_reply = libxcb.xcb_grab_keyboard_reply
 grab_keyboard_reply.argtypes = [
     POINTER(Connection),    # connection
@@ -459,13 +470,15 @@ def grab_keyboard_sync(conn, owner_events, grab_window, time, ptr_mode,
 ]
 grab_pointer_reply.restype = POINTER(GrabPointerReply)
 
+
 # constants to interpret grab results
 GrabSuccess = 0
 AlreadyGrabbed = 1
 GrabInvalidTime = 2
 GrabNotViewable = 3
 GrabFrozen = 4
 
+
 def grab_pointer_sync(conn, owner_events, window, event_mask, ptr_mode,
                       kbd_mode, confine_to, cursor, timestamp):
     """
@@ -486,14 +499,17 @@ def grab_pointer_sync(conn, owner_events, window, event_mask, ptr_mode,
     free(ptr_grab)
     return status
 
+
 wait_for_event_ = libxcb.xcb_wait_for_event
 wait_for_event_.argtypes = [POINTER(Connection)]
 wait_for_event_.restype = POINTER(GenericEvent)
 
+
 free = libc.free
 free.argtypes = [c_void_p]
 free.restype = None
 
+
 class FreeWrapper(object):
 
     def __init__(self, pointer):
@@ -509,12 +525,14 @@ def __exit__(self, etype, evalue, traceback):
 def wait_for_event(conn):
     return FreeWrapper(wait_for_event_(conn))
 
+
 connection_has_error = libxcb.xcb_connection_has_error
 connection_has_error.restype = c_int
 connection_has_error.argtypes = [
     POINTER(Connection),
 ]
 
+
 # xcb_image
 image_create_pixmap_from_bitmap_data = \
     libxcb_image.xcb_create_pixmap_from_bitmap_data