debugpy 1.8.3__zip → 1.8.6__zip

{debugpy-1.8.3 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/process.py

@@ -45,7 +45,7 @@ from __future__ import with_statement
 
 __revision__ = "$Id$"
 
-__all__ = ['Process']
+__all__ = ["Process"]
 
 import sys
 from winappdbg import win32
@@ -55,8 +55,7 @@ from winappdbg.util import Regenerator, PathOperations, MemoryAddresses
 from winappdbg.module import Module, _ModuleContainer
 from winappdbg.thread import Thread, _ThreadContainer
 from winappdbg.window import Window
-from winappdbg.search import Search, \
-                   Pattern, BytePattern, TextPattern, RegExpPattern, HexPattern
+from winappdbg.search import Search, Pattern, BytePattern, TextPattern, RegExpPattern, HexPattern
 from winappdbg.disasm import Disassembler
 
 import re
@@ -70,7 +69,7 @@ import traceback
 # delayed import
 System = None
 
-#==============================================================================
+# ==============================================================================
 
 # TODO
 # * Remote GetLastError()
@@ -79,7 +78,8 @@ System = None
 #   retrieve the original memory contents where code breakpoints are enabled.
 # * A memory cache could be implemented here.
 
-class Process (_ThreadContainer, _ModuleContainer):
+
+class Process(_ThreadContainer, _ModuleContainer):
     """
     Interface to a process. Contains threads and modules snapshots.
 
@@ -150,7 +150,7 @@ class Process (_ThreadContainer, _ModuleContainer):
     @ivar fileName: Filename of the main module. Use L{get_filename} instead.
     """
 
-    def __init__(self, dwProcessId, hProcess = None, fileName = None):
+    def __init__(self, dwProcessId, hProcess=None, fileName=None):
         """
         @type  dwProcessId: int
         @param dwProcessId: Global process ID.
@@ -165,8 +165,8 @@ class Process (_ThreadContainer, _ModuleContainer):
         _ModuleContainer.__init__(self)
 
         self.dwProcessId = dwProcessId
-        self.hProcess    = hProcess
-        self.fileName    = fileName
+        self.hProcess = hProcess
+        self.fileName = fileName
 
     def get_pid(self):
         """
@@ -184,7 +184,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             self.fileName = self.get_image_name()
         return self.fileName
 
-    def open_handle(self, dwDesiredAccess = win32.PROCESS_ALL_ACCESS):
+    def open_handle(self, dwDesiredAccess=win32.PROCESS_ALL_ACCESS):
         """
         Opens a new handle to the process.
 
@@ -208,8 +208,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         try:
             self.close_handle()
         except Exception:
-            warnings.warn(
-                "Failed to close process handle: %s" % traceback.format_exc())
+            warnings.warn("Failed to close process handle: %s" % traceback.format_exc())
 
         self.hProcess = hProcess
 
@@ -223,14 +222,14 @@ class Process (_ThreadContainer, _ModuleContainer):
             setting L{hProcess} to C{None} should be enough.
         """
         try:
-            if hasattr(self.hProcess, 'close'):
+            if hasattr(self.hProcess, "close"):
                 self.hProcess.close()
             elif self.hProcess not in (None, win32.INVALID_HANDLE_VALUE):
                 win32.CloseHandle(self.hProcess)
         finally:
             self.hProcess = None
 
-    def get_handle(self, dwDesiredAccess = win32.PROCESS_ALL_ACCESS):
+    def get_handle(self, dwDesiredAccess=win32.PROCESS_ALL_ACCESS):
         """
         Returns a handle to the process with I{at least} the access rights
         requested.
@@ -261,26 +260,26 @@ class Process (_ThreadContainer, _ModuleContainer):
                 self.open_handle(dwAccess | dwDesiredAccess)
         return self.hProcess
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # Not really sure if it's a good idea...
-##    def __eq__(self, aProcess):
-##        """
-##        Compare two Process objects. The comparison is made using the IDs.
-##
-##        @warning:
-##            If you have two Process instances with different handles the
-##            equality operator still returns C{True}, so be careful!
-##
-##        @type  aProcess: L{Process}
-##        @param aProcess: Another Process object.
-##
-##        @rtype:  bool
-##        @return: C{True} if the two process IDs are equal,
-##            C{False} otherwise.
-##        """
-##        return isinstance(aProcess, Process)         and \
-##               self.get_pid() == aProcess.get_pid()
+    ##    def __eq__(self, aProcess):
+    ##        """
+    ##        Compare two Process objects. The comparison is made using the IDs.
+    ##
+    ##        @warning:
+    ##            If you have two Process instances with different handles the
+    ##            equality operator still returns C{True}, so be careful!
+    ##
+    ##        @type  aProcess: L{Process}
+    ##        @param aProcess: Another Process object.
+    ##
+    ##        @rtype:  bool
+    ##        @return: C{True} if the two process IDs are equal,
+    ##            C{False} otherwise.
+    ##        """
+    ##        return isinstance(aProcess, Process)         and \
+    ##               self.get_pid() == aProcess.get_pid()
 
     def __contains__(self, anObject):
         """
@@ -293,8 +292,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @rtype:  bool
         @return: C{True} if the requested object was found in the snapshot.
         """
-        return _ThreadContainer.__contains__(self, anObject) or \
-               _ModuleContainer.__contains__(self, anObject)
+        return _ThreadContainer.__contains__(self, anObject) or _ModuleContainer.__contains__(self, anObject)
 
     def __len__(self):
         """
@@ -302,10 +300,9 @@ class Process (_ThreadContainer, _ModuleContainer):
         @rtype:  int
         @return: Count of L{Thread} and L{Module} objects in this snapshot.
         """
-        return _ThreadContainer.__len__(self) + \
-               _ModuleContainer.__len__(self)
+        return _ThreadContainer.__len__(self) + _ModuleContainer.__len__(self)
 
-    class __ThreadsAndModulesIterator (object):
+    class __ThreadsAndModulesIterator(object):
         """
         Iterator object for L{Process} objects.
         Iterates through L{Thread} objects first, L{Module} objects next.
@@ -317,30 +314,30 @@ class Process (_ThreadContainer, _ModuleContainer):
             @param container: L{Thread} and L{Module} container.
             """
             self.__container = container
-            self.__iterator  = None
-            self.__state     = 0
+            self.__iterator = None
+            self.__state = 0
 
         def __iter__(self):
-            'x.__iter__() <==> iter(x)'
+            "x.__iter__() <==> iter(x)"
             return self
 
         def next(self):
-            'x.next() -> the next value, or raise StopIteration'
+            "x.next() -> the next value, or raise StopIteration"
             if self.__state == 0:
                 self.__iterator = self.__container.iter_threads()
-                self.__state    = 1
+                self.__state = 1
             if self.__state == 1:
                 try:
                     return self.__iterator.next()
                 except StopIteration:
                     self.__iterator = self.__container.iter_modules()
-                    self.__state    = 2
+                    self.__state = 2
             if self.__state == 2:
                 try:
                     return self.__iterator.next()
                 except StopIteration:
                     self.__iterator = None
-                    self.__state    = 3
+                    self.__state = 3
             raise StopIteration
 
     def __iter__(self):
@@ -352,9 +349,9 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         return self.__ThreadsAndModulesIterator(self)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def wait(self, dwTimeout = None):
+    def wait(self, dwTimeout=None):
         """
         Waits for the process to finish executing.
 
@@ -362,7 +359,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         self.get_handle(win32.SYNCHRONIZE).wait(dwTimeout)
 
-    def kill(self, dwExitCode = 0):
+    def kill(self, dwExitCode=0):
         """
         Terminates the execution of the process.
 
@@ -377,7 +374,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.scan_threads() # force refresh the snapshot
+        self.scan_threads()  # force refresh the snapshot
         suspended = list()
         try:
             for aThread in self.iter_threads():
@@ -398,7 +395,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @raise WindowsError: On error an exception is raised.
         """
         if self.get_thread_count() == 0:
-            self.scan_threads() # only refresh the snapshot if empty
+            self.scan_threads()  # only refresh the snapshot if empty
         resumed = list()
         try:
             for aThread in self.iter_threads():
@@ -459,9 +456,9 @@ class Process (_ThreadContainer, _ModuleContainer):
             dwAccess = win32.PROCESS_QUERY_LIMITED_INFORMATION
         else:
             dwAccess = win32.PROCESS_QUERY_INFORMATION
-        return win32.GetExitCodeProcess( self.get_handle(dwAccess) )
+        return win32.GetExitCodeProcess(self.get_handle(dwAccess))
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def scan(self):
         """
@@ -482,10 +479,10 @@ class Process (_ThreadContainer, _ModuleContainer):
         finally:
             self.close_handle()
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # Regular expression to find hexadecimal values of any size.
-    __hexa_parameter = re.compile('0x[0-9A-Fa-f]+')
+    __hexa_parameter = re.compile("0x[0-9A-Fa-f]+")
 
     def __fixup_labels(self, disasm):
         """
@@ -504,7 +501,7 @@ class Process (_ThreadContainer, _ModuleContainer):
                 s, e = m.span()
                 value = text[s:e]
                 try:
-                    label = self.get_label_at_address( int(value, 0x10) )
+                    label = self.get_label_at_address(int(value, 0x10))
                 except Exception:
                     label = None
                 if label:
@@ -537,7 +534,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         try:
             disasm = self.__disasm
         except AttributeError:
-            disasm = self.__disasm = Disassembler( self.get_arch() )
+            disasm = self.__disasm = Disassembler(self.get_arch())
         return disasm.decode(lpAddress, code)
 
     def disassemble(self, lpAddress, dwSize):
@@ -558,14 +555,14 @@ class Process (_ThreadContainer, _ModuleContainer):
              - Disassembly line of instruction.
              - Hexadecimal dump of instruction.
         """
-        data   = self.read(lpAddress, dwSize)
+        data = self.read(lpAddress, dwSize)
         disasm = self.disassemble_string(lpAddress, data)
         self.__fixup_labels(disasm)
         return disasm
 
     # FIXME
     # This algorithm really bad, I've got to write a better one :P
-    def disassemble_around(self, lpAddress, dwSize = 64):
+    def disassemble_around(self, lpAddress, dwSize=64):
         """
         Disassemble around the given address.
 
@@ -584,21 +581,21 @@ class Process (_ThreadContainer, _ModuleContainer):
              - Disassembly line of instruction.
              - Hexadecimal dump of instruction.
         """
-        dwDelta  = int(float(dwSize) / 2.0)
-        addr_1   = lpAddress - dwDelta
-        addr_2   = lpAddress
-        size_1   = dwDelta
-        size_2   = dwSize - dwDelta
-        data     = self.read(addr_1, dwSize)
-        data_1   = data[:size_1]
-        data_2   = data[size_1:]
+        dwDelta = int(float(dwSize) / 2.0)
+        addr_1 = lpAddress - dwDelta
+        addr_2 = lpAddress
+        size_1 = dwDelta
+        size_2 = dwSize - dwDelta
+        data = self.read(addr_1, dwSize)
+        data_1 = data[:size_1]
+        data_2 = data[size_1:]
         disasm_1 = self.disassemble_string(addr_1, data_1)
         disasm_2 = self.disassemble_string(addr_2, data_2)
-        disasm   = disasm_1 + disasm_2
+        disasm = disasm_1 + disasm_2
         self.__fixup_labels(disasm)
         return disasm
 
-    def disassemble_around_pc(self, dwThreadId, dwSize = 64):
+    def disassemble_around_pc(self, dwThreadId, dwSize=64):
         """
         Disassemble around the program counter of the given thread.
 
@@ -659,7 +656,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         aThread = self.get_thread(dwThreadId)
         return self.disassemble_instruction(aThread.get_pc())
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def flush_instruction_cache(self):
         """
@@ -676,7 +673,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Maybe PROCESS_VM_OPERATION ???
         # In any case we're only calling this from the debugger,
         # so it should be fine (we already have PROCESS_ALL_ACCESS).
-        win32.FlushInstructionCache( self.get_handle() )
+        win32.FlushInstructionCache(self.get_handle())
 
     def debug_break(self):
         """
@@ -687,7 +684,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # The exception is raised by a new thread.
         # When continuing the exception, the thread dies by itself.
         # This thread is hidden from the debugger.
-        win32.DebugBreakProcess( self.get_handle() )
+        win32.DebugBreakProcess(self.get_handle())
 
     def is_wow64(self):
         """
@@ -709,7 +706,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         try:
             wow64 = self.__wow64
         except AttributeError:
-            if (win32.bits == 32 and not win32.wow64):
+            if win32.bits == 32 and not win32.wow64:
                 wow64 = False
             else:
                 if win32.PROCESS_ALL_ACCESS == win32.PROCESS_ALL_ACCESS_VISTA:
@@ -759,13 +756,11 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         # Are we in a 32 bit machine?
         if win32.bits == 32 and not win32.wow64:
-
             # All processes are 32 bits.
             return 32
 
         # Is the process inside WOW64?
         if self.is_wow64():
-
             # The process is 32 bits.
             return 32
 
@@ -775,7 +770,7 @@ class Process (_ThreadContainer, _ModuleContainer):
     # TODO: get_os, to test compatibility run
     # See: http://msdn.microsoft.com/en-us/library/windows/desktop/ms683224(v=vs.85).aspx
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def get_start_time(self):
         """
@@ -827,14 +822,14 @@ class Process (_ThreadContainer, _ModuleContainer):
         if self.is_alive():
             ExitTime = win32.GetSystemTimeAsFileTime()
         CreationTime = CreationTime.dwLowDateTime + (CreationTime.dwHighDateTime << 32)
-        ExitTime     =     ExitTime.dwLowDateTime + (    ExitTime.dwHighDateTime << 32)
-        RunningTime  = ExitTime - CreationTime
-        return RunningTime / 10000 # 100 nanoseconds steps => milliseconds
+        ExitTime = ExitTime.dwLowDateTime + (ExitTime.dwHighDateTime << 32)
+        RunningTime = ExitTime - CreationTime
+        return RunningTime / 10000  # 100 nanoseconds steps => milliseconds
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def __load_System_class(self):
-        global System      # delayed import
+        global System  # delayed import
         if System is None:
             from system import System
 
@@ -852,7 +847,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         pid = self.get_pid()
         return [d for d in System.get_active_services() if d.ProcessId == pid]
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def get_dep_policy(self):
         """
@@ -884,7 +879,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             msg = "This method is only available in Windows XP SP3 and above."
             raise NotImplementedError(msg)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def get_peb(self):
         """
@@ -895,8 +890,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: PEB structure.
         @raise WindowsError: An exception is raised on error.
         """
-        self.get_handle( win32.PROCESS_VM_READ |
-                         win32.PROCESS_QUERY_INFORMATION )
+        self.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
         return self.read_structure(self.get_peb_address(), win32.PEB)
 
     def get_peb_address(self):
@@ -911,8 +905,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             return self._peb_ptr
         except AttributeError:
             hProcess = self.get_handle(win32.PROCESS_QUERY_INFORMATION)
-            pbi = win32.NtQueryInformationProcess(hProcess,
-                                                win32.ProcessBasicInformation)
+            pbi = win32.NtQueryInformationProcess(hProcess, win32.ProcessBasicInformation)
             address = pbi.PebBaseAddress
             self._peb_ptr = address
             return address
@@ -961,18 +954,17 @@ class Process (_ThreadContainer, _ModuleContainer):
             if not name:
                 name = None
         except (KeyError, AttributeError, WindowsError):
-##            traceback.print_exc()                               # XXX DEBUG
+            ##            traceback.print_exc()                               # XXX DEBUG
             name = None
 
         # Method 2: QueryFullProcessImageName()
         # Not implemented until Windows Vista.
         if not name:
             try:
-                hProcess = self.get_handle(
-                                    win32.PROCESS_QUERY_LIMITED_INFORMATION)
+                hProcess = self.get_handle(win32.PROCESS_QUERY_LIMITED_INFORMATION)
                 name = win32.QueryFullProcessImageName(hProcess)
             except (AttributeError, WindowsError):
-##                traceback.print_exc()                           # XXX DEBUG
+                ##                traceback.print_exc()                           # XXX DEBUG
                 name = None
 
         # Method 3: GetProcessImageFileName()
@@ -989,7 +981,7 @@ class Process (_ThreadContainer, _ModuleContainer):
                 else:
                     name = None
             except (AttributeError, WindowsError):
-##                traceback.print_exc()                           # XXX DEBUG
+                ##                traceback.print_exc()                           # XXX DEBUG
                 if not name:
                     name = None
 
@@ -1000,20 +992,18 @@ class Process (_ThreadContainer, _ModuleContainer):
         # in usermode space (see http://www.ragestorm.net/blogs/?p=163).
         if not name:
             try:
-                hProcess = self.get_handle( win32.PROCESS_VM_READ |
-                                            win32.PROCESS_QUERY_INFORMATION )
+                hProcess = self.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
                 try:
                     name = win32.GetModuleFileNameEx(hProcess)
                 except WindowsError:
-##                    traceback.print_exc()                       # XXX DEBUG
-                    name = win32.GetModuleFileNameEx(
-                                            hProcess, self.get_image_base())
+                    ##                    traceback.print_exc()                       # XXX DEBUG
+                    name = win32.GetModuleFileNameEx(hProcess, self.get_image_base())
                 if name:
                     name = PathOperations.native_to_win32_pathname(name)
                 else:
                     name = None
             except (AttributeError, WindowsError):
-##                traceback.print_exc()                           # XXX DEBUG
+                ##                traceback.print_exc()                           # XXX DEBUG
                 if not name:
                     name = None
 
@@ -1026,17 +1016,15 @@ class Process (_ThreadContainer, _ModuleContainer):
         if not name:
             try:
                 peb = self.get_peb()
-                pp = self.read_structure(peb.ProcessParameters,
-                                             win32.RTL_USER_PROCESS_PARAMETERS)
+                pp = self.read_structure(peb.ProcessParameters, win32.RTL_USER_PROCESS_PARAMETERS)
                 s = pp.ImagePathName
-                name = self.peek_string(s.Buffer,
-                                    dwMaxSize=s.MaximumLength, fUnicode=True)
+                name = self.peek_string(s.Buffer, dwMaxSize=s.MaximumLength, fUnicode=True)
                 if name:
                     name = PathOperations.native_to_win32_pathname(name)
                 else:
                     name = None
             except (AttributeError, WindowsError):
-##                traceback.print_exc()                           # XXX DEBUG
+                ##                traceback.print_exc()                           # XXX DEBUG
                 name = None
 
         # Method 6: Module.get_filename()
@@ -1051,7 +1039,7 @@ class Process (_ThreadContainer, _ModuleContainer):
                 if not name:
                     name = None
             except (AttributeError, WindowsError):
-##                traceback.print_exc()                           # XXX DEBUG
+                ##                traceback.print_exc()                           # XXX DEBUG
                 name = None
 
         # Remember the filename.
@@ -1072,8 +1060,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @raise WindowsError: On error an exception is raised.
         """
         peb = self.get_peb()
-        pp = self.read_structure(peb.ProcessParameters,
-                                             win32.RTL_USER_PROCESS_PARAMETERS)
+        pp = self.read_structure(peb.ProcessParameters, win32.RTL_USER_PROCESS_PARAMETERS)
         s = pp.CommandLine
         return (s.Buffer, s.MaximumLength)
 
@@ -1092,8 +1079,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @raise WindowsError: On error an exception is raised.
         """
         peb = self.get_peb()
-        pp = self.read_structure(peb.ProcessParameters,
-                                             win32.RTL_USER_PROCESS_PARAMETERS)
+        pp = self.read_structure(peb.ProcessParameters, win32.RTL_USER_PROCESS_PARAMETERS)
         Environment = pp.Environment
         try:
             EnvironmentSize = pp.EnvironmentSize
@@ -1112,11 +1098,10 @@ class Process (_ThreadContainer, _ModuleContainer):
         @raise WindowsError: On error an exception is raised.
         """
         (Buffer, MaximumLength) = self.get_command_line_block()
-        CommandLine = self.peek_string(Buffer, dwMaxSize=MaximumLength,
-                                                            fUnicode=True)
+        CommandLine = self.peek_string(Buffer, dwMaxSize=MaximumLength, fUnicode=True)
         gst = win32.GuessStringType
         if gst.t_default == gst.t_ansi:
-            CommandLine = CommandLine.encode('cp1252')
+            CommandLine = CommandLine.encode("cp1252")
         return CommandLine
 
     def get_environment_variables(self):
@@ -1140,7 +1125,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # renders garbage.
 
         # Read the environment block contents.
-        data = self.peek( *self.get_environment_block() )
+        data = self.peek(*self.get_environment_block())
 
         # Put them into a Unicode buffer.
         tmp = ctypes.create_string_buffer(data)
@@ -1150,26 +1135,23 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         # Skip until the first Unicode null char is found.
         pos = 0
-        while buffer[pos] != u'\0':
+        while buffer[pos] != "\0":
             pos += 1
         pos += 1
 
         # Loop for each environment variable...
         environment = []
-        while buffer[pos] != u'\0':
-
+        while buffer[pos] != "\0":
             # Until we find a null char...
             env_name_pos = pos
-            env_name = u''
+            env_name = ""
             found_name = False
-            while buffer[pos] != u'\0':
-
+            while buffer[pos] != "\0":
                 # Get the current char.
                 char = buffer[pos]
 
                 # Is it an equal sign?
-                if char == u'=':
-
+                if char == "=":
                     # Skip leading equal signs.
                     if env_name_pos == pos:
                         env_name_pos += 1
@@ -1192,8 +1174,8 @@ class Process (_ThreadContainer, _ModuleContainer):
                 break
 
             # Read the variable value until we find a null char.
-            env_value = u''
-            while buffer[pos] != u'\0':
+            env_value = ""
+            while buffer[pos] != "\0":
                 env_value += buffer[pos]
                 pos += 1
 
@@ -1201,7 +1183,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             pos += 1
 
             # Add to the list of environment variables found.
-            environment.append( (env_name, env_value) )
+            environment.append((env_name, env_value))
 
         # Remove the last entry, it's garbage.
         if environment:
@@ -1210,7 +1192,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Return the environment variables.
         return environment
 
-    def get_environment_data(self, fUnicode = None):
+    def get_environment_data(self, fUnicode=None):
         """
         Retrieves the environment block data with wich the program is running.
 
@@ -1231,21 +1213,17 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
 
         # Issue a deprecation warning.
-        warnings.warn(
-            "Process.get_environment_data() is deprecated" \
-            " since WinAppDbg 1.5.",
-            DeprecationWarning)
+        warnings.warn("Process.get_environment_data() is deprecated" " since WinAppDbg 1.5.", DeprecationWarning)
 
         # Get the environment variables.
-        block = [ key + u'=' + value for (key, value) \
-                                     in self.get_environment_variables() ]
+        block = [key + "=" + value for (key, value) in self.get_environment_variables()]
 
         # Convert the data to ANSI if requested.
         if fUnicode is None:
             gst = win32.GuessStringType
             fUnicode = gst.t_default == gst.t_unicode
         if not fUnicode:
-            block = [x.encode('cp1252') for x in block]
+            block = [x.encode("cp1252") for x in block]
 
         # Return the environment data.
         return block
@@ -1267,10 +1245,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
 
         # Issue a deprecation warning.
-        warnings.warn(
-            "Process.parse_environment_data() is deprecated" \
-            " since WinAppDbg 1.5.",
-            DeprecationWarning)
+        warnings.warn("Process.parse_environment_data() is deprecated" " since WinAppDbg 1.5.", DeprecationWarning)
 
         # Create an empty environment dictionary.
         environment = dict()
@@ -1282,19 +1257,19 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Prepare the tokens (ANSI or Unicode).
         gst = win32.GuessStringType
         if type(block[0]) == gst.t_ansi:
-            equals = '='
-            terminator = '\0'
+            equals = "="
+            terminator = "\0"
         else:
-            equals = u'='
-            terminator = u'\0'
+            equals = "="
+            terminator = "\0"
 
         # Split the blocks into key/value pairs.
         for chunk in block:
             sep = chunk.find(equals, 1)
             if sep < 0:
-##                raise Exception()
-                continue    # corrupted environment block?
-            key, value = chunk[:sep], chunk[sep+1:]
+                ##                raise Exception()
+                continue  # corrupted environment block?
+            key, value = chunk[:sep], chunk[sep + 1 :]
 
             # For duplicated keys, append the value.
             # Values are separated using null terminators.
@@ -1306,7 +1281,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Return the environment dictionary.
         return environment
 
-    def get_environment(self, fUnicode = None):
+    def get_environment(self, fUnicode=None):
         """
         Retrieves the environment with wich the program is running.
 
@@ -1336,23 +1311,22 @@ class Process (_ThreadContainer, _ModuleContainer):
             gst = win32.GuessStringType
             fUnicode = gst.t_default == gst.t_unicode
         if not fUnicode:
-            variables = [ ( key.encode('cp1252'), value.encode('cp1252') ) \
-                        for (key, value) in variables ]
+            variables = [(key.encode("cp1252"), value.encode("cp1252")) for (key, value) in variables]
 
         # Add the variables to a dictionary, concatenating duplicates.
         environment = dict()
         for key, value in variables:
             if key in environment:
-                environment[key] = environment[key] + u'\0' + value
+                environment[key] = environment[key] + "\0" + value
             else:
                 environment[key] = value
 
         # Return the dictionary.
         return environment
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def search(self, pattern, minAddr = None, maxAddr = None):
+    def search(self, pattern, minAddr=None, maxAddr=None):
         """
         Search for the given pattern within the process memory.
 
@@ -1388,13 +1362,12 @@ class Process (_ThreadContainer, _ModuleContainer):
         if isinstance(pattern, str):
             return self.search_bytes(pattern, minAddr, maxAddr)
         if isinstance(pattern, compat.unicode):
-            return self.search_bytes(pattern.encode("utf-16le"),
-                                     minAddr, maxAddr)
+            return self.search_bytes(pattern.encode("utf-16le"), minAddr, maxAddr)
         if isinstance(pattern, Pattern):
             return Search.search_process(self, pattern, minAddr, maxAddr)
         raise TypeError("Unknown pattern type: %r" % type(pattern))
 
-    def search_bytes(self, bytes, minAddr = None, maxAddr = None):
+    def search_bytes(self, bytes, minAddr=None, maxAddr=None):
         """
         Search for the given byte pattern within the process memory.
 
@@ -1418,10 +1391,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         for addr, size, data in matches:
             yield addr
 
-    def search_text(self, text, encoding = "utf-16le",
-                                caseSensitive = False,
-                                minAddr = None,
-                                maxAddr = None):
+    def search_text(self, text, encoding="utf-16le", caseSensitive=False, minAddr=None, maxAddr=None):
         """
         Search for the given text within the process memory.
 
@@ -1456,10 +1426,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         for addr, size, data in matches:
             yield addr, data
 
-    def search_regexp(self, regexp, flags = 0,
-                                    minAddr = None,
-                                    maxAddr = None,
-                                    bufferPages = -1):
+    def search_regexp(self, regexp, flags=0, minAddr=None, maxAddr=None, bufferPages=-1):
         """
         Search for the given regular expression within the process memory.
 
@@ -1500,11 +1467,9 @@ class Process (_ThreadContainer, _ModuleContainer):
             process memory.
         """
         pattern = RegExpPattern(regexp, flags)
-        return Search.search_process(self, pattern,
-                                     minAddr, maxAddr,
-                                     bufferPages)
+        return Search.search_process(self, pattern, minAddr, maxAddr, bufferPages)
 
-    def search_hexa(self, hexa, minAddr = None, maxAddr = None):
+    def search_hexa(self, hexa, minAddr=None, maxAddr=None):
         """
         Search for the given hexadecimal pattern within the process memory.
 
@@ -1541,7 +1506,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         for addr, size, data in matches:
             yield addr, data
 
-    def strings(self, minSize = 4, maxSize = 1024):
+    def strings(self, minSize=4, maxSize=1024):
         """
         Extract ASCII strings from the process memory.
 
@@ -1558,10 +1523,9 @@ class Process (_ThreadContainer, _ModuleContainer):
              - The size of the string.
              - The string.
         """
-        return Search.extract_ascii_strings(self, minSize = minSize,
-                                                  maxSize = maxSize)
+        return Search.extract_ascii_strings(self, minSize=minSize, maxSize=maxSize)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def __read_c_type(self, address, format, c_type):
         size = ctypes.sizeof(c_type)
@@ -1571,7 +1535,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         return struct.unpack(format, packed)[0]
 
     def __write_c_type(self, address, format, unpacked):
-        packed = struct.pack('@L', unpacked)
+        packed = struct.pack("@L", unpacked)
         self.write(address, packed)
 
     # XXX TODO
@@ -1593,8 +1557,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        hProcess = self.get_handle( win32.PROCESS_VM_READ |
-                                    win32.PROCESS_QUERY_INFORMATION )
+        hProcess = self.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
         if not self.is_buffer(lpBaseAddress, nSize):
             raise ctypes.WinError(win32.ERROR_INVALID_ADDRESS)
         data = win32.ReadProcessMemory(hProcess, lpBaseAddress, nSize)
@@ -1636,7 +1599,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return ord( self.read(lpBaseAddress, 1) )
+        return ord(self.read(lpBaseAddress, 1))
 
     def write_char(self, lpBaseAddress, char):
         """
@@ -1670,7 +1633,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, compat.b('@l'), ctypes.c_int)
+        return self.__read_c_type(lpBaseAddress, compat.b("@l"), ctypes.c_int)
 
     def write_int(self, lpBaseAddress, unpackedValue):
         """
@@ -1688,7 +1651,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '@l', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "@l", unpackedValue)
 
     def read_uint(self, lpBaseAddress):
         """
