debugpy 1.8.5__zip → 1.8.6__zip

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

@@ -39,7 +39,7 @@ from __future__ import with_statement
 
 __revision__ = "$Id$"
 
-__all__ = ['Registry']
+__all__ = ["Registry"]
 
 import sys
 from winappdbg import win32
@@ -47,9 +47,10 @@ from winappdbg import compat
 import collections
 import warnings
 
-#==============================================================================
+# ==============================================================================
 
-class _RegistryContainer (object):
+
+class _RegistryContainer(object):
     """
     Base class for L{Registry} and L{RegistryKey}.
     """
@@ -57,6 +58,7 @@ class _RegistryContainer (object):
     # Dummy object to detect empty arguments.
     class __EmptyArgument:
         pass
+
     __emptyArgument = __EmptyArgument()
 
     def __init__(self):
@@ -79,9 +81,11 @@ class _RegistryContainer (object):
     def __iter__(self):
         return compat.iterkeys(self)
 
-#==============================================================================
 
-class RegistryKey (_RegistryContainer):
+# ==============================================================================
+
+
+class RegistryKey(_RegistryContainer):
     """
     Exposes a single Windows Registry key as a dictionary-like object.
 
@@ -103,9 +107,9 @@ class RegistryKey (_RegistryContainer):
         @param handle: Registry key handle.
         """
         super(RegistryKey, self).__init__()
-        if path.endswith('\\'):
+        if path.endswith("\\"):
             path = path[:-1]
-        self._path   = path
+        self._path = path
         self._handle = handle
 
     @property
@@ -114,12 +118,12 @@ class RegistryKey (_RegistryContainer):
 
     @property
     def handle(self):
-        #if not self._handle:
+        # if not self._handle:
         #    msg = "This Registry key handle has already been closed."
         #    raise RuntimeError(msg)
         return self._handle
 
-    #def close(self):
+    # def close(self):
     #    """
     #    Close the Registry key handle, freeing its resources. It cannot be
     #    used again after calling this method.
@@ -131,13 +135,13 @@ class RegistryKey (_RegistryContainer):
     #    """
     #    self.handle.close()
     #
-    #def __enter__(self):
+    # def __enter__(self):
     #    """
     #    Compatibility with the "C{with}" Python statement.
     #    """
     #    return self
     #
-    #def __exit__(self, type, value, traceback):
+    # def __exit__(self, type, value, traceback):
     #    """
     #    Compatibility with the "C{with}" Python statement.
     #    """
@@ -236,7 +240,7 @@ class RegistryKey (_RegistryContainer):
             resp = win32.RegEnumValue(handle, index)
             if resp is None:
                 break
-            items.append( (resp[0], resp[2]) )
+            items.append((resp[0], resp[2]))
             index += 1
         return items
 
@@ -281,11 +285,11 @@ class RegistryKey (_RegistryContainer):
             win32.RegDeleteValue(handle, resp[0])
 
     def __str__(self):
-        default = self['']
+        default = self[""]
         return str(default)
 
     def __unicode__(self):
-        default = self[u'']
+        default = self[""]
         return compat.unicode(default)
 
     def __repr__(self):
@@ -322,7 +326,7 @@ class RegistryKey (_RegistryContainer):
             subkey = win32.RegEnumKey(handle, index)
             if subkey is None:
                 break
-            result.append( self.child(subkey) )
+            result.append(self.child(subkey))
             index += 1
         return result
 
@@ -336,7 +340,7 @@ class RegistryKey (_RegistryContainer):
         @rtype:  L{RegistryKey}
         @return: Subkey.
         """
-        path = self._path + '\\' + subkey
+        path = self._path + "\\" + subkey
         handle = win32.RegOpenKey(self.handle, subkey)
         return RegistryKey(path, handle)
 
@@ -352,7 +356,8 @@ class RegistryKey (_RegistryContainer):
         """
         win32.RegFlushKey(self.handle)
 
-#==============================================================================
+
+# ==============================================================================
 
 # TODO: possibly cache the RegistryKey objects
 # to avoid opening and closing handles many times on code sequences like this:
@@ -372,7 +377,8 @@ class RegistryKey (_RegistryContainer):
 # Apparently RegDeleteTree won't work remotely from Win7 to WinXP, and the only
 # solution is to recursively call RegDeleteKey.
 
