debugpy 1.8.5__zip → 1.8.6__zip

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/textio.py

@@ -44,16 +44,16 @@ Functions for text input, logging or text output.
 
 __revision__ = "$Id$"
 
-__all__ =   [
-                'HexDump',
-                'HexInput',
-                'HexOutput',
-                'Color',
-                'Table',
-                'CrashDump',
-                'DebugLog',
-                'Logger',
-            ]
+__all__ = [
+    "HexDump",
+    "HexInput",
+    "HexOutput",
+    "Color",
+    "Table",
+    "CrashDump",
+    "DebugLog",
+    "Logger",
+]
 
 import sys
 from winappdbg import win32
@@ -65,9 +65,10 @@ import time
 import struct
 import traceback
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
-class HexInput (StaticClass):
+
+class HexInput(StaticClass):
     """
     Static functions for user input parsing.
     The counterparts for each method are in the L{HexOutput} class.
@@ -86,20 +87,20 @@ class HexInput (StaticClass):
         """
         token = token.strip()
         neg = False
-        if token.startswith(compat.b('-')):
+        if token.startswith(compat.b("-")):
             token = token[1:]
             neg = True
-        if token.startswith(compat.b('0x')):
-            result = int(token, 16)     # hexadecimal
-        elif token.startswith(compat.b('0b')):
+        if token.startswith(compat.b("0x")):
+            result = int(token, 16)  # hexadecimal
+        elif token.startswith(compat.b("0b")):
             result = int(token[2:], 2)  # binary
-        elif token.startswith(compat.b('0o')):
-            result = int(token, 8)      # octal
+        elif token.startswith(compat.b("0o")):
+            result = int(token, 8)  # octal
         else:
             try:
-                result = int(token)     # decimal
+                result = int(token)  # decimal
             except ValueError:
-                result = int(token, 16) # hexadecimal (no "0x" prefix)
+                result = int(token, 16)  # hexadecimal (no "0x" prefix)
         if neg:
             result = -result
         return result
@@ -128,14 +129,14 @@ class HexInput (StaticClass):
         @rtype:  str
         @return: Parsed string value.
         """
-        token = ''.join([ c for c in token if c.isalnum() ])
+        token = "".join([c for c in token if c.isalnum()])
         if len(token) % 2 != 0:
             raise ValueError("Missing characters in hex data")
-        data = ''
+        data = ""
         for i in compat.xrange(0, len(token), 2):
-            x = token[i:i+2]
+            x = token[i : i + 2]
             d = int(x, 16)
-            s = struct.pack('<B', d)
+            s = struct.pack("<B", d)
             data += s
         return data
 
@@ -158,24 +159,24 @@ class HexInput (StaticClass):
         @rtype:  str
         @return: Parsed string value.
         """
-        token = ''.join([ c for c in token if c == '?' or c.isalnum() ])
+        token = "".join([c for c in token if c == "?" or c.isalnum()])
         if len(token) % 2 != 0:
             raise ValueError("Missing characters in hex data")
-        regexp = ''
+        regexp = ""
         for i in compat.xrange(0, len(token), 2):
-            x = token[i:i+2]
-            if x == '??':
-                regexp += '.'
-            elif x[0] == '?':
-                f = '\\x%%.1x%s' % x[1]
-                x = ''.join([ f % c for c in compat.xrange(0, 0x10) ])
-                regexp = '%s[%s]' % (regexp, x)
-            elif x[1] == '?':
-                f = '\\x%s%%.1x' % x[0]
-                x = ''.join([ f % c for c in compat.xrange(0, 0x10) ])
-                regexp = '%s[%s]' % (regexp, x)
+            x = token[i : i + 2]
+            if x == "??":
+                regexp += "."
+            elif x[0] == "?":
+                f = "\\x%%.1x%s" % x[1]
+                x = "".join([f % c for c in compat.xrange(0, 0x10)])
+                regexp = "%s[%s]" % (regexp, x)
+            elif x[1] == "?":
+                f = "\\x%s%%.1x" % x[0]
+                x = "".join([f % c for c in compat.xrange(0, 0x10)])
+                regexp = "%s[%s]" % (regexp, x)
             else:
-                regexp = '%s\\x%s' % (regexp, x)
+                regexp = "%s\\x%s" % (regexp, x)
         return regexp
 
     @staticmethod
@@ -215,13 +216,13 @@ class HexInput (StaticClass):
         @rtype:  list( int )
         @return: List of integers read from the file.
         """
-        count  = 0
+        count = 0
         result = list()
-        fd     = open(filename, 'r')
+        fd = open(filename, "r")
         for line in fd:
             count = count + 1
-            if '#' in line:
-                line = line[ : line.find('#') ]
+            if "#" in line:
+                line = line[: line.find("#")]
             line = line.strip()
             if line:
                 try:
@@ -252,13 +253,13 @@ class HexInput (StaticClass):
         @rtype:  list
         @return: List of integers and strings read from the file.
         """
-        count  = 0
+        count = 0
         result = list()
-        fd     = open(filename, 'r')
+        fd = open(filename, "r")
         for line in fd:
             count = count + 1
-            if '#' in line:
-                line = line[ : line.find('#') ]
+            if "#" in line:
+                line = line[: line.find("#")]
             line = line.strip()
             if line:
                 result.append(line)
@@ -287,13 +288,13 @@ class HexInput (StaticClass):
         @rtype:  list
         @return: List of integers and strings read from the file.
         """
-        count  = 0
+        count = 0
         result = list()
-        fd     = open(filename, 'r')
+        fd = open(filename, "r")
         for line in fd:
             count = count + 1
-            if '#' in line:
-                line = line[ : line.find('#') ]
+            if "#" in line:
+                line = line[: line.find("#")]
             line = line.strip()
             if line:
                 try:
@@ -303,9 +304,11 @@ class HexInput (StaticClass):
                 result.append(value)
         return result
 
-#------------------------------------------------------------------------------
 
-class HexOutput (StaticClass):
+# ------------------------------------------------------------------------------
+
+
+class HexOutput(StaticClass):
     """
     Static functions for user output parsing.
     The counterparts for each method are in the L{HexInput} class.