@@ -1704,7 +1667,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '@L', ctypes.c_uint)
+        return self.__read_c_type(lpBaseAddress, "@L", ctypes.c_uint)
 
     def write_uint(self, lpBaseAddress, unpackedValue):
         """
@@ -1722,7 +1685,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '@L', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "@L", unpackedValue)
 
     def read_float(self, lpBaseAddress):
         """
@@ -1738,7 +1701,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '@f', ctypes.c_float)
+        return self.__read_c_type(lpBaseAddress, "@f", ctypes.c_float)
 
     def write_float(self, lpBaseAddress, unpackedValue):
         """
@@ -1756,7 +1719,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '@f', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "@f", unpackedValue)
 
     def read_double(self, lpBaseAddress):
         """
@@ -1772,7 +1735,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '@d', ctypes.c_double)
+        return self.__read_c_type(lpBaseAddress, "@d", ctypes.c_double)
 
     def write_double(self, lpBaseAddress, unpackedValue):
         """
@@ -1790,7 +1753,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '@d', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "@d", unpackedValue)
 
     def read_pointer(self, lpBaseAddress):
         """
@@ -1806,7 +1769,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '@P', ctypes.c_void_p)
+        return self.__read_c_type(lpBaseAddress, "@P", ctypes.c_void_p)
 
     def write_pointer(self, lpBaseAddress, unpackedValue):
         """
@@ -1824,7 +1787,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '@P', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "@P", unpackedValue)
 
     def read_dword(self, lpBaseAddress):
         """
