debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_runpy.py

@@ -23,7 +23,8 @@ import types
 import os
 
 __all__ = [
-    "run_module", "run_path",
+    "run_module",
+    "run_path",
 ]
 
 
@@ -81,7 +82,6 @@ class _TempModule(object):
 
 
 class _ModifiedArgv0(object):
-
     def __init__(self, value):
         self.value = value
         self._saved_value = self._sentinel = object()
@@ -98,9 +98,7 @@ class _ModifiedArgv0(object):
 
 
 # TODO: Replace these helpers with importlib._bootstrap_external functions.
-def _run_code(code, run_globals, init_globals=None,
-              mod_name=None, mod_spec=None,
-              pkg_name=None, script_name=None):
+def _run_code(code, run_globals, init_globals=None, mod_name=None, mod_spec=None, pkg_name=None, script_name=None):
     """Helper to run code in nominated namespace"""
     if init_globals is not None:
         run_globals.update(init_globals)
@@ -114,26 +112,19 @@ def _run_code(code, run_globals, init_globals=None,
         cached = mod_spec.cached
         if pkg_name is None:
             pkg_name = mod_spec.parent
-    run_globals.update(__name__=mod_name,
-                       __file__=fname,
-                       __cached__=cached,
-                       __doc__=None,
-                       __loader__=loader,
-                       __package__=pkg_name,
-                       __spec__=mod_spec)
+    run_globals.update(
+        __name__=mod_name, __file__=fname, __cached__=cached, __doc__=None, __loader__=loader, __package__=pkg_name, __spec__=mod_spec
+    )
     exec(code, run_globals)
     return run_globals
 
 
-def _run_module_code(code, init_globals=None,
-                    mod_name=None, mod_spec=None,
-                    pkg_name=None, script_name=None):
+def _run_module_code(code, init_globals=None, mod_name=None, mod_spec=None, pkg_name=None, script_name=None):
     """Helper to run code in new namespace with sys modified"""
     fname = script_name if mod_spec is None else mod_spec.origin
     with _TempModule(mod_name) as temp_module, _ModifiedArgv0(fname):
         mod_globals = temp_module.module.__dict__
-        _run_code(code, mod_globals, init_globals,
-                  mod_name, mod_spec, pkg_name, script_name)
+        _run_code(code, mod_globals, init_globals, mod_name, mod_spec, pkg_name, script_name)
     # Copy the globals of the temporary module, as they
     # may be cleared when the temporary module goes away
     return mod_globals.copy()
@@ -152,17 +143,19 @@ def _get_module_details(mod_name, error=ImportError):
             # If the parent or higher ancestor package is missing, let the
             # error be raised by find_spec() below and then be caught. But do
             # not allow other errors to be caught.
-            if e.name is None or (e.name != pkg_name and
-                    not pkg_name.startswith(e.name + ".")):
+            if e.name is None or (e.name != pkg_name and not pkg_name.startswith(e.name + ".")):
                 raise
         # Warn if the module has already been imported under its normal name
         existing = sys.modules.get(mod_name)
         if existing is not None and not hasattr(existing, "__path__"):
             from warnings import warn
-            msg = "{mod_name!r} found in sys.modules after import of " \
-                "package {pkg_name!r}, but prior to execution of " \
-                "{mod_name!r}; this may result in unpredictable " \
+
+            msg = (
+                "{mod_name!r} found in sys.modules after import of "
+                "package {pkg_name!r}, but prior to execution of "
+                "{mod_name!r}; this may result in unpredictable "
                 "behaviour".format(mod_name=mod_name, pkg_name=pkg_name)
+            )
             warn(RuntimeWarning(msg))
 
     try:
@@ -173,8 +166,7 @@ def _get_module_details(mod_name, error=ImportError):
         # pkgutil previously raised ImportError
         msg = "Error while finding module specification for {!r} ({}: {})"
         if mod_name.endswith(".py"):
-            msg += (f". Try using '{mod_name[:-3]}' instead of "
-                    f"'{mod_name}' as the module name.")
+            msg += f". Try using '{mod_name[:-3]}' instead of " f"'{mod_name}' as the module name."
         raise error(msg.format(mod_name, type(ex).__name__, ex)) from ex
     if spec is None:
         raise error("No module named %s" % mod_name)
@@ -187,12 +179,10 @@ def _get_module_details(mod_name, error=ImportError):
         except error as e:
             if mod_name not in sys.modules:
                 raise  # No module loaded; being a package is irrelevant
-            raise error(("%s; %r is a package and cannot " +
-                               "be directly executed") % (e, mod_name))
+            raise error(("%s; %r is a package and cannot " + "be directly executed") % (e, mod_name))
     loader = spec.loader
     if loader is None:
-        raise error("%r is a namespace package and cannot be executed"
-                                                                 % mod_name)
+        raise error("%r is a namespace package and cannot be executed" % mod_name)
     try:
         code = loader.get_code(mod_name)
     except ImportError as e:
@@ -213,16 +203,16 @@ class _Error(Exception):
 def _run_module_as_main(mod_name, alter_argv=True):
     """Runs the designated module in the __main__ namespace
 
-       Note that the executed module will have full access to the
-       __main__ namespace. If this is not desirable, the run_module()
-       function should be used to run the module code in a fresh namespace.
+    Note that the executed module will have full access to the
+    __main__ namespace. If this is not desirable, the run_module()
+    function should be used to run the module code in a fresh namespace.
 
-       At the very least, these variables in __main__ will be overwritten:
-           __name__
-           __file__
-           __cached__
-           __loader__
-           __package__
+    At the very least, these variables in __main__ will be overwritten:
+        __name__
+        __file__
+        __cached__
+        __loader__
+        __package__
     """
     try:
         if alter_argv or mod_name != "__main__":  # i.e. -m switch
@@ -235,15 +225,13 @@ def _run_module_as_main(mod_name, alter_argv=True):
     main_globals = sys.modules["__main__"].__dict__
     if alter_argv:
         sys.argv[0] = mod_spec.origin
-    return _run_code(code, main_globals, None,
-                     "__main__", mod_spec)
+    return _run_code(code, main_globals, None, "__main__", mod_spec)
 
 
-def run_module(mod_name, init_globals=None,
-               run_name=None, alter_sys=False):
+def run_module(mod_name, init_globals=None, run_name=None, alter_sys=False):
     """Execute a module's code without importing it
 
-       Returns the resulting top level namespace dictionary
+    Returns the resulting top level namespace dictionary
     """
     mod_name, mod_spec, code = _get_module_details(mod_name)
     if run_name is None:
@@ -267,8 +255,7 @@ def _get_main_module_details(error=ImportError):
         return _get_module_details(main_name)
     except ImportError as exc:
         if main_name in str(exc):
-            raise error("can't find %r module in %r" %
-                              (main_name, sys.path[0])) from exc
+            raise error("can't find %r module in %r" % (main_name, sys.path[0])) from exc
         raise
     finally:
         sys.modules[main_name] = saved_main
@@ -279,31 +266,33 @@ try:
 except AttributeError:
     # Compatibility with Python 3.6/3.7
     import tokenize
+
     io_open_code = tokenize.open
 
 
 def _get_code_from_file(run_name, fname):
     # Check for a compiled file first
     from pkgutil import read_code
+
     decoded_path = os.path.abspath(os.fsdecode(fname))
     with io_open_code(decoded_path) as f:
         code = read_code(f)
     if code is None:
         # That didn't work, so try it as normal source code
         with io_open_code(decoded_path) as f:
-            code = compile(f.read(), fname, 'exec')
+            code = compile(f.read(), fname, "exec")
     return code, fname
 
 
 def run_path(path_name, init_globals=None, run_name=None):
     """Execute code located at the specified filesystem location
 
-       Returns the resulting top level namespace dictionary
+    Returns the resulting top level namespace dictionary
 
-       The file path may refer directly to a Python script (i.e.
-       one that could be directly executed with execfile) or else
-       it may refer to a zipfile or directory containing a top
-       level __main__.py script.
+    The file path may refer directly to a Python script (i.e.
+    one that could be directly executed with execfile) or else
+    it may refer to a zipfile or directory containing a top
+    level __main__.py script.
     """
     if run_name is None:
         run_name = "<run_path>"
@@ -311,15 +300,14 @@ def run_path(path_name, init_globals=None, run_name=None):
     importer = pkgutil_get_importer(path_name)
     # Trying to avoid importing imp so as to not consume the deprecation warning.
     is_NullImporter = False
-    if type(importer).__module__ == 'imp':
-        if type(importer).__name__ == 'NullImporter':
+    if type(importer).__module__ == "imp":
+        if type(importer).__name__ == "NullImporter":
             is_NullImporter = True
     if isinstance(importer, type(None)) or is_NullImporter:
         # Not a valid sys.path entry, so run the code directly
         # execfile() doesn't help as we want to allow compiled files
         code, fname = _get_code_from_file(run_name, path_name)
-        return _run_module_code(code, init_globals, run_name,
-                                pkg_name=pkg_name, script_name=fname)
+        return _run_module_code(code, init_globals, run_name, pkg_name=pkg_name, script_name=fname)
     else:
         # Finder is defined for path, so add it to
         # the start of sys.path
@@ -332,11 +320,9 @@ def run_path(path_name, init_globals=None, run_name=None):
             # code. If we don't do this, a __loader__ attribute in the
             # existing __main__ module may prevent location of the new module.
             mod_name, mod_spec, code = _get_main_module_details()
-            with _TempModule(run_name) as temp_module, \
-                 _ModifiedArgv0(path_name):
+            with _TempModule(run_name) as temp_module, _ModifiedArgv0(path_name):
                 mod_globals = temp_module.module.__dict__
-                return _run_code(code, mod_globals, init_globals,
-                                    run_name, mod_spec, pkg_name).copy()
+                return _run_code(code, mod_globals, init_globals, run_name, mod_spec, pkg_name).copy()
         finally:
             try:
                 sys.path.remove(path_name)

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_safe_repr.py

@@ -19,15 +19,14 @@ class SafeRepr(object):
     # String types are truncated to maxstring_outer when at the outer-
     # most level, and truncated to maxstring_inner characters inside
     # collections.
-    maxstring_outer = 2 ** 16
+    maxstring_outer = 2**16
     maxstring_inner = 128
     string_types = (str, bytes)
     bytes = bytes
-    set_info = (set, '{', '}', False)
-    frozenset_info = (frozenset, 'frozenset({', '})', False)
+    set_info = (set, "{", "}", False)
+    frozenset_info = (frozenset, "frozenset({", "})", False)
     int_types = (int,)
-    long_iter_types = (list, tuple, bytearray, range,
-                       dict, set, frozenset)
+    long_iter_types = (list, tuple, bytearray, range, dict, set, frozenset)
 
     # Collection types are recursively iterated for each limit in
     # maxcollection.
@@ -37,52 +36,54 @@ class SafeRepr(object):
     # comma if there is only one element. (Using a sequence rather than a
     # mapping because we use isinstance() to determine the matching type.)
     collection_types = [
-        (tuple, '(', ')', True),
-        (list, '[', ']', False),
+        (tuple, "(", ")", True),
+        (list, "[", "]", False),
         frozenset_info,
         set_info,
     ]
     try:
         from collections import deque
-        collection_types.append((deque, 'deque([', '])', False))
+
+        collection_types.append((deque, "deque([", "])", False))
     except Exception:
         pass
 
     # type, prefix string, suffix string, item prefix string,
     # item key/value separator, item suffix string
-    dict_types = [(dict, '{', '}', '', ': ', '')]
+    dict_types = [(dict, "{", "}", "", ": ", "")]
     try:
         from collections import OrderedDict
-        dict_types.append((OrderedDict, 'OrderedDict([', '])', '(', ', ', ')'))
+
+        dict_types.append((OrderedDict, "OrderedDict([", "])", "(", ", ", ")"))
     except Exception:
         pass
 
     # All other types are treated identically to strings, but using
     # different limits.
-    maxother_outer = 2 ** 16
+    maxother_outer = 2**16
     maxother_inner = 128
 
     convert_to_hex = False
     raw_value = False
 
     def __call__(self, obj):
-        '''
+        """
         :param object obj:
             The object for which we want a representation.
 
         :return str:
             Returns bytes encoded as utf-8 on py2 and str on py3.
-        '''
+        """
         try:
-            return ''.join(self._repr(obj, 0))
+            return "".join(self._repr(obj, 0))
         except Exception:
             try:
-                return 'An exception was raised: %r' % sys.exc_info()[1]
+                return "An exception was raised: %r" % sys.exc_info()[1]
             except Exception:
-                return 'An exception was raised'
+                return "An exception was raised"
 
     def _repr(self, obj, level):
-        '''Returns an iterable of the parts in the final repr string.'''
+        """Returns an iterable of the parts in the final repr string."""
 
         try:
             obj_repr = type(obj).__repr__
@@ -102,8 +103,7 @@ class SafeRepr(object):
 
         for t, prefix, suffix, item_prefix, item_sep, item_suffix in self.dict_types:  # noqa
             if isinstance(obj, t) and has_obj_repr(t):
-                return self._repr_dict(obj, level, prefix, suffix,
-                                       item_prefix, item_sep, item_suffix)
+                return self._repr_dict(obj, level, prefix, suffix, item_prefix, item_sep, item_suffix)
 
         for t in self.string_types:
             if isinstance(obj, t) and has_obj_repr(t):
@@ -125,7 +125,7 @@ class SafeRepr(object):
                 return len(obj) > self.maxstring_inner
 
             # If it's not an iterable (and not a string), it's fine.
-            if not hasattr(obj, '__iter__'):
+            if not hasattr(obj, "__iter__"):
                 return False
 
             # If it's not an instance of these collection types then it
@@ -148,8 +148,8 @@ class SafeRepr(object):
             # numpy and scipy collections (ndarray etc) have
             # self-truncating repr, so they're always safe.
             try:
-                module = type(obj).__module__.partition('.')[0]
-                if module in ('numpy', 'scipy'):
+                module = type(obj).__module__.partition(".")[0]
+                if module in ("numpy", "scipy"):
                     return False
             except Exception:
                 pass
@@ -160,7 +160,7 @@ class SafeRepr(object):
 
             # It is too long if the length exceeds the limit, or any
             # of its elements are long iterables.
-            if hasattr(obj, '__len__'):
+            if hasattr(obj, "__len__"):
                 try:
                     size = len(obj)
                 except Exception:
@@ -174,23 +174,22 @@ class SafeRepr(object):
             # If anything breaks, assume the worst case.
             return True
 
-    def _repr_iter(self, obj, level, prefix, suffix,
-                   comma_after_single_element=False):
+    def _repr_iter(self, obj, level, prefix, suffix, comma_after_single_element=False):
         yield prefix
 
         if level >= len(self.maxcollection):
-            yield '...'
+            yield "..."
         else:
             count = self.maxcollection[level]
             yield_comma = False
             for item in obj:
                 if yield_comma:
-                    yield ', '
+                    yield ", "
                 yield_comma = True
 
                 count -= 1
                 if count <= 0:
-                    yield '...'
+                    yield "..."
                     break
 
                 for p in self._repr(item, 100 if item is obj else level + 1):
@@ -198,27 +197,26 @@ class SafeRepr(object):
             else:
                 if comma_after_single_element:
                     if count == self.maxcollection[level] - 1:
-                        yield ','
+                        yield ","
         yield suffix
 
     def _repr_long_iter(self, obj):
         try:
             length = hex(len(obj)) if self.convert_to_hex else len(obj)
-            obj_repr = '<%s, len() = %s>' % (type(obj).__name__, length)
+            obj_repr = "<%s, len() = %s>" % (type(obj).__name__, length)
         except Exception:
             try:
-                obj_repr = '<' + type(obj).__name__ + '>'
+                obj_repr = "<" + type(obj).__name__ + ">"
             except Exception:
-                obj_repr = '<no repr available for object>'
+                obj_repr = "<no repr available for object>"
         yield obj_repr
 
-    def _repr_dict(self, obj, level, prefix, suffix,
-                   item_prefix, item_sep, item_suffix):
+    def _repr_dict(self, obj, level, prefix, suffix, item_prefix, item_sep, item_suffix):
         if not obj:
             yield prefix + suffix
             return
         if level >= len(self.maxcollection):
-            yield prefix + '...' + suffix
+            yield prefix + "..." + suffix
             return
 
         yield prefix
@@ -238,12 +236,12 @@ class SafeRepr(object):
 
         for key in sorted_keys:
             if yield_comma:
-                yield ', '
+                yield ", "
             yield_comma = True
 
             count -= 1
             if count <= 0:
-                yield '...'
+                yield "..."
                 break
 
             yield item_prefix
@@ -255,7 +253,7 @@ class SafeRepr(object):
             try:
                 item = obj[key]
             except Exception:
-                yield '<?>'
+                yield "<?>"
             else:
                 for p in self._repr(item, 100 if item is obj else level + 1):
                     yield p
@@ -268,7 +266,7 @@ class SafeRepr(object):
             if self.raw_value:
                 # For raw value retrieval, ignore all limits.
                 if isinstance(obj, bytes):
-                    yield obj.decode('latin-1')
+                    yield obj.decode("latin-1")
                 else:
                     yield obj
                 return
@@ -304,32 +302,30 @@ class SafeRepr(object):
 
             part1 = obj[:left_count]
             part1 = repr(part1)
-            part1 = part1[:part1.rindex("'")]  # Remove the last '
+            part1 = part1[: part1.rindex("'")]  # Remove the last '
 
             part2 = obj[-right_count:]
             part2 = repr(part2)
-            part2 = part2[part2.index("'") + 1:]  # Remove the first ' (and possibly u or b).
+            part2 = part2[part2.index("'") + 1 :]  # Remove the first ' (and possibly u or b).
 
             yield part1
-            yield '...'
+            yield "..."
             yield part2
         except:
             # This shouldn't really happen, but let's play it safe.
-            pydev_log.exception('Error getting string representation to show.')
-            for part in self._repr_obj(obj, level,
-                                  self.maxother_inner, self.maxother_outer):
+            pydev_log.exception("Error getting string representation to show.")
+            for part in self._repr_obj(obj, level, self.maxother_inner, self.maxother_outer):
                 yield part
 
     def _repr_other(self, obj, level):
-        return self._repr_obj(obj, level,
-                              self.maxother_inner, self.maxother_outer)
+        return self._repr_obj(obj, level, self.maxother_inner, self.maxother_outer)
 
     def _repr_obj(self, obj, level, limit_inner, limit_outer):
         try:
             if self.raw_value:
                 # For raw value retrieval, ignore all limits.
                 if isinstance(obj, bytes):
-                    yield obj.decode('latin-1')
+                    yield obj.decode("latin-1")
                     return
 
                 try:
@@ -339,7 +335,7 @@ class SafeRepr(object):
                     return
                 else:
                     # Map bytes to Unicode codepoints with same values.
-                    yield mv.tobytes().decode('latin-1')
+                    yield mv.tobytes().decode("latin-1")
                     return
             elif self.convert_to_hex and isinstance(obj, self.int_types):
                 obj_repr = hex(obj)
@@ -350,9 +346,9 @@ class SafeRepr(object):
                 obj_repr = object.__repr__(obj)
             except Exception:
                 try:
-                    obj_repr = '<no repr available for ' + type(obj).__name__ + '>'  # noqa
+                    obj_repr = "<no repr available for " + type(obj).__name__ + ">"  # noqa
                 except Exception:
-                    obj_repr = '<no repr available for object>'
+                    obj_repr = "<no repr available for object>"
 
         limit = limit_inner if level > 0 else limit_outer
 
@@ -366,7 +362,7 @@ class SafeRepr(object):
         left_count, right_count = max(1, int(2 * limit / 3)), max(1, int(limit / 3))  # noqa
 
         yield obj_repr[:left_count]
-        yield '...'
+        yield "..."
         yield obj_repr[-right_count:]
 
     def _convert_to_unicode_or_bytes_repr(self, obj_repr):
@@ -377,7 +373,7 @@ class SafeRepr(object):
         # locale.getpreferredencoding() and 'utf-8). If no encoding can decode
         # the input, we return the original bytes.
         try_encodings = []
-        encoding = self.sys_stdout_encoding or getattr(sys.stdout, 'encoding', '')
+        encoding = self.sys_stdout_encoding or getattr(sys.stdout, "encoding", "")
         if encoding:
             try_encodings.append(encoding.lower())
 
@@ -387,8 +383,8 @@ class SafeRepr(object):
             if preferred_encoding not in try_encodings:
                 try_encodings.append(preferred_encoding)
 
-        if 'utf-8' not in try_encodings:
-            try_encodings.append('utf-8')
+        if "utf-8" not in try_encodings:
+            try_encodings.append("utf-8")
 
         for encoding in try_encodings:
             try:

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_save_locals.py

@@ -40,13 +40,14 @@ def make_save_locals_impl():
     lock being taken in different order in  different threads.
     """
     try:
-        if '__pypy__' in sys.builtin_module_names:
+        if "__pypy__" in sys.builtin_module_names:
             import __pypy__  # @UnresolvedImport
+
             save_locals = __pypy__.locals_to_fast
     except:
         pass
     else:
-        if '__pypy__' in sys.builtin_module_names:
+        if "__pypy__" in sys.builtin_module_names:
 
             def save_locals_pypy_impl(frame):
                 save_locals(frame)
@@ -55,6 +56,7 @@ def make_save_locals_impl():
 
     try:
         import ctypes
+
         locals_to_fast = ctypes.pythonapi.PyFrame_LocalsToFast
     except:
         pass