-class Registry (_RegistryContainer):
+
+class Registry(_RegistryContainer):
     """
     Exposes the Windows Registry as a Python container.
 
@@ -382,36 +388,34 @@ class Registry (_RegistryContainer):
     """
 
     _hives_by_name = {
-
         # Short names
-        'HKCR' : win32.HKEY_CLASSES_ROOT,
-        'HKCU' : win32.HKEY_CURRENT_USER,
-        'HKLM' : win32.HKEY_LOCAL_MACHINE,
-        'HKU'  : win32.HKEY_USERS,
-        'HKPD' : win32.HKEY_PERFORMANCE_DATA,
-        'HKCC' : win32.HKEY_CURRENT_CONFIG,
-
+        "HKCR": win32.HKEY_CLASSES_ROOT,
+        "HKCU": win32.HKEY_CURRENT_USER,
+        "HKLM": win32.HKEY_LOCAL_MACHINE,
+        "HKU": win32.HKEY_USERS,
+        "HKPD": win32.HKEY_PERFORMANCE_DATA,
+        "HKCC": win32.HKEY_CURRENT_CONFIG,
         # Long names
-        'HKEY_CLASSES_ROOT'     : win32.HKEY_CLASSES_ROOT,
-        'HKEY_CURRENT_USER'     : win32.HKEY_CURRENT_USER,
-        'HKEY_LOCAL_MACHINE'    : win32.HKEY_LOCAL_MACHINE,
-        'HKEY_USERS'            : win32.HKEY_USERS,
-        'HKEY_PERFORMANCE_DATA' : win32.HKEY_PERFORMANCE_DATA,
-        'HKEY_CURRENT_CONFIG'   : win32.HKEY_CURRENT_CONFIG,
+        "HKEY_CLASSES_ROOT": win32.HKEY_CLASSES_ROOT,
+        "HKEY_CURRENT_USER": win32.HKEY_CURRENT_USER,
+        "HKEY_LOCAL_MACHINE": win32.HKEY_LOCAL_MACHINE,
+        "HKEY_USERS": win32.HKEY_USERS,
+        "HKEY_PERFORMANCE_DATA": win32.HKEY_PERFORMANCE_DATA,
+        "HKEY_CURRENT_CONFIG": win32.HKEY_CURRENT_CONFIG,
     }
 
     _hives_by_value = {
-        win32.HKEY_CLASSES_ROOT     : 'HKEY_CLASSES_ROOT',
-        win32.HKEY_CURRENT_USER     : 'HKEY_CURRENT_USER',
-        win32.HKEY_LOCAL_MACHINE    : 'HKEY_LOCAL_MACHINE',
-        win32.HKEY_USERS            : 'HKEY_USERS',
-        win32.HKEY_PERFORMANCE_DATA : 'HKEY_PERFORMANCE_DATA',
-        win32.HKEY_CURRENT_CONFIG   : 'HKEY_CURRENT_CONFIG',
+        win32.HKEY_CLASSES_ROOT: "HKEY_CLASSES_ROOT",
+        win32.HKEY_CURRENT_USER: "HKEY_CURRENT_USER",
+        win32.HKEY_LOCAL_MACHINE: "HKEY_LOCAL_MACHINE",
+        win32.HKEY_USERS: "HKEY_USERS",
+        win32.HKEY_PERFORMANCE_DATA: "HKEY_PERFORMANCE_DATA",
+        win32.HKEY_CURRENT_CONFIG: "HKEY_CURRENT_CONFIG",
     }
 
     _hives = sorted(compat.itervalues(_hives_by_value))
 
-    def __init__(self, machine = None):
+    def __init__(self, machine=None):
         """
         Opens a local or remote registry.
 
@@ -443,14 +447,14 @@ class Registry (_RegistryContainer):
              - L{win32.HKEY_PERFORMANCE_DATA}
              - L{win32.HKEY_CURRENT_CONFIG}
         """
-        if '\\' in path:
-            p = path.find('\\')
+        if "\\" in path:
+            p = path.find("\\")
             hive = path[:p]
-            path = path[p+1:]
+            path = path[p + 1 :]
         else:
             hive = path
             path = None
-        handle = self._hives_by_name[ hive.upper() ]
+        handle = self._hives_by_name[hive.upper()]
         return handle, path
 
     def _parse_path(self, path):
@@ -492,7 +496,7 @@ class Registry (_RegistryContainer):
         """
         path = self._hives_by_value[hive]
         if subkey:
-            path = path + '\\' + subkey
+            path = path + "\\" + subkey
         return path
 
     def _sanitize_path(self, path):
@@ -505,7 +509,7 @@ class Registry (_RegistryContainer):
         @rtype:  str
         @return: Registry path.
         """