@@ -1840,7 +1803,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '=L', win32.DWORD)
+        return self.__read_c_type(lpBaseAddress, "=L", win32.DWORD)
 
     def write_dword(self, lpBaseAddress, unpackedValue):
         """
@@ -1858,7 +1821,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '=L', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "=L", unpackedValue)
 
     def read_qword(self, lpBaseAddress):
         """
@@ -1874,7 +1837,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        return self.__read_c_type(lpBaseAddress, '=Q', win32.QWORD)
+        return self.__read_c_type(lpBaseAddress, "=Q", win32.QWORD)
 
     def write_qword(self, lpBaseAddress, unpackedValue):
         """
@@ -1892,7 +1855,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         @raise WindowsError: On error an exception is raised.
         """
-        self.__write_c_type(lpBaseAddress, '=Q', unpackedValue)
+        self.__write_c_type(lpBaseAddress, "=Q", unpackedValue)
 
     def read_structure(self, lpBaseAddress, stype):
         """
@@ -1916,36 +1879,36 @@ class Process (_ThreadContainer, _ModuleContainer):
             lpBaseAddress = ctypes.cast(lpBaseAddress, ctypes.c_void_p)
         data = self.read(lpBaseAddress, ctypes.sizeof(stype))
         buff = ctypes.create_string_buffer(data)
-        ptr  = ctypes.cast(ctypes.pointer(buff), ctypes.POINTER(stype))
+        ptr = ctypes.cast(ctypes.pointer(buff), ctypes.POINTER(stype))
         return ptr.contents
 
-# XXX TODO
-##    def write_structure(self, lpBaseAddress, sStructure):
-##        """
-##        Writes a ctypes structure into the memory of the process.
-##
-##        @note: Page permissions may be changed temporarily while writing.
-##
-##        @see: L{write}
-##
-##        @type  lpBaseAddress: int
-##        @param lpBaseAddress: Memory address to begin writing.
-##
-##        @type  sStructure: ctypes.Structure or a subclass' instance.
-##        @param sStructure: Structure definition.
-##
-##        @rtype:  int
-##        @return: Structure instance filled in with data
-##            read from the process memory.
-##
-##        @raise WindowsError: On error an exception is raised.
-##        """
-##        size = ctypes.sizeof(sStructure)
-##        data = ctypes.create_string_buffer("", size = size)
-##        win32.CopyMemory(ctypes.byref(data), ctypes.byref(sStructure), size)
-##        self.write(lpBaseAddress, data.raw)
-
-    def read_string(self, lpBaseAddress, nChars, fUnicode = False):
+    # XXX TODO
+    ##    def write_structure(self, lpBaseAddress, sStructure):
+    ##        """
+    ##        Writes a ctypes structure into the memory of the process.
+    ##
+    ##        @note: Page permissions may be changed temporarily while writing.
+    ##
+    ##        @see: L{write}
+    ##
+    ##        @type  lpBaseAddress: int
+    ##        @param lpBaseAddress: Memory address to begin writing.
+    ##
+    ##        @type  sStructure: ctypes.Structure or a subclass' instance.
+    ##        @param sStructure: Structure definition.
+    ##
+    ##        @rtype:  int
+    ##        @return: Structure instance filled in with data
+    ##            read from the process memory.
+    ##
+    ##        @raise WindowsError: On error an exception is raised.
+    ##        """
+    ##        size = ctypes.sizeof(sStructure)
+    ##        data = ctypes.create_string_buffer("", size = size)
+    ##        win32.CopyMemory(ctypes.byref(data), ctypes.byref(sStructure), size)
+    ##        self.write(lpBaseAddress, data.raw)
+
+    def read_string(self, lpBaseAddress, nChars, fUnicode=False):
         """
         Reads an ASCII or Unicode string
         from the address space of the process.
@@ -1972,23 +1935,23 @@ class Process (_ThreadContainer, _ModuleContainer):
             nChars = nChars * 2
         szString = self.read(lpBaseAddress, nChars)
         if fUnicode:
-            szString = compat.unicode(szString, 'U16', 'ignore')
+            szString = compat.unicode(szString, "U16", "ignore")
         return szString
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # FIXME this won't work properly with a different endianness!
     def __peek_c_type(self, address, format, c_type):
         size = ctypes.sizeof(c_type)
         packed = self.peek(address, size)
         if len(packed) < size:
-            packed = '\0' * (size - len(packed)) + packed
+            packed = "\0" * (size - len(packed)) + packed
         elif len(packed) > size:
             packed = packed[:size]
         return struct.unpack(format, packed)[0]
 
     def __poke_c_type(self, address, format, unpacked):
-        packed = struct.pack('@L', unpacked)
+        packed = struct.pack("@L", unpacked)
         return self.poke(address, packed)
 
     def peek(self, lpBaseAddress, nSize):
@@ -2011,25 +1974,20 @@ class Process (_ThreadContainer, _ModuleContainer):
         # + Maybe change page permissions before trying to read?
         # + Maybe use mquery instead of get_memory_map?
         #   (less syscalls if we break out of the loop earlier)
-        data = ''
+        data = ""
         if nSize > 0:
             try:
-                hProcess = self.get_handle( win32.PROCESS_VM_READ |
-                                            win32.PROCESS_QUERY_INFORMATION )
-                for mbi in self.get_memory_map(lpBaseAddress,
-                                               lpBaseAddress + nSize):
+                hProcess = self.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
+                for mbi in self.get_memory_map(lpBaseAddress, lpBaseAddress + nSize):
                     if not mbi.is_readable():
                         nSize = mbi.BaseAddress - lpBaseAddress
                         break
                 if nSize > 0:
-                    data = win32.ReadProcessMemory(
-                                    hProcess, lpBaseAddress, nSize)
+                    data = win32.ReadProcessMemory(hProcess, lpBaseAddress, nSize)
             except WindowsError:
                 e = sys.exc_info()[1]
                 msg = "Error reading process %d address %s: %s"
-                msg %= (self.get_pid(),
-                        HexDump.address(lpBaseAddress),
-                        e.strerror)
+                msg %= (self.get_pid(), HexDump.address(lpBaseAddress), e.strerror)
                 warnings.warn(msg)
         return data
 
@@ -2052,9 +2010,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             May be less than the number of bytes to write.
         """
         assert isinstance(lpBuffer, compat.bytes)