@@ -319,11 +322,11 @@ class HexOutput (StaticClass):
         This value is platform dependent.
     """
 
-    integer_size = (win32.SIZEOF(win32.DWORD)  * 2) + 2
+    integer_size = (win32.SIZEOF(win32.DWORD) * 2) + 2
     address_size = (win32.SIZEOF(win32.SIZE_T) * 2) + 2
 
     @classmethod
-    def integer(cls, integer, bits = None):
+    def integer(cls, integer, bits=None):
         """
         @type  integer: int
         @param integer: Integer.
@@ -341,11 +344,11 @@ class HexOutput (StaticClass):
         else:
             integer_size = (bits / 4) + 2
         if integer >= 0:
-            return ('0x%%.%dx' % (integer_size - 2)) % integer
-        return ('-0x%%.%dx' % (integer_size - 2)) % -integer
+            return ("0x%%.%dx" % (integer_size - 2)) % integer
+        return ("-0x%%.%dx" % (integer_size - 2)) % -integer
 
     @classmethod
-    def address(cls, address, bits = None):
+    def address(cls, address, bits=None):
         """
         @type  address: int
         @param address: Memory address.
@@ -364,8 +367,8 @@ class HexOutput (StaticClass):
         else:
             address_size = (bits / 4) + 2
         if address < 0:
-            address = ((2 ** bits) - 1) ^ ~address
-        return ('0x%%.%dx' % (address_size - 2)) % address
+            address = ((2**bits) - 1) ^ ~address
+        return ("0x%%.%dx" % (address_size - 2)) % address
 
     @staticmethod
     def hexadecimal(data):
@@ -378,10 +381,10 @@ class HexOutput (StaticClass):
         @rtype:  str
         @return: Hexadecimal representation.
         """
-        return HexDump.hexadecimal(data, separator = '')
+        return HexDump.hexadecimal(data, separator="")
 
     @classmethod
-    def integer_list_file(cls, filename, values, bits = None):
+    def integer_list_file(cls, filename, values, bits=None):
         """
         Write a list of integers to a file.
         If a file of the same name exists, it's contents are replaced.
@@ -399,7 +402,7 @@ class HexOutput (StaticClass):
             (Optional) Number of bits of the target architecture.
             The default is platform dependent. See: L{HexOutput.integer_size}
         """
-        fd = open(filename, 'w')
+        fd = open(filename, "w")
         for integer in values:
             print >> fd, cls.integer(integer, bits)
         fd.close()
@@ -418,7 +421,7 @@ class HexOutput (StaticClass):
         @type  values: list( int )
         @param values: List of strings to write to the file.
         """
-        fd = open(filename, 'w')
+        fd = open(filename, "w")
         for string in values:
             print >> fd, string
         fd.close()
@@ -442,7 +445,7 @@ class HexOutput (StaticClass):
             (Optional) Number of bits of the target architecture.
             The default is platform dependent. See: L{HexOutput.integer_size}
         """
-        fd = open(filename, 'w')
+        fd = open(filename, "w")
         for original in values:
             try:
                 parsed = cls.integer(original, bits)
@@ -451,9 +454,11 @@ class HexOutput (StaticClass):
             print >> fd, parsed
         fd.close()
 
-#------------------------------------------------------------------------------
 
-class HexDump (StaticClass):
+# ------------------------------------------------------------------------------
+
+
+class HexDump(StaticClass):
     """
     Static functions for hexadecimal dumps.
 
@@ -466,11 +471,11 @@ class HexDump (StaticClass):
         This value is platform dependent.
     """
 
-    integer_size = (win32.SIZEOF(win32.DWORD)  * 2)
-    address_size = (win32.SIZEOF(win32.SIZE_T) * 2)
+    integer_size = win32.SIZEOF(win32.DWORD) * 2
+    address_size = win32.SIZEOF(win32.SIZE_T) * 2
 
     @classmethod
-    def integer(cls, integer, bits = None):
+    def integer(cls, integer, bits=None):
         """
         @type  integer: int
         @param integer: Integer.
@@ -487,10 +492,10 @@ class HexDump (StaticClass):
             integer_size = cls.integer_size
         else:
             integer_size = bits / 4
-        return ('%%.%dX' % integer_size) % integer
+        return ("%%.%dX" % integer_size) % integer
 
     @classmethod
-    def address(cls, address, bits = None):
+    def address(cls, address, bits=None):
         """
         @type  address: int
         @param address: Memory address.
@@ -509,8 +514,8 @@ class HexDump (StaticClass):
         else:
             address_size = bits / 4
         if address < 0:
-            address = ((2 ** bits) - 1) ^ ~address
-        return ('%%.%dX' % address_size) % address
+            address = ((2**bits) - 1) ^ ~address
+        return ("%%.%dX" % address_size) % address
 
     @staticmethod
     def printable(data):
@@ -523,16 +528,16 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Printable text.
         """
-        result = ''
+        result = ""
         for c in data:
             if 32 < ord(c) < 128:
                 result += c
             else:
-                result += '.'
+                result += "."
         return result
 
     @staticmethod
-    def hexadecimal(data, separator = ''):
+    def hexadecimal(data, separator=""):
         """
         Convert binary data to a string of hexadecimal numbers.
 
@@ -546,10 +551,10 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Hexadecimal representation.
         """
-        return separator.join( [ '%.2x' % ord(c) for c in data ] )
+        return separator.join(["%.2x" % ord(c) for c in data])
 
     @staticmethod
-    def hexa_word(data, separator = ' '):
+    def hexa_word(data, separator=" "):
         """
         Convert binary data to a string of hexadecimal WORDs.
 
@@ -564,12 +569,11 @@ class HexDump (StaticClass):
         @return: Hexadecimal representation.
         """
         if len(data) & 1 != 0:
-            data += '\0'
-        return separator.join( [ '%.4x' % struct.unpack('<H', data[i:i+2])[0] \
-                                           for i in compat.xrange(0, len(data), 2) ] )
+            data += "\0"
+        return separator.join(["%.4x" % struct.unpack("<H", data[i : i + 2])[0] for i in compat.xrange(0, len(data), 2)])
 
     @staticmethod
-    def hexa_dword(data, separator = ' '):
+    def hexa_dword(data, separator=" "):
         """
         Convert binary data to a string of hexadecimal DWORDs.
 