-        return self._join_path( *self._split_path(path) )
+        return self._join_path(*self._split_path(path))
 
     def _connect_hive(self, hive):
         """
@@ -560,7 +564,7 @@ class Registry (_RegistryContainer):
     def __repr__(self):
         if self._machine:
             return '<Remote Registry at "%s">' % self._machine
-        return '<Local Registry>'
+        return "<Local Registry>"
 
     def __contains__(self, path):
         hive, subpath = self._parse_path(path)
@@ -587,8 +591,7 @@ class Registry (_RegistryContainer):
 
     def __setitem__(self, path, value):
         do_copy = isinstance(value, RegistryKey)
-        if not do_copy and not isinstance(value, str)    \
-                       and not isinstance(value, compat.unicode):
+        if not do_copy and not isinstance(value, str) and not isinstance(value, compat.unicode):
             if isinstance(value, object):
                 t = value.__class__.__name__
             else:
@@ -606,9 +609,7 @@ class Registry (_RegistryContainer):
     def __delitem__(self, path):
         hive, subpath = self._parse_path(path)
         if not subpath:
-            raise TypeError(
-                "Are you SURE you want to wipe out an entire hive?!"
-                " Call win32.RegDeleteTree() directly if you must...")
+            raise TypeError("Are you SURE you want to wipe out an entire hive?!" " Call win32.RegDeleteTree() directly if you must...")
         try:
             win32.RegDeleteTree(hive, subpath)
         except WindowsError:
@@ -666,7 +667,7 @@ class Registry (_RegistryContainer):
 
         @raise KeyError: The specified path does not exist.
         """
-        if path.endswith('\\'):
+        if path.endswith("\\"):
             path = path[:-1]
         if not self.has_key(path):
             raise KeyError(path)
@@ -690,6 +691,6 @@ class Registry (_RegistryContainer):
                 subkeys = self.subkeys(path)
             except WindowsError:
                 continue
-            prefix = path + '\\'
+            prefix = path + "\\"
             subkeys = [prefix + name for name in subkeys]
             stack.extendleft(subkeys)

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

@@ -43,14 +43,14 @@ Process memory search.
 
 __revision__ = "$Id$"
 
-__all__ =   [
-                'Search',
-                'Pattern',
-                'BytePattern',
-                'TextPattern',
-                'RegExpPattern',
-                'HexPattern',
-            ]
+__all__ = [
+    "Search",
+    "Pattern",
+    "BytePattern",
+    "TextPattern",
+    "RegExpPattern",
+    "HexPattern",
+]
 
 from winappdbg.textio import HexInput
 from winappdbg.util import StaticClass, MemoryAddresses
@@ -64,9 +64,10 @@ try:
 except ImportError:
     import re
 
-#==============================================================================
+# ==============================================================================
 
-class Pattern (object):
+
+class Pattern(object):
     """
     Base class for search patterns.
 
@@ -116,7 +117,7 @@ class Pattern (object):
         """
         return process.read(address, size)
 
-    def find(self, buffer, pos = None):
+    def find(self, buffer, pos=None):
         """
         Searches for the pattern in the given buffer, optionally starting at
         the given position within the buffer.
@@ -169,9 +170,11 @@ class Pattern (object):
         """
         return (address, size, data)
 
-#------------------------------------------------------------------------------
 
-class BytePattern (Pattern):
+# ------------------------------------------------------------------------------
+
+
+class BytePattern(Pattern):
     """
     Fixed byte pattern.
 
@@ -188,7 +191,7 @@ class BytePattern (Pattern):
         @param pattern: Byte string to search for.
         """
         self.pattern = str(pattern)
-        self.length  = len(pattern)
+        self.length = len(pattern)
 
     def __len__(self):
         """
@@ -198,14 +201,16 @@ class BytePattern (Pattern):
         """
         return self.length
 
-    def find(self, buffer, pos = None):
+    def find(self, buffer, pos=None):
         return buffer.find(self.pattern, pos), self.length
 
-#------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
 
 # FIXME: case insensitive compat.unicode searches are probably buggy!
 
-class TextPattern (BytePattern):
+
+class TextPattern(BytePattern):
     """
     Text pattern.
 
@@ -223,7 +228,7 @@ class TextPattern (BytePattern):
         C{False} otherwise.
     """
 