-        hProcess = self.get_handle( win32.PROCESS_VM_WRITE |
-                                    win32.PROCESS_VM_OPERATION |
-                                    win32.PROCESS_QUERY_INFORMATION )
+        hProcess = self.get_handle(win32.PROCESS_VM_WRITE | win32.PROCESS_VM_OPERATION | win32.PROCESS_QUERY_INFORMATION)
         mbi = self.mquery(lpBaseAddress)
         if not mbi.has_content():
             raise ctypes.WinError(win32.ERROR_INVALID_ADDRESS)
@@ -2071,11 +2027,8 @@ class Process (_ThreadContainer, _ModuleContainer):
                 self.mprotect(lpBaseAddress, len(lpBuffer), prot)
             except Exception:
                 prot = None
-                msg = ("Failed to adjust page permissions"
-                       " for process %s at address %s: %s")
-                msg = msg % (self.get_pid(),
-                             HexDump.address(lpBaseAddress, self.get_bits()),
-                             traceback.format_exc())
+                msg = "Failed to adjust page permissions" " for process %s at address %s: %s"
+                msg = msg % (self.get_pid(), HexDump.address(lpBaseAddress, self.get_bits()), traceback.format_exc())
                 warnings.warn(msg, RuntimeWarning)
         try:
             r = win32.WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer)
@@ -2135,7 +2088,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '@l', ctypes.c_int)
+        return self.__peek_c_type(lpBaseAddress, "@l", ctypes.c_int)
 
     def poke_int(self, lpBaseAddress, unpackedValue):
         """
@@ -2155,7 +2108,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '@l', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "@l", unpackedValue)
 
     def peek_uint(self, lpBaseAddress):
         """
@@ -2170,7 +2123,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '@L', ctypes.c_uint)
+        return self.__peek_c_type(lpBaseAddress, "@L", ctypes.c_uint)
 
     def poke_uint(self, lpBaseAddress, unpackedValue):
         """
@@ -2190,7 +2143,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '@L', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "@L", unpackedValue)
 
     def peek_float(self, lpBaseAddress):
         """
@@ -2205,7 +2158,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '@f', ctypes.c_float)
+        return self.__peek_c_type(lpBaseAddress, "@f", ctypes.c_float)
 
     def poke_float(self, lpBaseAddress, unpackedValue):
         """
@@ -2225,7 +2178,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '@f', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "@f", unpackedValue)
 
     def peek_double(self, lpBaseAddress):
         """
@@ -2240,7 +2193,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '@d', ctypes.c_double)
+        return self.__peek_c_type(lpBaseAddress, "@d", ctypes.c_double)
 
     def poke_double(self, lpBaseAddress, unpackedValue):
         """
@@ -2260,7 +2213,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '@d', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "@d", unpackedValue)
 
     def peek_dword(self, lpBaseAddress):
         """
@@ -2275,7 +2228,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '=L', win32.DWORD)
+        return self.__peek_c_type(lpBaseAddress, "=L", win32.DWORD)
 
     def poke_dword(self, lpBaseAddress, unpackedValue):
         """
@@ -2295,7 +2248,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '=L', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "=L", unpackedValue)
 
     def peek_qword(self, lpBaseAddress):
         """
@@ -2310,7 +2263,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Integer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '=Q', win32.QWORD)
+        return self.__peek_c_type(lpBaseAddress, "=Q", win32.QWORD)
 
     def poke_qword(self, lpBaseAddress, unpackedValue):
         """
@@ -2330,7 +2283,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '=Q', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "=Q", unpackedValue)
 
     def peek_pointer(self, lpBaseAddress):
         """
@@ -2345,7 +2298,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Pointer value read from the process memory.
             Returns zero on error.
         """
-        return self.__peek_c_type(lpBaseAddress, '@P', ctypes.c_void_p)
+        return self.__peek_c_type(lpBaseAddress, "@P", ctypes.c_void_p)
 
     def poke_pointer(self, lpBaseAddress, unpackedValue):
         """
@@ -2365,9 +2318,9 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Number of bytes written.
             May be less than the number of bytes to write.
         """
-        return self.__poke_c_type(lpBaseAddress, '@P', unpackedValue)
+        return self.__poke_c_type(lpBaseAddress, "@P", unpackedValue)
 
-    def peek_string(self, lpBaseAddress, fUnicode = False, dwMaxSize = 0x1000):
+    def peek_string(self, lpBaseAddress, fUnicode=False, dwMaxSize=0x1000):
         """
         Tries to read an ASCII or Unicode string
         from the address space of the process.
@@ -2393,8 +2346,8 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Validate the parameters.
         if not lpBaseAddress or dwMaxSize == 0:
             if fUnicode:
-                return u''
-            return ''
+                return ""
+            return ""
         if not dwMaxSize:
             dwMaxSize = 0x1000
 
@@ -2403,31 +2356,29 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         # If the string is Unicode...
         if fUnicode:
-
             # Decode the string.
-            szString = compat.unicode(szString, 'U16', 'replace')
-##            try:
-##                szString = compat.unicode(szString, 'U16')
-##            except UnicodeDecodeError:
-##                szString = struct.unpack('H' * (len(szString) / 2), szString)
-##                szString = [ unichr(c) for c in szString ]
-##                szString = u''.join(szString)
+            szString = compat.unicode(szString, "U16", "replace")
+            ##            try:
+            ##                szString = compat.unicode(szString, 'U16')
+            ##            except UnicodeDecodeError:
+            ##                szString = struct.unpack('H' * (len(szString) / 2), szString)
+            ##                szString = [ unichr(c) for c in szString ]
+            ##                szString = u''.join(szString)
 
             # Truncate the string when the first null char is found.
-            szString = szString[ : szString.find(u'\0') ]
+            szString = szString[: szString.find("\0")]
 
         # If the string is ANSI...
         else:
-
             # Truncate the string when the first null char is found.
-            szString = szString[ : szString.find('\0') ]
+            szString = szString[: szString.find("\0")]
 
         # Return the decoded string.
         return szString
 
     # TODO
     # try to avoid reading the same page twice by caching it
-    def peek_pointers_in_data(self, data, peekSize = 16, peekStep = 1):
+    def peek_pointers_in_data(self, data, peekSize=16, peekStep=1):
         """
         Tries to guess which values in the given data are valid pointers,
         and reads some data from them.
@@ -2452,23 +2403,23 @@ class Process (_ThreadContainer, _ModuleContainer):
         result = dict()
         ptrSize = win32.sizeof(win32.LPVOID)
         if ptrSize == 4:
-            ptrFmt = '<L'
+            ptrFmt = "<L"
         else:
-            ptrFmt = '<Q'
+            ptrFmt = "<Q"
         if len(data) > 0:
             for i in compat.xrange(0, len(data), peekStep):
-                packed          = data[i:i+ptrSize]
+                packed = data[i : i + ptrSize]
                 if len(packed) == ptrSize:
-                    address     = struct.unpack(ptrFmt, packed)[0]
-##                    if not address & (~0xFFFF): continue
-                    peek_data   = self.peek(address, peekSize)
+                    address = struct.unpack(ptrFmt, packed)[0]
+                    ##                    if not address & (~0xFFFF): continue
+                    peek_data = self.peek(address, peekSize)
                     if peek_data:
                         result[i] = peek_data
         return result
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def malloc(self, dwSize, lpAddress = None):
+    def malloc(self, dwSize, lpAddress=None):
         """
         Allocates memory into the address space of the process.
 
@@ -2547,7 +2498,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         hProcess = self.get_handle(win32.PROCESS_VM_OPERATION)
         win32.VirtualFreeEx(hProcess, lpAddress)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def is_pointer(self, address):
         """
@@ -3031,7 +2982,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             size = size - mbi.RegionSize
         return True
 
-    def get_memory_map(self, minAddr = None, maxAddr = None):
+    def get_memory_map(self, minAddr=None, maxAddr=None):
         """
         Produces a memory map to the process address space.
 
@@ -3050,7 +3001,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         return list(self.iter_memory_map(minAddr, maxAddr))
 
-    def generate_memory_map(self, minAddr = None, maxAddr = None):
+    def generate_memory_map(self, minAddr=None, maxAddr=None):
         """
         Returns a L{Regenerator} that can iterate indefinitely over the memory
         map to the process address space.
@@ -3070,7 +3021,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         return Regenerator(self.iter_memory_map, minAddr, maxAddr)
 
-    def iter_memory_map(self, minAddr = None, maxAddr = None):
+    def iter_memory_map(self, minAddr=None, maxAddr=None):
         """
         Produces an iterator over the memory map to the process address space.
 
@@ -3087,8 +3038,8 @@ class Process (_ThreadContainer, _ModuleContainer):
         @rtype:  iterator of L{win32.MemoryBasicInformation}
         @return: List of memory region information objects.
         """
-        minAddr, maxAddr = MemoryAddresses.align_address_range(minAddr,maxAddr)
-        prevAddr    = minAddr - 1
+        minAddr, maxAddr = MemoryAddresses.align_address_range(minAddr, maxAddr)
+        prevAddr = minAddr - 1
         currentAddr = minAddr
         while prevAddr < currentAddr < maxAddr:
             try:
@@ -3099,10 +3050,10 @@ class Process (_ThreadContainer, _ModuleContainer):
                     break
                 raise
             yield mbi
-            prevAddr    = currentAddr
+            prevAddr = currentAddr
             currentAddr = mbi.BaseAddress + mbi.RegionSize
 
-    def get_mapped_filenames(self, memoryMap = None):
+    def get_mapped_filenames(self, memoryMap=None):
         """
         Retrieves the filenames for memory mapped files in the debugee.
 