@@ -584,12 +588,11 @@ class HexDump (StaticClass):
         @return: Hexadecimal representation.
         """
         if len(data) & 3 != 0:
-            data += '\0' * (4 - (len(data) & 3))
-        return separator.join( [ '%.8x' % struct.unpack('<L', data[i:i+4])[0] \
-                                           for i in compat.xrange(0, len(data), 4) ] )
+            data += "\0" * (4 - (len(data) & 3))
+        return separator.join(["%.8x" % struct.unpack("<L", data[i : i + 4])[0] for i in compat.xrange(0, len(data), 4)])
 
     @staticmethod
-    def hexa_qword(data, separator = ' '):
+    def hexa_qword(data, separator=" "):
         """
         Convert binary data to a string of hexadecimal QWORDs.
 
@@ -604,12 +607,11 @@ class HexDump (StaticClass):
         @return: Hexadecimal representation.
         """
         if len(data) & 7 != 0:
-            data += '\0' * (8 - (len(data) & 7))
-        return separator.join( [ '%.16x' % struct.unpack('<Q', data[i:i+8])[0]\
-                                           for i in compat.xrange(0, len(data), 8) ] )
+            data += "\0" * (8 - (len(data) & 7))
+        return separator.join(["%.16x" % struct.unpack("<Q", data[i : i + 8])[0] for i in compat.xrange(0, len(data), 8)])
 
     @classmethod
-    def hexline(cls, data, separator = ' ', width = None):
+    def hexline(cls, data, separator=" ", width=None):
         """
         Dump a line of hexadecimal numbers from binary data.
 
@@ -629,16 +631,13 @@ class HexDump (StaticClass):
         @return: Multiline output text.
         """
         if width is None:
-            fmt = '%s  %s'
+            fmt = "%s  %s"
         else:
-            fmt = '%%-%ds  %%-%ds' % ((len(separator)+2)*width-1, width)
+            fmt = "%%-%ds  %%-%ds" % ((len(separator) + 2) * width - 1, width)
         return fmt % (cls.hexadecimal(data, separator), cls.printable(data))
 
     @classmethod
-    def hexblock(cls, data,                                    address = None,
-                                                                  bits = None,
-                                                             separator = ' ',
-                                                                 width = 8):
+    def hexblock(cls, data, address=None, bits=None, separator=" ", width=8):
         """
         Dump a block of hexadecimal numbers from binary data.
         Also show a printable text version of the data.
@@ -665,15 +664,10 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        return cls.hexblock_cb(cls.hexline, data, address, bits, width,
-                 cb_kwargs = {'width' : width, 'separator' : separator})
+        return cls.hexblock_cb(cls.hexline, data, address, bits, width, cb_kwargs={"width": width, "separator": separator})
 
     @classmethod
-    def hexblock_cb(cls, callback, data,                        address = None,
-                                                                   bits = None,
-                                                                  width = 16,
-                                                                cb_args = (),
-                                                              cb_kwargs = {}):
+    def hexblock_cb(cls, callback, data, address=None, bits=None, width=16, cb_args=(), cb_kwargs={}):
         """
         Dump a block of binary data using a callback function to convert each
         line of text.
@@ -708,26 +702,18 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        result = ''
+        result = ""
         if address is None:
             for i in compat.xrange(0, len(data), width):
-                result = '%s%s\n' % ( result, \
-                             callback(data[i:i+width], *cb_args, **cb_kwargs) )
+                result = "%s%s\n" % (result, callback(data[i : i + width], *cb_args, **cb_kwargs))
         else:
             for i in compat.xrange(0, len(data), width):
-                result = '%s%s: %s\n' % (
-                             result,
-                             cls.address(address, bits),
-                             callback(data[i:i+width], *cb_args, **cb_kwargs)
-                             )
+                result = "%s%s: %s\n" % (result, cls.address(address, bits), callback(data[i : i + width], *cb_args, **cb_kwargs))
                 address += width
         return result
 
     @classmethod
-    def hexblock_byte(cls, data,                                address = None,
-                                                                   bits = None,
-                                                              separator = ' ',
-                                                                  width = 16):
+    def hexblock_byte(cls, data, address=None, bits=None, separator=" ", width=16):
         """
         Dump a block of hexadecimal BYTEs from binary data.
 
@@ -753,15 +739,10 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        return cls.hexblock_cb(cls.hexadecimal, data,
-                               address, bits, width,
-                               cb_kwargs = {'separator': separator})
+        return cls.hexblock_cb(cls.hexadecimal, data, address, bits, width, cb_kwargs={"separator": separator})
 
     @classmethod
-    def hexblock_word(cls, data,                                address = None,
-                                                                   bits = None,
-                                                              separator = ' ',
-                                                                  width = 8):
+    def hexblock_word(cls, data, address=None, bits=None, separator=" ", width=8):
         """
         Dump a block of hexadecimal WORDs from binary data.
 
@@ -787,15 +768,10 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        return cls.hexblock_cb(cls.hexa_word, data,
-                               address, bits, width * 2,
-                               cb_kwargs = {'separator': separator})
+        return cls.hexblock_cb(cls.hexa_word, data, address, bits, width * 2, cb_kwargs={"separator": separator})
 
     @classmethod
-    def hexblock_dword(cls, data,                               address = None,
-                                                                   bits = None,
-                                                              separator = ' ',
-                                                                  width = 4):
+    def hexblock_dword(cls, data, address=None, bits=None, separator=" ", width=4):
         """
         Dump a block of hexadecimal DWORDs from binary data.
 
@@ -821,15 +797,10 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        return cls.hexblock_cb(cls.hexa_dword, data,
-                               address, bits, width * 4,
-                               cb_kwargs = {'separator': separator})
+        return cls.hexblock_cb(cls.hexa_dword, data, address, bits, width * 4, cb_kwargs={"separator": separator})
 
     @classmethod
-    def hexblock_qword(cls, data,                               address = None,
-                                                                   bits = None,
-                                                              separator = ' ',
-                                                                  width = 2):
+    def hexblock_qword(cls, data, address=None, bits=None, separator=" ", width=2):
         """
         Dump a block of hexadecimal QWORDs from binary data.
 
@@ -855,15 +826,15 @@ class HexDump (StaticClass):
         @rtype:  str
         @return: Multiline output text.
         """
-        return cls.hexblock_cb(cls.hexa_qword, data,
-                               address, bits, width * 8,
-                               cb_kwargs = {'separator': separator})
+        return cls.hexblock_cb(cls.hexa_qword, data, address, bits, width * 8, cb_kwargs={"separator": separator})
 