-    def __init__(self, text, encoding = "utf-16le", caseSensitive = False):
+    def __init__(self, text, encoding="utf-16le", caseSensitive=False):
         """
         @type  text: str or compat.unicode
         @param text: Text to search for.
@@ -270,13 +275,15 @@ class TextPattern (BytePattern):
             try:
                 data = compat.unicode(data, self.encoding)
             except Exception:
-##                traceback.print_exc()    # XXX DEBUG
+                ##                traceback.print_exc()    # XXX DEBUG
                 return None
         return (address, size, data)
 
-#------------------------------------------------------------------------------
 
-class RegExpPattern (Pattern):
+# ------------------------------------------------------------------------------
+
+
+class RegExpPattern(Pattern):
     """
     Regular expression pattern.
 
@@ -305,7 +312,7 @@ class RegExpPattern (Pattern):
         buffered search.
     """
 
-    def __init__(self, regexp, flags = 0, maxLength = None):
+    def __init__(self, regexp, flags=0, maxLength=None):
         """
         @type  regexp: str
         @param regexp: Regular expression string.
@@ -327,9 +334,9 @@ class RegExpPattern (Pattern):
             cause an exception to be raised if this pattern is used in a
             buffered search.
         """
-        self.pattern   = regexp
-        self.flags     = flags
-        self.regexp    = re.compile(regexp, flags)
+        self.pattern = regexp
+        self.flags = flags
+        self.regexp = re.compile(regexp, flags)
         self.maxLength = maxLength
 
     def __len__(self):
@@ -350,8 +357,8 @@ class RegExpPattern (Pattern):
             raise NotImplementedError()
         return self.maxLength
 
-    def find(self, buffer, pos = None):
-        if not pos:   # make sure pos is an int
+    def find(self, buffer, pos=None):
+        if not pos:  # make sure pos is an int
             pos = 0
         match = self.regexp.search(buffer, pos)
         if match:
@@ -359,9 +366,11 @@ class RegExpPattern (Pattern):
             return start, end - start
         return -1, 0
 
-#------------------------------------------------------------------------------
 
-class HexPattern (RegExpPattern):
+# ------------------------------------------------------------------------------
+
+
+class HexPattern(RegExpPattern):
     """
     Hexadecimal pattern.
 
@@ -386,8 +395,8 @@ class HexPattern (RegExpPattern):
         L{BytePattern} is created instead. That's because searching for a
         fixed byte pattern is faster than searching for a regular expression.
         """
-        if '?' not in pattern:
-            return BytePattern( HexInput.hexadecimal(pattern) )
+        if "?" not in pattern:
+            return BytePattern(HexInput.hexadecimal(pattern))
         return object.__new__(cls, pattern)
 
     def __init__(self, hexa):
@@ -406,14 +415,14 @@ class HexPattern (RegExpPattern):
         @type  hexa: str
         @param hexa: Pattern to search for.
         """
-        maxLength = len([x for x in hexa
-                            if x in "?0123456789ABCDEFabcdef"]) / 2
-        super(HexPattern, self).__init__(HexInput.pattern(hexa),
-                                         maxLength = maxLength)
+        maxLength = len([x for x in hexa if x in "?0123456789ABCDEFabcdef"]) / 2
+        super(HexPattern, self).__init__(HexInput.pattern(hexa), maxLength=maxLength)
 
-#==============================================================================
 
-class Search (StaticClass):
+# ==============================================================================
+
+
+class Search(StaticClass):
     """
     Static class to group the search functionality.
 
@@ -426,10 +435,7 @@ class Search (StaticClass):
     # TODO: search non-ascii C strings
 
     @staticmethod
-    def search_process(process, pattern, minAddr = None,
-                                         maxAddr = None,
-                                         bufferPages = None,
-                                         overlapping = False):
+    def search_process(process, pattern, minAddr=None, maxAddr=None, bufferPages=None, overlapping=False):
         """
         Search for the given pattern within the process memory.
 
@@ -517,38 +523,35 @@ class Search (StaticClass):
         # Calculate the buffer size from the number of pages.
         if bufferPages is None:
             try:
-                size = MemoryAddresses.\
-                            align_address_to_page_end(len(pattern)) + page
+                size = MemoryAddresses.align_address_to_page_end(len(pattern)) + page
             except NotImplementedError:
                 size = None
         elif bufferPages > 0:
-                size = page * (bufferPages + 1)
+            size = page * (bufferPages + 1)
         else:
-                size = None
+            size = None
 
         # Get the memory map of the process.
         memory_map = process.iter_memory_map(minAddr, maxAddr)
 
         # Perform search with buffering enabled.
         if size:
-
             # Loop through all memory blocks containing data.
-            buffer     = "" # buffer to hold the memory data
-            prev_addr  = 0  # previous memory block address
-            last       = 0  # position of the last match
-            delta      = 0  # delta of last read address and start of buffer
+            buffer = ""  # buffer to hold the memory data
+            prev_addr = 0  # previous memory block address
+            last = 0  # position of the last match
+            delta = 0  # delta of last read address and start of buffer
             for mbi in memory_map:
-
                 # Skip blocks with no data to search on.
                 if not mbi.has_content():
                     continue
 
                 # Get the address and size of this block.
-                address    = mbi.BaseAddress    # current address to search on
-                block_size = mbi.RegionSize     # total size of the block
+                address = mbi.BaseAddress  # current address to search on
+                block_size = mbi.RegionSize  # total size of the block
                 if address >= maxAddr:
                     break
-                end = address + block_size      # end address of the block
+                end = address + block_size  # end address of the block
 
                 # If the block is contiguous to the previous block,
                 # coalesce the new data in the buffer.
@@ -558,20 +561,17 @@ class Search (StaticClass):
                 # If not, clear the buffer and read new data.
                 else:
                     buffer = read(process, address, min(size, block_size))
-                    last   = 0
-                    delta  = 0
+                    last = 0
+                    delta = 0
 
                 # Search for the pattern in this block.
                 while 1:
-
                     # Yield each match of the pattern in the buffer.
                     pos, length = find(buffer, last)
                     while pos >= last:
                         match_addr = address + pos - delta
                         if minAddr <= match_addr < maxAddr:
-                            result = pattern.found(
-                                            match_addr, length,
-                                            buffer [ pos : pos + length ] )
+                            result = pattern.found(match_addr, length, buffer[pos : pos + length])
                             if result is not None:
                                 yield result
                         if overlapping:
@@ -581,9 +581,9 @@ class Search (StaticClass):
                         pos, length = find(buffer, last)
 
                     # Advance to the next page.
-                    address    = address + page
+                    address = address + page
                     block_size = block_size - page
-                    prev_addr  = address
+                    prev_addr = address
 
                     # Fix the position of the last match.
                     last = last - page
@@ -591,8 +591,8 @@ class Search (StaticClass):
                         last = 0
 
                     # Remove the first page in the buffer.
-                    buffer = buffer[ page : ]
-                    delta  = page
+                    buffer = buffer[page:]
+                    delta = page
 
                     # If we haven't reached the end of the block yet,
                     # read the next page in the block and keep seaching.
@@ -605,19 +605,17 @@ class Search (StaticClass):
 
         # Perform search with buffering disabled.
         else:
-
             # Loop through all memory blocks containing data.
             for mbi in memory_map:
-
                 # Skip blocks with no data to search on.
                 if not mbi.has_content():
                     continue
 
                 # Get the address and size of this block.
-                address    = mbi.BaseAddress
+                address = mbi.BaseAddress
                 block_size = mbi.RegionSize
                 if address >= maxAddr:
-                    break;
+                    break
 
                 # Read the whole memory region.
                 buffer = process.read(address, block_size)
@@ -628,9 +626,7 @@ class Search (StaticClass):
                 while pos >= last:
                     match_addr = address + pos
                     if minAddr <= match_addr < maxAddr:
-                        result = pattern.found(
-                                        match_addr, length,
-                                        buffer [ pos : pos + length ] )
+                        result = pattern.found(match_addr, length, buffer[pos : pos + length])
                         if result is not None:
                             yield result
                     if overlapping:
@@ -640,7 +636,7 @@ class Search (StaticClass):
                     pos, length = find(buffer, last)
 
     @classmethod
-    def extract_ascii_strings(cls, process, minSize = 4, maxSize = 1024):
+    def extract_ascii_strings(cls, process, minSize=4, maxSize=1024):
         """
         Extract ASCII strings from the process memory.
 
@@ -662,4 +658,4 @@ class Search (StaticClass):
         """
         regexp = r"[\s\w\!\@\#\$\%%\^\&\*\(\)\{\}\[\]\~\`\'\"\:\;\.\,\\\/\-\+\=\_\<\>]{%d,%d}\0" % (minSize, maxSize)
         pattern = RegExpPattern(regexp, 0, maxSize)
-        return cls.search_process(process, pattern, overlapping = False)
+        return cls.search_process(process, pattern, overlapping=False)