@@ -3114,8 +3065,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         @return: Dictionary mapping memory addresses to file names.
             Native filenames are converted to Win32 filenames when possible.
         """
-        hProcess = self.get_handle( win32.PROCESS_VM_READ |
-                                    win32.PROCESS_QUERY_INFORMATION )
+        hProcess = self.get_handle(win32.PROCESS_VM_READ | win32.PROCESS_QUERY_INFORMATION)
         if not memoryMap:
             memoryMap = self.get_memory_map()
         mappedFilenames = dict()
@@ -3123,24 +3073,24 @@ class Process (_ThreadContainer, _ModuleContainer):
             if mbi.Type not in (win32.MEM_IMAGE, win32.MEM_MAPPED):
                 continue
             baseAddress = mbi.BaseAddress
-            fileName    = ""
+            fileName = ""
             try:
                 fileName = win32.GetMappedFileName(hProcess, baseAddress)
                 fileName = PathOperations.native_to_win32_pathname(fileName)
             except WindowsError:
-                #e = sys.exc_info()[1]
-                #try:
+                # e = sys.exc_info()[1]
+                # try:
                 #    msg = "Can't get mapped file name at address %s in process " \
                 #          "%d, reason: %s" % (HexDump.address(baseAddress),
                 #                              self.get_pid(),
                 #                              e.strerror)
                 #    warnings.warn(msg, Warning)
-                #except Exception:
+                # except Exception:
                 pass
             mappedFilenames[baseAddress] = fileName
         return mappedFilenames
 
-    def generate_memory_snapshot(self, minAddr = None, maxAddr = None):
+    def generate_memory_snapshot(self, minAddr=None, maxAddr=None):
         """
         Returns a L{Regenerator} that allows you to iterate through the memory
         contents of a process indefinitely.
@@ -3185,7 +3135,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         return Regenerator(self.iter_memory_snapshot, minAddr, maxAddr)
 
-    def iter_memory_snapshot(self, minAddr = None, maxAddr = None):
+    def iter_memory_snapshot(self, minAddr=None, maxAddr=None):
         """
         Returns an iterator that allows you to go through the memory contents
         of a process.
@@ -3257,7 +3207,7 @@ class Process (_ThreadContainer, _ModuleContainer):
             minAddr = MemoryAddresses.align_address_to_page_start(minAddr)
             mbi = memory[0]
             if mbi.BaseAddress < minAddr:
-                mbi.RegionSize  = mbi.BaseAddress + mbi.RegionSize - minAddr
+                mbi.RegionSize = mbi.BaseAddress + mbi.RegionSize - minAddr
                 mbi.BaseAddress = minAddr
 
         # Trim the last memory information block if needed.
@@ -3270,7 +3220,7 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         # Read the contents of each block and yield it.
         while memory:
-            mbi = memory.pop(0) # so the garbage collector can take it
+            mbi = memory.pop(0)  # so the garbage collector can take it
             mbi.filename = filenames.get(mbi.BaseAddress, None)
             if mbi.has_content():
                 mbi.content = self.read(mbi.BaseAddress, mbi.RegionSize)
@@ -3278,7 +3228,7 @@ class Process (_ThreadContainer, _ModuleContainer):
                 mbi.content = None
             yield mbi
 
-    def take_memory_snapshot(self, minAddr = None, maxAddr = None):
+    def take_memory_snapshot(self, minAddr=None, maxAddr=None):
         """
         Takes a snapshot of the memory contents of the process.
 
@@ -3316,11 +3266,9 @@ class Process (_ThreadContainer, _ModuleContainer):
              - C{filename}: Mapped filename, or C{None}.
              - C{content}: Memory contents, or C{None}.
         """
-        return list( self.iter_memory_snapshot(minAddr, maxAddr) )
+        return list(self.iter_memory_snapshot(minAddr, maxAddr))
 
-    def restore_memory_snapshot(self, snapshot,
-                                bSkipMappedFiles = True,
-                                bSkipOnError = False):
+    def restore_memory_snapshot(self, snapshot, bSkipMappedFiles=True, bSkipOnError=False):
         """
         Attempts to restore the memory state as it was when the given snapshot
         was taken.
@@ -3352,42 +3300,34 @@ class Process (_ThreadContainer, _ModuleContainer):
         @raise RuntimeError: An error occured while restoring the snapshot.
         @raise TypeError: A snapshot of the wrong type was passed.
         """
-        if not snapshot or not isinstance(snapshot, list) \
-                or not isinstance(snapshot[0], win32.MemoryBasicInformation):
-            raise TypeError( "Only snapshots returned by " \
-                             "take_memory_snapshot() can be used here." )
+        if not snapshot or not isinstance(snapshot, list) or not isinstance(snapshot[0], win32.MemoryBasicInformation):
+            raise TypeError("Only snapshots returned by " "take_memory_snapshot() can be used here.")
 
         # Get the process handle.
-        hProcess = self.get_handle( win32.PROCESS_VM_WRITE          |
-                                    win32.PROCESS_VM_OPERATION      |
-                                    win32.PROCESS_SUSPEND_RESUME    |
-                                    win32.PROCESS_QUERY_INFORMATION )
+        hProcess = self.get_handle(
+            win32.PROCESS_VM_WRITE | win32.PROCESS_VM_OPERATION | win32.PROCESS_SUSPEND_RESUME | win32.PROCESS_QUERY_INFORMATION
+        )
 
         # Freeze the process.
         self.suspend()
         try:
-
             # For each memory region in the snapshot...
             for old_mbi in snapshot:
-
                 # If the region matches, restore it directly.
                 new_mbi = self.mquery(old_mbi.BaseAddress)
-                if new_mbi.BaseAddress == old_mbi.BaseAddress and \
-                                    new_mbi.RegionSize == old_mbi.RegionSize:
-                    self.__restore_mbi(hProcess, new_mbi, old_mbi,
-                                       bSkipMappedFiles)
+                if new_mbi.BaseAddress == old_mbi.BaseAddress and new_mbi.RegionSize == old_mbi.RegionSize:
+                    self.__restore_mbi(hProcess, new_mbi, old_mbi, bSkipMappedFiles)
 
                 # If the region doesn't match, restore it page by page.
                 else:
-
                     # We need a copy so we don't corrupt the snapshot.
                     old_mbi = win32.MemoryBasicInformation(old_mbi)
 
                     # Get the overlapping range of pages.
                     old_start = old_mbi.BaseAddress
-                    old_end   = old_start + old_mbi.RegionSize
+                    old_end = old_start + old_mbi.RegionSize
                     new_start = new_mbi.BaseAddress
-                    new_end   = new_start + new_mbi.RegionSize
+                    new_end = new_start + new_mbi.RegionSize
                     if old_start > new_start:
                         start = old_start
                     else:
@@ -3405,114 +3345,83 @@ class Process (_ThreadContainer, _ModuleContainer):
                     while address < end:
                         old_mbi.BaseAddress = address
                         new_mbi.BaseAddress = address
-                        self.__restore_mbi(hProcess, new_mbi, old_mbi,
-                                           bSkipMappedFiles, bSkipOnError)
+                        self.__restore_mbi(hProcess, new_mbi, old_mbi, bSkipMappedFiles, bSkipOnError)
                         address = address + step
 
         # Resume execution.
         finally:
             self.resume()
 
-    def __restore_mbi(self, hProcess, new_mbi, old_mbi, bSkipMappedFiles,
-                      bSkipOnError):
+    def __restore_mbi(self, hProcess, new_mbi, old_mbi, bSkipMappedFiles, bSkipOnError):
         """
         Used internally by L{restore_memory_snapshot}.
         """
 
-##        print "Restoring %s-%s" % (
-##            HexDump.address(old_mbi.BaseAddress, self.get_bits()),
-##            HexDump.address(old_mbi.BaseAddress + old_mbi.RegionSize,
-##                            self.get_bits()))
+        ##        print "Restoring %s-%s" % (
+        ##            HexDump.address(old_mbi.BaseAddress, self.get_bits()),
+        ##            HexDump.address(old_mbi.BaseAddress + old_mbi.RegionSize,
+        ##                            self.get_bits()))
 
         try:
-
             # Restore the region state.
             if new_mbi.State != old_mbi.State:
                 if new_mbi.is_free():
                     if old_mbi.is_reserved():
-
                         # Free -> Reserved
-                        address = win32.VirtualAllocEx(hProcess,
-                                                       old_mbi.BaseAddress,
-                                                       old_mbi.RegionSize,
-                                                       win32.MEM_RESERVE,
-                                                       old_mbi.Protect)
+                        address = win32.VirtualAllocEx(
+                            hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_RESERVE, old_mbi.Protect
+                        )
                         if address != old_mbi.BaseAddress:
                             self.free(address)
                             msg = "Error restoring region at address %s"
-                            msg = msg % HexDump(old_mbi.BaseAddress,
-                                                self.get_bits())
+                            msg = msg % HexDump(old_mbi.BaseAddress, self.get_bits())
                             raise RuntimeError(msg)
                         # permissions already restored
                         new_mbi.Protect = old_mbi.Protect
 
-                    else:   # elif old_mbi.is_commited():
-
+                    else:  # elif old_mbi.is_commited():
                         # Free -> Commited
-                        address = win32.VirtualAllocEx(hProcess,
-                                                       old_mbi.BaseAddress,
-                                                       old_mbi.RegionSize,
-                                                       win32.MEM_RESERVE | \
-                                                       win32.MEM_COMMIT,
-                                                       old_mbi.Protect)
+                        address = win32.VirtualAllocEx(
+                            hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_RESERVE | win32.MEM_COMMIT, old_mbi.Protect
+                        )
                         if address != old_mbi.BaseAddress:
                             self.free(address)
                             msg = "Error restoring region at address %s"
-                            msg = msg % HexDump(old_mbi.BaseAddress,
-                                                self.get_bits())
+                            msg = msg % HexDump(old_mbi.BaseAddress, self.get_bits())
                             raise RuntimeError(msg)
                         # permissions already restored
                         new_mbi.Protect = old_mbi.Protect
 
                 elif new_mbi.is_reserved():
                     if old_mbi.is_commited():
-
                         # Reserved -> Commited
-                        address = win32.VirtualAllocEx(hProcess,
-                                                       old_mbi.BaseAddress,
-                                                       old_mbi.RegionSize,
-                                                       win32.MEM_COMMIT,
-                                                       old_mbi.Protect)
+                        address = win32.VirtualAllocEx(hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_COMMIT, old_mbi.Protect)
                         if address != old_mbi.BaseAddress:
                             self.free(address)
                             msg = "Error restoring region at address %s"
-                            msg = msg % HexDump(old_mbi.BaseAddress,
-                                                self.get_bits())
+                            msg = msg % HexDump(old_mbi.BaseAddress, self.get_bits())
                             raise RuntimeError(msg)
                         # permissions already restored
                         new_mbi.Protect = old_mbi.Protect
 
-                    else:   # elif old_mbi.is_free():
-
+                    else:  # elif old_mbi.is_free():
                         # Reserved -> Free
-                        win32.VirtualFreeEx(hProcess,
-                                            old_mbi.BaseAddress,
-                                            old_mbi.RegionSize,
-                                            win32.MEM_RELEASE)
+                        win32.VirtualFreeEx(hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_RELEASE)
 
-                else:   # elif new_mbi.is_commited():
+                else:  # elif new_mbi.is_commited():
                     if old_mbi.is_reserved():
-
                         # Commited -> Reserved
-                        win32.VirtualFreeEx(hProcess,
-                                            old_mbi.BaseAddress,
-                                            old_mbi.RegionSize,
-                                            win32.MEM_DECOMMIT)
-
-                    else:   # elif old_mbi.is_free():
+                        win32.VirtualFreeEx(hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_DECOMMIT)
 
+                    else:  # elif old_mbi.is_free():
                         # Commited -> Free
-                        win32.VirtualFreeEx(hProcess,
-                                            old_mbi.BaseAddress,
-                                            old_mbi.RegionSize,
-                                            win32.MEM_DECOMMIT | win32.MEM_RELEASE)
+                        win32.VirtualFreeEx(hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, win32.MEM_DECOMMIT | win32.MEM_RELEASE)
 
             new_mbi.State = old_mbi.State
 
             # Restore the region permissions.
             if old_mbi.is_commited() and old_mbi.Protect != new_mbi.Protect:
-                win32.VirtualProtectEx(hProcess, old_mbi.BaseAddress,
-                                       old_mbi.RegionSize, old_mbi.Protect)
+                win32.VirtualProtectEx(hProcess, old_mbi.BaseAddress, old_mbi.RegionSize, old_mbi.Protect)
                 new_mbi.Protect = old_mbi.Protect
 
             # Restore the region data.
@@ -3530,14 +3439,12 @@ class Process (_ThreadContainer, _ModuleContainer):
             if not bSkipOnError:
                 raise
             msg = "Error restoring region at address %s: %s"
-            msg = msg % (
-                HexDump(old_mbi.BaseAddress, self.get_bits()),
-                traceback.format_exc())
+            msg = msg % (HexDump(old_mbi.BaseAddress, self.get_bits()), traceback.format_exc())
             warnings.warn(msg, RuntimeWarning)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
-    def inject_code(self, payload, lpParameter = 0):
+    def inject_code(self, payload, lpParameter=0):
         """
         Injects relocatable code into the process memory and executes it.
 