-#------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
 
 # TODO: implement an ANSI parser to simplify using colors
 
-class Color (object):
+
+class Color(object):
     """
     Colored console output.
     """
@@ -874,9 +845,9 @@ class Color (object):
 
     @staticmethod
     def _set_text_attributes(wAttributes):
-        win32.SetConsoleTextAttribute(wAttributes = wAttributes)
+        win32.SetConsoleTextAttribute(wAttributes=wAttributes)
 
-    #--------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
 
     @classmethod
     def can_use_colors(cls):
@@ -903,10 +874,10 @@ class Color (object):
         "Reset the colors to the default values."
         cls._set_text_attributes(win32.FOREGROUND_GREY)
 
-    #--------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
 
-    #@classmethod
-    #def underscore(cls, on = True):
+    # @classmethod
+    # def underscore(cls, on = True):
     #    wAttributes = cls._get_text_attributes()
     #    if on:
     #        wAttributes |=  win32.COMMON_LVB_UNDERSCORE
@@ -914,14 +885,14 @@ class Color (object):
     #        wAttributes &= ~win32.COMMON_LVB_UNDERSCORE
     #    cls._set_text_attributes(wAttributes)
 
-    #--------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
 
     @classmethod
     def default(cls):
         "Make the current foreground color the default."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_GREY
+        wAttributes |= win32.FOREGROUND_GREY
         wAttributes &= ~win32.FOREGROUND_INTENSITY
         cls._set_text_attributes(wAttributes)
 
@@ -944,7 +915,7 @@ class Color (object):
         "Make the text foreground color black."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        #wAttributes |=  win32.FOREGROUND_BLACK
+        # wAttributes |=  win32.FOREGROUND_BLACK
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -952,7 +923,7 @@ class Color (object):
         "Make the text foreground color white."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_GREY
+        wAttributes |= win32.FOREGROUND_GREY
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -960,7 +931,7 @@ class Color (object):
         "Make the text foreground color red."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_RED
+        wAttributes |= win32.FOREGROUND_RED
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -968,7 +939,7 @@ class Color (object):
         "Make the text foreground color green."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_GREEN
+        wAttributes |= win32.FOREGROUND_GREEN
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -976,7 +947,7 @@ class Color (object):
         "Make the text foreground color blue."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_BLUE
+        wAttributes |= win32.FOREGROUND_BLUE
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -984,7 +955,7 @@ class Color (object):
         "Make the text foreground color cyan."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_CYAN
+        wAttributes |= win32.FOREGROUND_CYAN
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -992,7 +963,7 @@ class Color (object):
         "Make the text foreground color magenta."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_MAGENTA
+        wAttributes |= win32.FOREGROUND_MAGENTA
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1000,17 +971,17 @@ class Color (object):
         "Make the text foreground color yellow."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.FOREGROUND_MASK
-        wAttributes |=  win32.FOREGROUND_YELLOW
+        wAttributes |= win32.FOREGROUND_YELLOW
         cls._set_text_attributes(wAttributes)
 
-    #--------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
 
     @classmethod
     def bk_default(cls):
         "Make the current background color the default."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        #wAttributes |= win32.BACKGROUND_BLACK
+        # wAttributes |= win32.BACKGROUND_BLACK
         wAttributes &= ~win32.BACKGROUND_INTENSITY
         cls._set_text_attributes(wAttributes)
 
@@ -1033,7 +1004,7 @@ class Color (object):
         "Make the text background color black."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        #wAttributes |= win32.BACKGROUND_BLACK
+        # wAttributes |= win32.BACKGROUND_BLACK
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1041,7 +1012,7 @@ class Color (object):
         "Make the text background color white."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_GREY
+        wAttributes |= win32.BACKGROUND_GREY
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1049,7 +1020,7 @@ class Color (object):
         "Make the text background color red."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_RED
+        wAttributes |= win32.BACKGROUND_RED
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1057,7 +1028,7 @@ class Color (object):
         "Make the text background color green."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_GREEN
+        wAttributes |= win32.BACKGROUND_GREEN
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1065,7 +1036,7 @@ class Color (object):
         "Make the text background color blue."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_BLUE
+        wAttributes |= win32.BACKGROUND_BLUE
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1073,7 +1044,7 @@ class Color (object):
         "Make the text background color cyan."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_CYAN
+        wAttributes |= win32.BACKGROUND_CYAN
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1081,7 +1052,7 @@ class Color (object):
         "Make the text background color magenta."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_MAGENTA
+        wAttributes |= win32.BACKGROUND_MAGENTA
         cls._set_text_attributes(wAttributes)
 
     @classmethod
@@ -1089,27 +1060,29 @@ class Color (object):
         "Make the text background color yellow."
         wAttributes = cls._get_text_attributes()
         wAttributes &= ~win32.BACKGROUND_MASK
-        wAttributes |=  win32.BACKGROUND_YELLOW
+        wAttributes |= win32.BACKGROUND_YELLOW
         cls._set_text_attributes(wAttributes)
 
-#------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
 
 # TODO: another class for ASCII boxes
 
-class Table (object):
+
+class Table(object):
     """
     Text based table. The number of columns and the width of each column
     is automatically calculated.
     """
 
-    def __init__(self, sep = ' '):
+    def __init__(self, sep=" "):
         """
         @type  sep: str
         @param sep: Separator between cells in each row.
         """
-        self.__cols  = list()
+        self.__cols = list()
         self.__width = list()
-        self.__sep   = sep
+        self.__sep = sep
 
     def addRow(self, *row):
         """
@@ -1118,18 +1091,18 @@ class Table (object):
         @type    row: tuple
         @keyword row: Each argument is a cell in the table.
         """
-        row     = [ str(item) for item in row ]
-        len_row = [ len(item) for item in row ]
-        width   = self.__width
+        row = [str(item) for item in row]
+        len_row = [len(item) for item in row]
+        width = self.__width
         len_old = len(width)
         len_new = len(row)
-        known   = min(len_old, len_new)
+        known = min(len_old, len_new)
         missing = len_new - len_old
         if missing > 0:
-            width.extend( len_row[ -missing : ] )
+            width.extend(len_row[-missing:])
         elif missing < 0:
-            len_row.extend( [0] * (-missing) )
-        self.__width = [ max( width[i], len_row[i] ) for i in compat.xrange(len(len_row)) ]
+            len_row.extend([0] * (-missing))
+        self.__width = [max(width[i], len_row[i]) for i in compat.xrange(len(len_row))]
         self.__cols.append(row)
 
     def justify(self, column, direction):
@@ -1148,9 +1121,9 @@ class Table (object):
         @raise ValueError: Bad direction value.
         """
         if direction == -1:
-            self.__width[column] =   abs(self.__width[column])
+            self.__width[column] = abs(self.__width[column])
         elif direction == 1:
-            self.__width[column] = - abs(self.__width[column])
+            self.__width[column] = -abs(self.__width[column])
         else:
             raise ValueError("Bad direction value.")
 
@@ -1164,7 +1137,7 @@ class Table (object):
         """
         width = 0
         if self.__width:
-            width = sum( abs(x) for x in self.__width )
+            width = sum(abs(x) for x in self.__width)
             width = width + len(self.__width) * len(self.__sep) + 1
         return width
 
@@ -1175,7 +1148,7 @@ class Table (object):
         @rtype:  str
         @return: Text output.
         """
-        return '%s\n' % '\n'.join( self.yieldOutput() )
+        return "%s\n" % "\n".join(self.yieldOutput())
 
     def yieldOutput(self):
         """
@@ -1187,12 +1160,12 @@ class Table (object):
         width = self.__width
         if width:
             num_cols = len(width)
-            fmt = ['%%%ds' % -w for w in width]
+            fmt = ["%%%ds" % -w for w in width]
             if width[-1] > 0:
-                fmt[-1] = '%s'
+                fmt[-1] = "%s"
             fmt = self.__sep.join(fmt)
             for row in self.__cols:
-                row.extend( [''] * (num_cols - len(row)) )
+                row.extend([""] * (num_cols - len(row)))
                 yield fmt % tuple(row)
 
     def show(self):
@@ -1201,9 +1174,11 @@ class Table (object):
         """
         print(self.getOutput())
 
-#------------------------------------------------------------------------------
 
-class CrashDump (StaticClass):
+# ------------------------------------------------------------------------------
+
+
+class CrashDump(StaticClass):
     """
     Static functions for crash dumps.
 
@@ -1213,21 +1188,21 @@ class CrashDump (StaticClass):
 
     # Templates for the dump_registers method.
     reg_template = {
-        win32.ARCH_I386 : (
-            'eax=%(Eax).8x ebx=%(Ebx).8x ecx=%(Ecx).8x edx=%(Edx).8x esi=%(Esi).8x edi=%(Edi).8x\n'
-            'eip=%(Eip).8x esp=%(Esp).8x ebp=%(Ebp).8x %(efl_dump)s\n'
-            'cs=%(SegCs).4x  ss=%(SegSs).4x  ds=%(SegDs).4x  es=%(SegEs).4x  fs=%(SegFs).4x  gs=%(SegGs).4x             efl=%(EFlags).8x\n'
-            ),
-        win32.ARCH_AMD64 : (
-            'rax=%(Rax).16x rbx=%(Rbx).16x rcx=%(Rcx).16x\n'
-            'rdx=%(Rdx).16x rsi=%(Rsi).16x rdi=%(Rdi).16x\n'
-            'rip=%(Rip).16x rsp=%(Rsp).16x rbp=%(Rbp).16x\n'
-            ' r8=%(R8).16x  r9=%(R9).16x r10=%(R10).16x\n'
-            'r11=%(R11).16x r12=%(R12).16x r13=%(R13).16x\n'
-            'r14=%(R14).16x r15=%(R15).16x\n'
-            '%(efl_dump)s\n'
-            'cs=%(SegCs).4x  ss=%(SegSs).4x  ds=%(SegDs).4x  es=%(SegEs).4x  fs=%(SegFs).4x  gs=%(SegGs).4x             efl=%(EFlags).8x\n'
-            ),
+        win32.ARCH_I386: (
+            "eax=%(Eax).8x ebx=%(Ebx).8x ecx=%(Ecx).8x edx=%(Edx).8x esi=%(Esi).8x edi=%(Edi).8x\n"
+            "eip=%(Eip).8x esp=%(Esp).8x ebp=%(Ebp).8x %(efl_dump)s\n"
+            "cs=%(SegCs).4x  ss=%(SegSs).4x  ds=%(SegDs).4x  es=%(SegEs).4x  fs=%(SegFs).4x  gs=%(SegGs).4x             efl=%(EFlags).8x\n"
+        ),
+        win32.ARCH_AMD64: (
+            "rax=%(Rax).16x rbx=%(Rbx).16x rcx=%(Rcx).16x\n"
+            "rdx=%(Rdx).16x rsi=%(Rsi).16x rdi=%(Rdi).16x\n"
+            "rip=%(Rip).16x rsp=%(Rsp).16x rbp=%(Rbp).16x\n"
+            " r8=%(R8).16x  r9=%(R9).16x r10=%(R10).16x\n"
+            "r11=%(R11).16x r12=%(R12).16x r13=%(R13).16x\n"
+            "r14=%(R14).16x r15=%(R15).16x\n"
+            "%(efl_dump)s\n"
+            "cs=%(SegCs).4x  ss=%(SegSs).4x  ds=%(SegDs).4x  es=%(SegEs).4x  fs=%(SegFs).4x  gs=%(SegGs).4x             efl=%(EFlags).8x\n"
+        ),
     }
 
     @staticmethod
@@ -1244,56 +1219,56 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if efl is None:
-            return ''
-        efl_dump = 'iopl=%1d' % ((efl & 0x3000) >> 12)
+            return ""
+        efl_dump = "iopl=%1d" % ((efl & 0x3000) >> 12)
         if efl & 0x100000:
-            efl_dump += ' vip'
+            efl_dump += " vip"
         else:
-            efl_dump += '    '
+            efl_dump += "    "
         if efl & 0x80000:
-            efl_dump += ' vif'
+            efl_dump += " vif"
         else:
-            efl_dump += '    '
+            efl_dump += "    "
         # 0x20000 ???
         if efl & 0x800:
-            efl_dump += ' ov'       # Overflow
+            efl_dump += " ov"  # Overflow
         else:
-            efl_dump += ' no'       # No overflow
+            efl_dump += " no"  # No overflow
         if efl & 0x400:
-            efl_dump += ' dn'       # Downwards
+            efl_dump += " dn"  # Downwards
         else:
-            efl_dump += ' up'       # Upwards
+            efl_dump += " up"  # Upwards
         if efl & 0x200:
-            efl_dump += ' ei'       # Enable interrupts
+            efl_dump += " ei"  # Enable interrupts
         else:
-            efl_dump += ' di'       # Disable interrupts
+            efl_dump += " di"  # Disable interrupts
         # 0x100 trap flag
         if efl & 0x80:
-            efl_dump += ' ng'       # Negative
+            efl_dump += " ng"  # Negative
         else:
-            efl_dump += ' pl'       # Positive
+            efl_dump += " pl"  # Positive
         if efl & 0x40:
-            efl_dump += ' zr'       # Zero
+            efl_dump += " zr"  # Zero
         else:
-            efl_dump += ' nz'       # Nonzero
+            efl_dump += " nz"  # Nonzero
         if efl & 0x10:
-            efl_dump += ' ac'       # Auxiliary carry
+            efl_dump += " ac"  # Auxiliary carry
         else:
-            efl_dump += ' na'       # No auxiliary carry
+            efl_dump += " na"  # No auxiliary carry
         # 0x8 ???
         if efl & 0x4:
-            efl_dump += ' pe'       # Parity odd
+            efl_dump += " pe"  # Parity odd
         else:
-            efl_dump += ' po'       # Parity even
+            efl_dump += " po"  # Parity even
         # 0x2 ???
         if efl & 0x1:
-            efl_dump += ' cy'       # Carry
+            efl_dump += " cy"  # Carry
         else:
-            efl_dump += ' nc'       # No carry
+            efl_dump += " nc"  # No carry
         return efl_dump
 
     @classmethod
-    def dump_registers(cls, registers, arch = None):
+    def dump_registers(cls, registers, arch=None):
         """
         Dump the x86/x64 processor register values.
         The output mimics that of the WinDBG debugger.
@@ -1312,23 +1287,23 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if registers is None:
-            return ''
+            return ""
         if arch is None:
-            if 'Eax' in registers:
+            if "Eax" in registers:
                 arch = win32.ARCH_I386
-            elif 'Rax' in registers:
+            elif "Rax" in registers:
                 arch = win32.ARCH_AMD64
             else:
-                arch = 'Unknown'
+                arch = "Unknown"
         if arch not in cls.reg_template:
             msg = "Don't know how to dump the registers for architecture: %s"
             raise NotImplementedError(msg % arch)
         registers = registers.copy()
-        registers['efl_dump'] = cls.dump_flags( registers['EFlags'] )
+        registers["efl_dump"] = cls.dump_flags(registers["EFlags"])
         return cls.reg_template[arch] % registers
 
     @staticmethod
-    def dump_registers_peek(registers, data, separator = ' ', width = 16):
+    def dump_registers_peek(registers, data, separator=" ", width=16):
         """
         Dump data pointed to by the given registers, if any.
 
@@ -1344,21 +1319,18 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if None in (registers, data):
-            return ''
+            return ""
         names = compat.keys(data)
         names.sort()
-        result = ''
+        result = ""
         for reg_name in names:
-            tag     = reg_name.lower()
-            dumped  = HexDump.hexline(data[reg_name], separator, width)
-            result += '%s -> %s\n' % (tag, dumped)
+            tag = reg_name.lower()
+            dumped = HexDump.hexline(data[reg_name], separator, width)
+            result += "%s -> %s\n" % (tag, dumped)
         return result
 
     @staticmethod
-    def dump_data_peek(data,                                      base = 0,
-                                                             separator = ' ',
-                                                                 width = 16,
-                                                                  bits = None):
+    def dump_data_peek(data, base=0, separator=" ", width=16, bits=None):
         """
         Dump data from pointers guessed within the given binary data.
 
@@ -1377,18 +1349,18 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if data is None:
-            return ''
+            return ""
         pointers = compat.keys(data)
         pointers.sort()
-        result = ''
+        result = ""
         for offset in pointers:
-            dumped  = HexDump.hexline(data[offset], separator, width)
+            dumped = HexDump.hexline(data[offset], separator, width)
             address = HexDump.address(base + offset, bits)
-            result += '%s -> %s\n' % (address, dumped)
+            result += "%s -> %s\n" % (address, dumped)
         return result
 
     @staticmethod
-    def dump_stack_peek(data, separator = ' ', width = 16, arch = None):
+    def dump_stack_peek(data, separator=" ", width=16, arch=None):
         """
         Dump data from pointers guessed within the given stack dump.
 
@@ -1412,28 +1384,28 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if data is None:
-            return ''
+            return ""
         if arch is None:
             arch = win32.arch
         pointers = compat.keys(data)
         pointers.sort()
-        result = ''
+        result = ""
         if pointers:
             if arch == win32.ARCH_I386:
-                spreg = 'esp'
+                spreg = "esp"
             elif arch == win32.ARCH_AMD64:
-                spreg = 'rsp'
+                spreg = "rsp"
             else:
-                spreg = 'STACK' # just a generic tag
-            tag_fmt = '[%s+0x%%.%dx]' % (spreg, len( '%x' % pointers[-1] ) )
+                spreg = "STACK"  # just a generic tag
+            tag_fmt = "[%s+0x%%.%dx]" % (spreg, len("%x" % pointers[-1]))
             for offset in pointers:
-                dumped  = HexDump.hexline(data[offset], separator, width)
-                tag     = tag_fmt % offset
-                result += '%s -> %s\n' % (tag, dumped)
+                dumped = HexDump.hexline(data[offset], separator, width)
+                tag = tag_fmt % offset
+                result += "%s -> %s\n" % (tag, dumped)
         return result
 
     @staticmethod
-    def dump_stack_trace(stack_trace, bits = None):
+    def dump_stack_trace(stack_trace, bits=None):
         """
         Dump a stack trace, as returned by L{Thread.get_stack_trace} with the
         C{bUseLabels} parameter set to C{False}.
@@ -1451,17 +1423,17 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if not stack_trace:
-            return ''
+            return ""
         table = Table()
-        table.addRow('Frame', 'Origin', 'Module')
-        for (fp, ra, mod) in stack_trace:
+        table.addRow("Frame", "Origin", "Module")
+        for fp, ra, mod in stack_trace:
             fp_d = HexDump.address(fp, bits)
             ra_d = HexDump.address(ra, bits)
             table.addRow(fp_d, ra_d, mod)
         return table.getOutput()
 
     @staticmethod
-    def dump_stack_trace_with_labels(stack_trace, bits = None):
+    def dump_stack_trace_with_labels(stack_trace, bits=None):
         """
         Dump a stack trace,
         as returned by L{Thread.get_stack_trace_with_labels}.
@@ -1479,11 +1451,11 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if not stack_trace:
-            return ''
+            return ""
         table = Table()
-        table.addRow('Frame', 'Origin')
-        for (fp, label) in stack_trace:
-            table.addRow( HexDump.address(fp, bits), label )
+        table.addRow("Frame", "Origin")
+        for fp, label in stack_trace:
+            table.addRow(HexDump.address(fp, bits), label)
         return table.getOutput()
 
     # TODO
@@ -1493,9 +1465,7 @@ class CrashDump (StaticClass):
     # + It'd be very useful to show some labels here.
     # + It'd be very useful to show register contents for code at EIP
     @staticmethod
-    def dump_code(disassembly,                                      pc = None,
-                                                            bLowercase = True,
-                                                                  bits = None):
+    def dump_code(disassembly, pc=None, bLowercase=True, bits=None):
         """
         Dump a disassembly. Optionally mark where the program counter is.
 
@@ -1518,26 +1488,21 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if not disassembly:
-            return ''
-        table = Table(sep = ' | ')
-        for (addr, size, code, dump) in disassembly:
+            return ""
+        table = Table(sep=" | ")
+        for addr, size, code, dump in disassembly:
             if bLowercase:
                 code = code.lower()
             if addr == pc:
-                addr = ' * %s' % HexDump.address(addr, bits)
+                addr = " * %s" % HexDump.address(addr, bits)
             else:
-                addr = '   %s' % HexDump.address(addr, bits)
+                addr = "   %s" % HexDump.address(addr, bits)
             table.addRow(addr, dump, code)
         table.justify(1, 1)
         return table.getOutput()
 
     @staticmethod
-    def dump_code_line(disassembly_line,                  bShowAddress = True,
-                                                             bShowDump = True,
-                                                            bLowercase = True,
-                                                           dwDumpWidth = None,
-                                                           dwCodeWidth = None,
-                                                                  bits = None):
+    def dump_code_line(disassembly_line, bShowAddress=True, bShowDump=True, bLowercase=True, dwDumpWidth=None, dwCodeWidth=None, bits=None):
         """
         Dump a single line of code. To dump a block of code use L{dump_code}.
 
@@ -1573,29 +1538,29 @@ class CrashDump (StaticClass):
         else:
             address_size = bits / 4
         (addr, size, code, dump) = disassembly_line
-        dump = dump.replace(' ', '')
+        dump = dump.replace(" ", "")
         result = list()
-        fmt = ''
+        fmt = ""
         if bShowAddress:
-            result.append( HexDump.address(addr, bits) )
-            fmt += '%%%ds:' % address_size
+            result.append(HexDump.address(addr, bits))
+            fmt += "%%%ds:" % address_size
         if bShowDump:
             result.append(dump)
             if dwDumpWidth:
-                fmt += ' %%-%ds' % dwDumpWidth
+                fmt += " %%-%ds" % dwDumpWidth
             else:
-                fmt += ' %s'
+                fmt += " %s"
         if bLowercase:
             code = code.lower()
         result.append(code)
         if dwCodeWidth:
-            fmt += ' %%-%ds' % dwCodeWidth
+            fmt += " %%-%ds" % dwCodeWidth
         else:
-            fmt += ' %s'
+            fmt += " %s"
         return fmt % tuple(result)
 
     @staticmethod
-    def dump_memory_map(memoryMap, mappedFilenames = None, bits = None):
+    def dump_memory_map(memoryMap, mappedFilenames=None, bits=None):
         """
         Dump the memory map of a process. Optionally show the filenames for
         memory mapped files as well.
@@ -1616,7 +1581,7 @@ class CrashDump (StaticClass):
         @return: Text suitable for logging.
         """
         if not memoryMap:
-            return ''
+            return ""
 
         table = Table()
         if mappedFilenames:
@@ -1626,28 +1591,27 @@ class CrashDump (StaticClass):
 
         # For each memory block in the map...
         for mbi in memoryMap:
-
             # Address and size of memory block.
             BaseAddress = HexDump.address(mbi.BaseAddress, bits)
-            RegionSize  = HexDump.address(mbi.RegionSize,  bits)
+            RegionSize = HexDump.address(mbi.RegionSize, bits)
 
             # State (free or allocated).
             mbiState = mbi.State
-            if   mbiState == win32.MEM_RESERVE:
-                State   = "Reserved"
+            if mbiState == win32.MEM_RESERVE:
+                State = "Reserved"
             elif mbiState == win32.MEM_COMMIT:
-                State   = "Commited"
+                State = "Commited"
             elif mbiState == win32.MEM_FREE:
-                State   = "Free"
+                State = "Free"
             else:
-                State   = "Unknown"
+                State = "Unknown"
 
             # Page protection bits (R/W/X/G).
             if mbiState != win32.MEM_COMMIT:
                 Protect = ""
             else:
                 mbiProtect = mbi.Protect
-                if   mbiProtect & win32.PAGE_NOACCESS:
+                if mbiProtect & win32.PAGE_NOACCESS:
                     Protect = "--- "
                 elif mbiProtect & win32.PAGE_READONLY:
                     Protect = "R-- "
@@ -1665,46 +1629,48 @@ class CrashDump (StaticClass):
                     Protect = "RCX "
                 else:
                     Protect = "??? "
-                if   mbiProtect & win32.PAGE_GUARD:
+                if mbiProtect & win32.PAGE_GUARD:
                     Protect += "G"
                 else:
                     Protect += "-"
-                if   mbiProtect & win32.PAGE_NOCACHE:
+                if mbiProtect & win32.PAGE_NOCACHE:
                     Protect += "N"
                 else:
                     Protect += "-"
-                if   mbiProtect & win32.PAGE_WRITECOMBINE:
+                if mbiProtect & win32.PAGE_WRITECOMBINE:
                     Protect += "W"
                 else:
                     Protect += "-"
 
             # Type (file mapping, executable image, or private memory).
             mbiType = mbi.Type