@@ -3560,20 +3467,18 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
 
         # Uncomment for debugging...
-##        payload = '\xCC' + payload
+        ##        payload = '\xCC' + payload
 
         # Allocate the memory for the shellcode.
         lpStartAddress = self.malloc(len(payload))
 
         # Catch exceptions so we can free the memory on error.
         try:
-
             # Write the shellcode to our memory location.
             self.write(lpStartAddress, payload)
 
             # Start a new thread for the shellcode to run.
-            aThread = self.start_thread(lpStartAddress, lpParameter,
-                                                            bSuspended = False)
+            aThread = self.start_thread(lpStartAddress, lpParameter, bSuspended=False)
 
             # Remember the shellcode address.
             #  It will be freed ONLY by the Thread.kill() method
@@ -3594,8 +3499,7 @@ class Process (_ThreadContainer, _ModuleContainer):
     # The shellcode should check for errors, otherwise it just crashes
     # when the DLL can't be loaded or the procedure can't be found.
     # On error the shellcode should execute an int3 instruction.
-    def inject_dll(self, dllname, procname = None, lpParameter = 0,
-                                               bWait = True, dwTimeout = None):
+    def inject_dll(self, dllname, procname=None, lpParameter=0, bWait=True, dwTimeout=None):
         """
         Injects a DLL into the process memory.
 
@@ -3652,13 +3556,12 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
 
         # Resolve kernel32.dll
-        aModule = self.get_module_by_name(compat.b('kernel32.dll'))
+        aModule = self.get_module_by_name(compat.b("kernel32.dll"))
         if aModule is None:
             self.scan_modules()
-            aModule = self.get_module_by_name(compat.b('kernel32.dll'))
+            aModule = self.get_module_by_name(compat.b("kernel32.dll"))
         if aModule is None:
-            raise RuntimeError(
-                "Cannot resolve kernel32.dll in the remote process")
+            raise RuntimeError("Cannot resolve kernel32.dll in the remote process")
 
         # Old method, using shellcode.
         if procname:
@@ -3667,88 +3570,81 @@ class Process (_ThreadContainer, _ModuleContainer):
             dllname = compat.b(dllname)
 
             # Resolve kernel32.dll!LoadLibraryA
-            pllib = aModule.resolve(compat.b('LoadLibraryA'))
+            pllib = aModule.resolve(compat.b("LoadLibraryA"))
             if not pllib:
-                raise RuntimeError(
-                    "Cannot resolve kernel32.dll!LoadLibraryA"
-                    " in the remote process")
+                raise RuntimeError("Cannot resolve kernel32.dll!LoadLibraryA" " in the remote process")
 
             # Resolve kernel32.dll!GetProcAddress
-            pgpad = aModule.resolve(compat.b('GetProcAddress'))
+            pgpad = aModule.resolve(compat.b("GetProcAddress"))
             if not pgpad:
-                raise RuntimeError(
-                    "Cannot resolve kernel32.dll!GetProcAddress"
-                    " in the remote process")
+                raise RuntimeError("Cannot resolve kernel32.dll!GetProcAddress" " in the remote process")
 
             # Resolve kernel32.dll!VirtualFree
-            pvf = aModule.resolve(compat.b('VirtualFree'))
+            pvf = aModule.resolve(compat.b("VirtualFree"))
             if not pvf:
-                raise RuntimeError(
-                    "Cannot resolve kernel32.dll!VirtualFree"
-                    " in the remote process")
+                raise RuntimeError("Cannot resolve kernel32.dll!VirtualFree" " in the remote process")
 
             # Shellcode follows...
-            code  = compat.b('')
+            code = compat.b("")
 
             # push dllname
-            code += compat.b('\xe8') + struct.pack('<L', len(dllname) + 1) + dllname + compat.b('\0')
+            code += compat.b("\xe8") + struct.pack("<L", len(dllname) + 1) + dllname + compat.b("\0")
 
             # mov eax, LoadLibraryA
-            code += compat.b('\xb8') + struct.pack('<L', pllib)
+            code += compat.b("\xb8") + struct.pack("<L", pllib)
 
             # call eax
-            code += compat.b('\xff\xd0')
+            code += compat.b("\xff\xd0")
 
             if procname:
-
                 # push procname
-                code += compat.b('\xe8') + struct.pack('<L', len(procname) + 1)
-                code += procname + compat.b('\0')
+                code += compat.b("\xe8") + struct.pack("<L", len(procname) + 1)
+                code += procname + compat.b("\0")
 
                 # push eax
-                code += compat.b('\x50')
+                code += compat.b("\x50")
 
                 # mov eax, GetProcAddress
-                code += compat.b('\xb8') + struct.pack('<L', pgpad)
+                code += compat.b("\xb8") + struct.pack("<L", pgpad)
 
                 # call eax
-                code += compat.b('\xff\xd0')
+                code += compat.b("\xff\xd0")
 
                 # mov ebp, esp      ; preserve stack pointer
-                code += compat.b('\x8b\xec')
+                code += compat.b("\x8b\xec")
 
                 # push lpParameter
-                code += compat.b('\x68') + struct.pack('<L', lpParameter)
+                code += compat.b("\x68") + struct.pack("<L", lpParameter)
 
                 # call eax
-                code += compat.b('\xff\xd0')
+                code += compat.b("\xff\xd0")
 
                 # mov esp, ebp      ; restore stack pointer
-                code += compat.b('\x8b\xe5')
+                code += compat.b("\x8b\xe5")
 
             # pop edx       ; our own return address
-            code += compat.b('\x5a')
+            code += compat.b("\x5a")
 
             # push MEM_RELEASE  ; dwFreeType
-            code += compat.b('\x68') + struct.pack('<L', win32.MEM_RELEASE)
+            code += compat.b("\x68") + struct.pack("<L", win32.MEM_RELEASE)
 
             # push 0x1000       ; dwSize, shellcode max size 4096 bytes
-            code += compat.b('\x68') + struct.pack('<L', 0x1000)
+            code += compat.b("\x68") + struct.pack("<L", 0x1000)
 
             # call $+5
-            code += compat.b('\xe8\x00\x00\x00\x00')
+            code += compat.b("\xe8\x00\x00\x00\x00")
 
             # and dword ptr [esp], 0xFFFFF000   ; align to page boundary
-            code += compat.b('\x81\x24\x24\x00\xf0\xff\xff')
+            code += compat.b("\x81\x24\x24\x00\xf0\xff\xff")
 
             # mov eax, VirtualFree
-            code += compat.b('\xb8') + struct.pack('<L', pvf)
+            code += compat.b("\xb8") + struct.pack("<L", pvf)
 
             # push edx      ; our own return address
-            code += compat.b('\x52')
+            code += compat.b("\x52")
 
             # jmp eax   ; VirtualFree will return to our own return address
-            code += compat.b('\xff\xe0')
+            code += compat.b("\xff\xe0")
 
             # Inject the shellcode.
             # There's no need to free the memory,
@@ -3757,15 +3653,14 @@ class Process (_ThreadContainer, _ModuleContainer):
 
         # New method, not using shellcode.
         else:
-
             # Resolve kernel32.dll!LoadLibrary (A/W)
-            if type(dllname) == type(u''):
-                pllibname = compat.b('LoadLibraryW')
+            if type(dllname) == type(""):
+                pllibname = compat.b("LoadLibraryW")
                 bufferlen = (len(dllname) + 1) * 2
-                dllname = win32.ctypes.create_unicode_buffer(dllname).raw[:bufferlen + 1]
+                dllname = win32.ctypes.create_unicode_buffer(dllname).raw[: bufferlen + 1]
             else:
-                pllibname = compat.b('LoadLibraryA')
-                dllname   = compat.b(dllname) + compat.b('\x00')
+                pllibname = compat.b("LoadLibraryA")
+                dllname = compat.b(dllname) + compat.b("\x00")
                 bufferlen = len(dllname)
             pllib = aModule.resolve(pllibname)
             if not pllib:
@@ -3788,10 +3683,7 @@ class Process (_ThreadContainer, _ModuleContainer):
                     # This specific error is caused by trying to spawn a new
                     # thread in a process belonging to a different Terminal
                     # Services session (for example a service).
-                    raise NotImplementedError(
-                        "Target process belongs to a different"
-                        " Terminal Services session, cannot inject!"
-                    )
+                    raise NotImplementedError("Target process belongs to a different" " Terminal Services session, cannot inject!")
 
                 # Remember the buffer address.
                 #  It will be freed ONLY by the Thread.kill() method
@@ -3813,7 +3705,7 @@ class Process (_ThreadContainer, _ModuleContainer):
         # Return the thread object.
         return aThread
 
-    def clean_exit(self, dwExitCode = 0, bWait = False, dwTimeout = None):
+    def clean_exit(self, dwExitCode=0, bWait=False, dwTimeout=None):
         """
         Injects a new thread to call ExitProcess().
         Optionally waits for the injected thread to finish.
@@ -3836,12 +3728,12 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         if not dwExitCode:
             dwExitCode = 0
-        pExitProcess = self.resolve_label('kernel32!ExitProcess')
+        pExitProcess = self.resolve_label("kernel32!ExitProcess")
         aThread = self.start_thread(pExitProcess, dwExitCode)
         if bWait:
             aThread.wait(dwTimeout)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def _notify_create_process(self, event):
         """
@@ -3858,13 +3750,14 @@ class Process (_ThreadContainer, _ModuleContainer):
         """
         # Do not use super() here.
         bCallHandler = _ThreadContainer._notify_create_process(self, event)
-        bCallHandler = bCallHandler and \
-                           _ModuleContainer._notify_create_process(self, event)
+        bCallHandler = bCallHandler and _ModuleContainer._notify_create_process(self, event)
         return bCallHandler
 
-#==============================================================================
 
-class _ProcessContainer (object):
+# ==============================================================================
+
+
+class _ProcessContainer(object):
     """
     Encapsulates the capability to contain Process objects.
 
@@ -3905,10 +3798,10 @@ class _ProcessContainer (object):
         """
         if not self.__processDict:
             try:
-                self.scan_processes()       # remote desktop api (relative fn)
+                self.scan_processes()  # remote desktop api (relative fn)
             except Exception:
                 self.scan_processes_fast()  # psapi (no filenames)
-            self.scan_process_filenames()   # get the pathnames when possible
+            self.scan_process_filenames()  # get the pathnames when possible
 
     def __contains__(self, anObject):
         """
@@ -4009,7 +3902,7 @@ class _ProcessContainer (object):
         self.__initialize_snapshot()
         return len(self.__processDict)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX TODO
     # Support for string searches on the window captions.
@@ -4022,7 +3915,7 @@ class _ProcessContainer (object):
         """
         window_list = list()
         for process in self.iter_processes():
-            window_list.extend( process.get_windows() )
+            window_list.extend(process.get_windows())
         return window_list
 
     def get_pid_from_tid(self, dwThreadId):
@@ -4038,22 +3931,19 @@ class _ProcessContainer (object):
         @raise KeyError: The thread does not exist.
         """
         try:
-
             # No good, because in XP and below it tries to get the PID
             # through the toolhelp API, and that's slow. We don't want
             # to scan for threads over and over for each call.
-##            dwProcessId = Thread(dwThreadId).get_pid()
+            ##            dwProcessId = Thread(dwThreadId).get_pid()
 
             # This API only exists in Windows 2003, Vista and above.
             try:
-                hThread = win32.OpenThread(
-                    win32.THREAD_QUERY_LIMITED_INFORMATION, False, dwThreadId)
+                hThread = win32.OpenThread(win32.THREAD_QUERY_LIMITED_INFORMATION, False, dwThreadId)
             except WindowsError:
                 e = sys.exc_info()[1]
                 if e.winerror != win32.ERROR_ACCESS_DENIED:
                     raise
-                hThread = win32.OpenThread(
-                    win32.THREAD_QUERY_INFORMATION, False, dwThreadId)
+                hThread = win32.OpenThread(win32.THREAD_QUERY_INFORMATION, False, dwThreadId)
             try:
                 return win32.GetProcessIdOfThread(hThread)
             finally:
@@ -4081,7 +3971,7 @@ class _ProcessContainer (object):
         msg = "Unknown thread ID %d" % dwThreadId
         raise KeyError(msg)
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     @staticmethod
     def argv_to_cmdline(argv):
@@ -4102,13 +3992,10 @@ class _ProcessContainer (object):
             else:
                 if '"' in token:
                     token = token.replace('"', '\\"')
-                if  ' ' in token  or \
-                    '\t' in token or \
-                    '\n' in token or \
-                    '\r' in token:
-                        token = '"%s"' % token
+                if " " in token or "\t" in token or "\n" in token or "\r" in token:
+                    token = '"%s"' % token
             cmdline.append(token)
-        return ' '.join(cmdline)
+        return " ".join(cmdline)
 
     @staticmethod
     def cmdline_to_argv(lpCmdLine):
@@ -4196,14 +4083,14 @@ class _ProcessContainer (object):
         """
 
         # Get the flags.
-        bConsole            = kwargs.pop('bConsole', False)
-        bDebug              = kwargs.pop('bDebug', False)
-        bFollow             = kwargs.pop('bFollow', False)
-        bSuspended          = kwargs.pop('bSuspended', False)
-        bInheritHandles     = kwargs.pop('bInheritHandles', False)
-        dwParentProcessId   = kwargs.pop('dwParentProcessId', None)
-        iTrustLevel         = kwargs.pop('iTrustLevel', 2)
-        bAllowElevation     = kwargs.pop('bAllowElevation', True)
+        bConsole = kwargs.pop("bConsole", False)
+        bDebug = kwargs.pop("bDebug", False)
+        bFollow = kwargs.pop("bFollow", False)
+        bSuspended = kwargs.pop("bSuspended", False)
+        bInheritHandles = kwargs.pop("bInheritHandles", False)
+        dwParentProcessId = kwargs.pop("dwParentProcessId", None)
+        iTrustLevel = kwargs.pop("iTrustLevel", 2)
+        bAllowElevation = kwargs.pop("bAllowElevation", True)
         if kwargs:
             raise TypeError("Unknown keyword arguments: %s" % compat.keys(kwargs))
         if not lpCmdLine:
@@ -4218,18 +4105,16 @@ class _ProcessContainer (object):
             bAllowElevation = bAllowElevation or not self.is_admin()
         except AttributeError:
             bAllowElevation = True
-            warnings.warn(
-                "UAC elevation is only available in Windows Vista and above",
-                RuntimeWarning)
+            warnings.warn("UAC elevation is only available in Windows Vista and above", RuntimeWarning)
 
         # Calculate the process creation flags.
-        dwCreationFlags  = 0
+        dwCreationFlags = 0
         dwCreationFlags |= win32.CREATE_DEFAULT_ERROR_MODE
         dwCreationFlags |= win32.CREATE_BREAKAWAY_FROM_JOB
         ##dwCreationFlags |= win32.CREATE_UNICODE_ENVIRONMENT
         if not bConsole:
             dwCreationFlags |= win32.DETACHED_PROCESS
-            #dwCreationFlags |= win32.CREATE_NO_WINDOW   # weird stuff happens
+            # dwCreationFlags |= win32.CREATE_NO_WINDOW   # weird stuff happens
         if bSuspended:
             dwCreationFlags |= win32.CREATE_SUSPENDED
         if bDebug:
@@ -4247,22 +4132,16 @@ class _ProcessContainer (object):
                     ParentProcess = self.get_process(dwParentProcessId)
                 else:
                     ParentProcess = Process(dwParentProcessId)
-                ParentProcessHandle = ParentProcess.get_handle(
-                                        win32.PROCESS_CREATE_PROCESS)
-                AttributeListData = (
-                    (
-                        win32.PROC_THREAD_ATTRIBUTE_PARENT_PROCESS,
-                        ParentProcessHandle._as_parameter_
-                    ),
-                )
+                ParentProcessHandle = ParentProcess.get_handle(win32.PROCESS_CREATE_PROCESS)
+                AttributeListData = ((win32.PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, ParentProcessHandle._as_parameter_),)
                 AttributeList = win32.ProcThreadAttributeList(AttributeListData)
-                StartupInfoEx           = win32.STARTUPINFOEX()
-                StartupInfo             = StartupInfoEx.StartupInfo
-                StartupInfo.cb          = win32.sizeof(win32.STARTUPINFOEX)
-                StartupInfo.lpReserved  = 0
-                StartupInfo.lpDesktop   = 0
-                StartupInfo.lpTitle     = 0
-                StartupInfo.dwFlags     = 0
+                StartupInfoEx = win32.STARTUPINFOEX()
+                StartupInfo = StartupInfoEx.StartupInfo
+                StartupInfo.cb = win32.sizeof(win32.STARTUPINFOEX)
+                StartupInfo.lpReserved = 0
+                StartupInfo.lpDesktop = 0
+                StartupInfo.lpTitle = 0
+                StartupInfo.dwFlags = 0
                 StartupInfo.cbReserved2 = 0
                 StartupInfo.lpReserved2 = 0
                 StartupInfoEx.lpAttributeList = AttributeList.value
@@ -4271,36 +4150,27 @@ class _ProcessContainer (object):
 
         pi = None
         try:
-
             # Create the process the easy way.
             if iTrustLevel >= 2 and bAllowElevation:
-                pi = win32.CreateProcess(None, lpCmdLine,
-                                            bInheritHandles = bInheritHandles,
-                                            dwCreationFlags = dwCreationFlags,
-                                            lpStartupInfo   = lpStartupInfo)
+                pi = win32.CreateProcess(
+                    None, lpCmdLine, bInheritHandles=bInheritHandles, dwCreationFlags=dwCreationFlags, lpStartupInfo=lpStartupInfo
+                )
 
             # Create the process the hard way...
             else:
-
                 # If we allow elevation, use the current process token.
                 # If not, get the token from the current shell process.
                 hToken = None
                 try:
                     if not bAllowElevation:
                         if bFollow:
-                            msg = (
-                                "Child processes can't be autofollowed"
-                                " when dropping UAC elevation.")
+                            msg = "Child processes can't be autofollowed" " when dropping UAC elevation."
                             raise NotImplementedError(msg)
                         if bConsole:
-                            msg = (
-                                "Child processes can't inherit the debugger's"
-                                " console when dropping UAC elevation.")
+                            msg = "Child processes can't inherit the debugger's" " console when dropping UAC elevation."
                             raise NotImplementedError(msg)
                         if bInheritHandles:
-                            msg = (
-                                "Child processes can't inherit the debugger's"
-                                " handles when dropping UAC elevation.")
+                            msg = "Child processes can't inherit the debugger's" " handles when dropping UAC elevation."
                             raise NotImplementedError(msg)
                         try:
                             hWnd = self.get_shell_window()
@@ -4308,8 +4178,7 @@ class _ProcessContainer (object):
                             hWnd = self.get_desktop_window()
                         shell = hWnd.get_process()
                         try:
-                            hShell = shell.get_handle(
-                                            win32.PROCESS_QUERY_INFORMATION)
+                            hShell = shell.get_handle(win32.PROCESS_QUERY_INFORMATION)
                             with win32.OpenProcessToken(hShell) as hShellToken:
                                 hToken = win32.DuplicateTokenEx(hShellToken)
                         finally:
@@ -4321,9 +4190,8 @@ class _ProcessContainer (object):
                             dwLevelId = win32.SAFER_LEVELID_NORMALUSER
                         else:
                             dwLevelId = win32.SAFER_LEVELID_UNTRUSTED
-                        with win32.SaferCreateLevel(dwLevelId = dwLevelId) as hSafer:
-                            hSaferToken = win32.SaferComputeTokenFromLevel(
-                                                            hSafer, hToken)[0]
+                        with win32.SaferCreateLevel(dwLevelId=dwLevelId) as hSafer:
+                            hSaferToken = win32.SaferComputeTokenFromLevel(hSafer, hToken)[0]
                             try:
                                 if hToken is not None:
                                     hToken.close()
@@ -4335,11 +4203,12 @@ class _ProcessContainer (object):
                     # If we have a computed token, call CreateProcessAsUser().
                     if bAllowElevation:
                         pi = win32.CreateProcessAsUser(
-                                    hToken          = hToken,
-                                    lpCommandLine   = lpCmdLine,
-                                    bInheritHandles = bInheritHandles,
-                                    dwCreationFlags = dwCreationFlags,
-                                    lpStartupInfo   = lpStartupInfo)
+                            hToken=hToken,
+                            lpCommandLine=lpCmdLine,
+                            bInheritHandles=bInheritHandles,
+                            dwCreationFlags=dwCreationFlags,
+                            lpStartupInfo=lpStartupInfo,
+                        )
 
                     # If we have a primary token call CreateProcessWithToken().
                     # The problem is, there are many flags CreateProcess() and
@@ -4347,7 +4216,6 @@ class _ProcessContainer (object):
                     # and CreateProcessWithLogonW() don't, so we need to work
                     # around them.
                     else:
-
                         # Remove the debug flags.
                         dwCreationFlags &= ~win32.DEBUG_PROCESS
                         dwCreationFlags &= ~win32.DEBUG_ONLY_THIS_PROCESS
@@ -4360,11 +4228,12 @@ class _ProcessContainer (object):
 
                         # Create the process using the new primary token.
                         pi = win32.CreateProcessWithToken(
-                                    hToken          = hToken,
-                                    dwLogonFlags    = win32.LOGON_WITH_PROFILE,
-                                    lpCommandLine   = lpCmdLine,
-                                    dwCreationFlags = dwCreationFlags,
-                                    lpStartupInfo   = lpStartupInfo)
+                            hToken=hToken,
+                            dwLogonFlags=win32.LOGON_WITH_PROFILE,
+                            lpCommandLine=lpCmdLine,
+                            dwCreationFlags=dwCreationFlags,
+                            lpStartupInfo=lpStartupInfo,
+                        )
 
                         # Attach as a debugger, if requested.
                         if bDebug:
@@ -4382,7 +4251,7 @@ class _ProcessContainer (object):
             # Wrap the new process and thread in Process and Thread objects,
             # and add them to the corresponding snapshots.
             aProcess = Process(pi.dwProcessId, pi.hProcess)
-            aThread  = Thread (pi.dwThreadId,  pi.hThread)
+            aThread = Thread(pi.dwThreadId, pi.hThread)
             aProcess._add_thread(aThread)
             self._add_process(aProcess)
 
@@ -4412,15 +4281,15 @@ class _ProcessContainer (object):
         except Exception:
             exp = None
         if not exp:
-            exp = os.getenv('SystemRoot')
+            exp = os.getenv("SystemRoot")
         if exp:
-            exp = os.path.join(exp, 'explorer.exe')
+            exp = os.path.join(exp, "explorer.exe")
             exp_list = self.find_processes_by_filename(exp)
             if exp_list:
                 return exp_list[0][0].get_pid()
         return None
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX this methods musn't end up calling __initialize_snapshot by accident!
 
@@ -4441,13 +4310,11 @@ class _ProcessContainer (object):
         has_threads = True
         try:
             try:
-
                 # Try using the Toolhelp API
                 # to scan for processes and threads.
                 self.scan_processes_and_threads()
 
             except Exception:
-
                 # On error, try using the PSAPI to scan for process IDs only.
                 self.scan_processes_fast()
 