-            if   mbiType == win32.MEM_IMAGE:
-                Type    = "Image"
+            if mbiType == win32.MEM_IMAGE:
+                Type = "Image"
             elif mbiType == win32.MEM_MAPPED:
-                Type    = "Mapped"
+                Type = "Mapped"
             elif mbiType == win32.MEM_PRIVATE:
-                Type    = "Private"
+                Type = "Private"
             elif mbiType == 0:
-                Type    = ""
+                Type = ""
             else:
-                Type    = "Unknown"
+                Type = "Unknown"
 
             # Output a row in the table.
             if mappedFilenames:
-                FileName = mappedFilenames.get(mbi.BaseAddress, '')
-                table.addRow( BaseAddress, RegionSize, State, Protect, Type, FileName )
+                FileName = mappedFilenames.get(mbi.BaseAddress, "")
+                table.addRow(BaseAddress, RegionSize, State, Protect, Type, FileName)
             else:
-                table.addRow( BaseAddress, RegionSize, State, Protect, Type )
+                table.addRow(BaseAddress, RegionSize, State, Protect, Type)
 
         # Return the table output.
         return table.getOutput()
 
-#------------------------------------------------------------------------------
 
-class DebugLog (StaticClass):
-    'Static functions for debug logging.'
+# ------------------------------------------------------------------------------
+
+
+class DebugLog(StaticClass):
+    "Static functions for debug logging."
 
     @staticmethod
     def log_text(text):
@@ -1717,16 +1683,16 @@ class DebugLog (StaticClass):
         @rtype:  str
         @return: Log line.
         """
-        if text.endswith('\n'):
-            text = text[:-len('\n')]
-        #text  = text.replace('\n', '\n\t\t')           # text CSV
+        if text.endswith("\n"):
+            text = text[: -len("\n")]
+        # text  = text.replace('\n', '\n\t\t')           # text CSV
         ltime = time.strftime("%X")
         msecs = (time.time() % 1) * 1000
-        return '[%s.%04d] %s' % (ltime, msecs, text)
-        #return '[%s.%04d]\t%s' % (ltime, msecs, text)  # text CSV
+        return "[%s.%04d] %s" % (ltime, msecs, text)
+        # return '[%s.%04d]\t%s' % (ltime, msecs, text)  # text CSV
 
     @classmethod
-    def log_event(cls, event, text = None):
+    def log_event(cls, event, text=None):
         """
         Log lines of text associated with a debug event.
 
@@ -1744,29 +1710,31 @@ class DebugLog (StaticClass):
             if event.get_event_code() == win32.EXCEPTION_DEBUG_EVENT:
                 what = event.get_exception_description()
                 if event.is_first_chance():
-                    what = '%s (first chance)' % what
+                    what = "%s (first chance)" % what
                 else:
-                    what = '%s (second chance)' % what
+                    what = "%s (second chance)" % what
                 try:
                     address = event.get_fault_address()
                 except NotImplementedError:
                     address = event.get_exception_address()
             else:
-                what    = event.get_event_name()
+                what = event.get_event_name()
                 address = event.get_thread().get_pc()
             process = event.get_process()
             label = process.get_label_at_address(address)
             address = HexDump.address(address, process.get_bits())
             if label:
-                where = '%s (%s)' % (address, label)
+                where = "%s (%s)" % (address, label)
             else:
                 where = address
-            text = '%s at %s' % (what, where)
-        text = 'pid %d tid %d: %s' % (event.get_pid(), event.get_tid(), text)
-        #text = 'pid %d tid %d:\t%s' % (event.get_pid(), event.get_tid(), text)     # text CSV
+            text = "%s at %s" % (what, where)
+        text = "pid %d tid %d: %s" % (event.get_pid(), event.get_tid(), text)
+        # text = 'pid %d tid %d:\t%s' % (event.get_pid(), event.get_tid(), text)     # text CSV
         return cls.log_text(text)
 
-#------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
+
 
 class Logger(object):
     """
@@ -1783,7 +1751,7 @@ class Logger(object):
         C{None} if no log file is used.
     """
 
-    def __init__(self, logfile = None, verbose = True):
+    def __init__(self, logfile=None, verbose=True):
         """
         @type  logfile: str or None
         @param logfile: Append messages to this text file.
@@ -1794,7 +1762,7 @@ class Logger(object):
         self.verbose = verbose
         self.logfile = logfile
         if self.logfile:
-            self.fd = open(self.logfile, 'a+')
+            self.fd = open(self.logfile, "a+")
 
     def __logfile_error(self, e):
         """
@@ -1807,11 +1775,12 @@ class Logger(object):
         @param e: Exception raised when trying to write to the log file.
         """
         from sys import stderr
+
         msg = "Warning, error writing log file %s: %s\n"
         msg = msg % (self.logfile, str(e))
         stderr.write(DebugLog.log_text(msg))
         self.logfile = None
-        self.fd      = None
+        self.fd = None
 
     def __do_log(self, text):
         """
@@ -1824,12 +1793,12 @@ class Logger(object):
         @param text: Text to print.
         """
         if isinstance(text, compat.unicode):
-            text = text.encode('cp1252')
+            text = text.encode("cp1252")
         if self.verbose:
             print(text)
         if self.logfile:
             try:
-                self.fd.writelines('%s\n' % text)
+                self.fd.writelines("%s\n" % text)
             except IOError:
                 e = sys.exc_info()[1]
                 self.__logfile_error(e)
@@ -1841,9 +1810,9 @@ class Logger(object):
         @type  text: str
         @param text: Text to log.
         """
-        self.__do_log( DebugLog.log_text(text) )
+        self.__do_log(DebugLog.log_text(text))
 
-    def log_event(self, event, text = None):
+    def log_event(self, event, text=None):
         """
         Log lines of text associated with a debug event.
 
@@ -1854,13 +1823,13 @@ class Logger(object):
         @param text: (Optional) Text to log. If no text is provided the default
             is to show a description of the event itself.
         """
-        self.__do_log( DebugLog.log_event(event, text) )
+        self.__do_log(DebugLog.log_event(event, text))
 
     def log_exc(self):
         """
         Log lines of text associated with the last Python exception.
         """
-        self.__do_log( 'Exception raised: %s' % traceback.format_exc() )
+        self.__do_log("Exception raised: %s" % traceback.format_exc())
 
     def is_enabled(self):
         """