@@ -4460,7 +4327,6 @@ class _ProcessContainer (object):
                             has_threads = False
 
         finally:
-
             # Try using the Remote Desktop API to scan for processes only.
             # This will update the filenames when it's not possible
             # to obtain them from the Toolhelp API.
@@ -4494,8 +4360,8 @@ class _ProcessContainer (object):
         # since this information resides in usermode space.
         # See: http://www.ragestorm.net/blogs/?p=163
 
-        our_pid    = win32.GetCurrentProcessId()
-        dead_pids  = set( compat.iterkeys(self.__processDict) )
+        our_pid = win32.GetCurrentProcessId()
+        dead_pids = set(compat.iterkeys(self.__processDict))
         found_tids = set()
 
         # Ignore our own process if it's in the snapshot for some reason
@@ -4503,9 +4369,8 @@ class _ProcessContainer (object):
             dead_pids.remove(our_pid)
 
         # Take a snapshot of all processes and threads
-        dwFlags   = win32.TH32CS_SNAPPROCESS | win32.TH32CS_SNAPTHREAD
+        dwFlags = win32.TH32CS_SNAPPROCESS | win32.TH32CS_SNAPTHREAD
         with win32.CreateToolhelp32Snapshot(dwFlags) as hSnapshot:
-
             # Add all the processes (excluding our own)
             pe = win32.Process32First(hSnapshot)
             while pe is not None:
@@ -4537,7 +4402,7 @@ class _ProcessContainer (object):
                     dwThreadId = te.th32ThreadID
                     found_tids.add(dwThreadId)
                     if not aProcess._has_thread_id(dwThreadId):
-                        aThread = Thread(dwThreadId, process = aProcess)
+                        aThread = Thread(dwThreadId, process=aProcess)
                         aProcess._add_thread(aThread)
                 te = win32.Thread32Next(hSnapshot)
 
@@ -4547,7 +4412,7 @@ class _ProcessContainer (object):
 
         # Remove dead threads
         for aProcess in compat.itervalues(self.__processDict):
-            dead_tids = set( aProcess._get_thread_ids() )
+            dead_tids = set(aProcess._get_thread_ids())
             dead_tids.difference_update(found_tids)
             for tid in dead_tids:
                 aProcess._del_thread(tid)
@@ -4597,8 +4462,8 @@ class _ProcessContainer (object):
 
         # Get the previous list of PIDs.
         # We'll be removing live PIDs from it as we find them.
-        our_pid   = win32.GetCurrentProcessId()
-        dead_pids  = set( compat.iterkeys(self.__processDict) )
+        our_pid = win32.GetCurrentProcessId()
+        dead_pids = set(compat.iterkeys(self.__processDict))
 
         # Ignore our own PID.
         if our_pid in dead_pids:
@@ -4607,16 +4472,15 @@ class _ProcessContainer (object):
         # Get the list of processes from the Remote Desktop API.
         pProcessInfo = None
         try:
-            pProcessInfo, dwCount = win32.WTSEnumerateProcesses(
-                                            win32.WTS_CURRENT_SERVER_HANDLE)
+            pProcessInfo, dwCount = win32.WTSEnumerateProcesses(win32.WTS_CURRENT_SERVER_HANDLE)
 
             # For each process found...
             for index in compat.xrange(dwCount):
                 sProcessInfo = pProcessInfo[index]
 
-##                # Ignore processes belonging to other sessions.
-##                if sProcessInfo.SessionId != win32.WTS_CURRENT_SESSION:
-##                    continue
+                ##                # Ignore processes belonging to other sessions.
+                ##                if sProcessInfo.SessionId != win32.WTS_CURRENT_SESSION:
+                ##                    continue
 
                 # Ignore our own PID.
                 pid = sProcessInfo.ProcessId
@@ -4634,7 +4498,7 @@ class _ProcessContainer (object):
 
                 # If the process is new, add a new Process object.
                 if pid not in self.__processDict:
-                    aProcess = Process(pid, fileName = fileName)
+                    aProcess = Process(pid, fileName=fileName)
                     self._add_process(aProcess)
 
                 # If the process was already in the snapshot, and the
@@ -4674,11 +4538,11 @@ class _ProcessContainer (object):
         """
 
         # Get the new and old list of pids
-        new_pids = set( win32.EnumProcesses() )
-        old_pids = set( compat.iterkeys(self.__processDict) )
+        new_pids = set(win32.EnumProcesses())
+        old_pids = set(compat.iterkeys(self.__processDict))
 
         # Ignore our own pid
-        our_pid  = win32.GetCurrentProcessId()
+        our_pid = win32.GetCurrentProcessId()
         if our_pid in new_pids:
             new_pids.remove(our_pid)
         if our_pid in old_pids:
@@ -4686,7 +4550,7 @@ class _ProcessContainer (object):
 
         # Add newly found pids
         for pid in new_pids.difference(old_pids):
-            self._add_process( Process(pid) )
+            self._add_process(Process(pid))
 
         # Remove missing pids
         for pid in old_pids.difference(new_pids):
@@ -4727,7 +4591,7 @@ class _ProcessContainer (object):
                 complete = False
         return complete
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def clear_dead_processes(self):
         """
@@ -4787,7 +4651,7 @@ class _ProcessContainer (object):
         """
         Removes all L{Process}, L{Thread} and L{Module} objects in this snapshot.
         """
-        #self.close_process_and_thread_handles()
+        # self.close_process_and_thread_handles()
         for aProcess in self.iter_processes():
             aProcess.clear()
         self.__processDict = dict()
@@ -4800,7 +4664,7 @@ class _ProcessContainer (object):
         """
         self.clear_processes()
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # Docs for these methods are taken from the _ThreadContainer class.
 
@@ -4829,12 +4693,12 @@ class _ProcessContainer (object):
             count += aProcess.get_thread_count()
         return count
 
-    has_thread.__doc__       = _ThreadContainer.has_thread.__doc__
-    get_thread.__doc__       = _ThreadContainer.get_thread.__doc__
-    get_thread_ids.__doc__   = _ThreadContainer.get_thread_ids.__doc__
+    has_thread.__doc__ = _ThreadContainer.has_thread.__doc__
+    get_thread.__doc__ = _ThreadContainer.get_thread.__doc__
+    get_thread_ids.__doc__ = _ThreadContainer.get_thread_ids.__doc__
     get_thread_count.__doc__ = _ThreadContainer.get_thread_count.__doc__
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # Docs for these methods are taken from the _ModuleContainer class.
 
@@ -4846,7 +4710,7 @@ class _ProcessContainer (object):
 
     get_module_count.__doc__ = _ModuleContainer.get_module_count.__doc__
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     def find_modules_by_base(self, lpBaseOfDll):
         """
@@ -4857,7 +4721,7 @@ class _ProcessContainer (object):
         for aProcess in self.iter_processes():
             if aProcess.has_module(lpBaseOfDll):
                 aModule = aProcess.get_module(lpBaseOfDll)
-                found.append( (aProcess, aModule) )
+                found.append((aProcess, aModule))
         return found
 
     def find_modules_by_name(self, fileName):
@@ -4869,7 +4733,7 @@ class _ProcessContainer (object):
         for aProcess in self.iter_processes():
             aModule = aProcess.get_module_by_name(fileName)
             if aModule is not None:
-                found.append( (aProcess, aModule) )
+                found.append((aProcess, aModule))
         return found
 
     def find_modules_by_address(self, address):
@@ -4881,27 +4745,27 @@ class _ProcessContainer (object):
         for aProcess in self.iter_processes():
             aModule = aProcess.get_module_at_address(address)
             if aModule is not None:
-                found.append( (aProcess, aModule) )
+                found.append((aProcess, aModule))
         return found
 
     def __find_processes_by_filename(self, filename):
         """
         Internally used by L{find_processes_by_filename}.
         """
-        found    = list()
+        found = list()
         filename = filename.lower()
         if PathOperations.path_is_absolute(filename):
             for aProcess in self.iter_processes():
                 imagename = aProcess.get_filename()
                 if imagename and imagename.lower() == filename:
-                    found.append( (aProcess, imagename) )
+                    found.append((aProcess, imagename))
         else:
             for aProcess in self.iter_processes():
                 imagename = aProcess.get_filename()
                 if imagename:
                     imagename = PathOperations.pathname_to_filename(imagename)
                     if imagename.lower() == filename:
-                        found.append( (aProcess, imagename) )
+                        found.append((aProcess, imagename))
         return found
 
     def find_processes_by_filename(self, fileName):
@@ -4924,11 +4788,11 @@ class _ProcessContainer (object):
         if not found:
             fn, ext = PathOperations.split_extension(fileName)
             if not ext:
-                fileName = '%s.exe' % fn
-                found    = self.__find_processes_by_filename(fileName)
+                fileName = "%s.exe" % fn
+                found = self.__find_processes_by_filename(fileName)
         return found
 
-#------------------------------------------------------------------------------
+    # ------------------------------------------------------------------------------
 
     # XXX _notify_* methods should not trigger a scan
 
@@ -4939,17 +4803,17 @@ class _ProcessContainer (object):
         @type  aProcess: L{Process}
         @param aProcess: Process object.
         """
-##        if not isinstance(aProcess, Process):
-##            if hasattr(aProcess, '__class__'):
-##                typename = aProcess.__class__.__name__
-##            else:
-##                typename = str(type(aProcess))
-##            msg = "Expected Process, got %s instead" % typename
-##            raise TypeError(msg)
+        ##        if not isinstance(aProcess, Process):
+        ##            if hasattr(aProcess, '__class__'):
+        ##                typename = aProcess.__class__.__name__
+        ##            else:
+        ##                typename = str(type(aProcess))
+        ##            msg = "Expected Process, got %s instead" % typename
+        ##            raise TypeError(msg)
         dwProcessId = aProcess.dwProcessId
-##        if dwProcessId in self.__processDict:
-##            msg = "Process already exists: %d" % dwProcessId
-##            raise KeyError(msg)
+        ##        if dwProcessId in self.__processDict:
+        ##            msg = "Process already exists: %d" % dwProcessId
+        ##            raise KeyError(msg)
         self.__processDict[dwProcessId] = aProcess
 
     def _del_process(self, dwProcessId):
@@ -4967,7 +4831,7 @@ class _ProcessContainer (object):
             msg = "Unknown process ID %d" % dwProcessId
             warnings.warn(msg, RuntimeWarning)
         if aProcess:
-            aProcess.clear()    # remove circular references
+            aProcess.clear()  # remove circular references
 
     # Notify the creation of a new process.
     def _notify_create_process(self, event):
@@ -4984,16 +4848,16 @@ class _ProcessContainer (object):
         @return: C{True} to call the user-defined handle, C{False} otherwise.
         """
         dwProcessId = event.get_pid()
-        dwThreadId  = event.get_tid()
-        hProcess    = event.get_process_handle()
-##        if not self.has_process(dwProcessId): # XXX this would trigger a scan
+        dwThreadId = event.get_tid()
+        hProcess = event.get_process_handle()
+        ##        if not self.has_process(dwProcessId): # XXX this would trigger a scan
         if dwProcessId not in self.__processDict:
             aProcess = Process(dwProcessId, hProcess)
             self._add_process(aProcess)
             aProcess.fileName = event.get_filename()
         else:
             aProcess = self.get_process(dwProcessId)
-            #if hProcess != win32.INVALID_HANDLE_VALUE:
+            # if hProcess != win32.INVALID_HANDLE_VALUE:
             #    aProcess.hProcess = hProcess    # may have more privileges
             if not aProcess.fileName:
                 fileName = event.get_filename()
@@ -5015,7 +4879,7 @@ class _ProcessContainer (object):
         @return: C{True} to call the user-defined handle, C{False} otherwise.
         """
         dwProcessId = event.get_pid()
-##        if self.has_process(dwProcessId): # XXX this would trigger a scan
+        ##        if self.has_process(dwProcessId): # XXX this would trigger a scan
         if dwProcessId in self.__processDict:
             self._del_process(dwProcessId)
         return True