debugpy 1.8.3__zip → 1.8.6__zip

{debugpy-1.8.3 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_io.py

@@ -5,12 +5,12 @@ from contextlib import contextmanager
 
 
 class IORedirector:
-    '''
+    """
     This class works to wrap a stream (stdout/stderr) with an additional redirect.
-    '''
+    """
 
     def __init__(self, original, new_redirect, wrap_buffer=False):
-        '''
+        """
         :param stream original:
             The stream to be wrapped (usually stdout/stderr, but could be None).
 
@@ -20,11 +20,11 @@ class IORedirector:
         :param bool wrap_buffer:
             Whether to create a buffer attribute (needed to mimick python 3 s
             tdout/stderr which has a buffer to write binary data).
-        '''
+        """
         self._lock = ForkSafeLock(rlock=True)
         self._writing = False
         self._redirect_to = (original, new_redirect)
-        if wrap_buffer and hasattr(original, 'buffer'):
+        if wrap_buffer and hasattr(original, "buffer"):
             self.buffer = IORedirector(original.buffer, new_redirect.buffer, False)
 
     def write(self, s):
@@ -36,20 +36,20 @@ class IORedirector:
             self._writing = True
             try:
                 for r in self._redirect_to:
-                    if hasattr(r, 'write'):
+                    if hasattr(r, "write"):
                         r.write(s)
             finally:
                 self._writing = False
 
     def isatty(self):
         for r in self._redirect_to:
-            if hasattr(r, 'isatty'):
+            if hasattr(r, "isatty"):
                 return r.isatty()
         return False
 
     def flush(self):
         for r in self._redirect_to:
-            if hasattr(r, 'flush'):
+            if hasattr(r, "flush"):
                 r.flush()
 
     def __getattr__(self, name):
@@ -60,9 +60,8 @@ class IORedirector:
 
 
 class RedirectToPyDBIoMessages(object):
-
     def __init__(self, out_ctx, wrap_stream, wrap_buffer, on_write=None):
-        '''
+        """
         :param out_ctx:
             1=stdout and 2=stderr
 
@@ -77,10 +76,10 @@ class RedirectToPyDBIoMessages(object):
             May be a custom callable to be called when to write something.
             If not passed the default implementation will create an io message
             and send it through the debugger.
-        '''
-        encoding = getattr(wrap_stream, 'encoding', None)
+        """
+        encoding = getattr(wrap_stream, "encoding", None)
         if not encoding:
-            encoding = os.environ.get('PYTHONIOENCODING', 'utf-8')
+            encoding = os.environ.get("PYTHONIOENCODING", "utf-8")
         self.encoding = encoding
         self._out_ctx = out_ctx
         if wrap_buffer:
@@ -102,7 +101,7 @@ class RedirectToPyDBIoMessages(object):
         if s:
             # Need s in str
             if isinstance(s, bytes):
-                s = s.decode(self.encoding, errors='replace')
+                s = s.decode(self.encoding, errors="replace")
 
             py_db = self.get_pydb()
             if py_db is not None:
@@ -114,24 +113,25 @@ class RedirectToPyDBIoMessages(object):
 
 
 class IOBuf:
-    '''This class works as a replacement for stdio and stderr.
+    """This class works as a replacement for stdio and stderr.
     It is a buffer and when its contents are requested, it will erase what
     it has so far so that the next return will not return the same contents again.
-    '''
+    """
 
     def __init__(self):
         self.buflist = []
         import os
-        self.encoding = os.environ.get('PYTHONIOENCODING', 'utf-8')
+
+        self.encoding = os.environ.get("PYTHONIOENCODING", "utf-8")
 
     def getvalue(self):
         b = self.buflist
         self.buflist = []  # clear it
-        return ''.join(b)  # bytes on py2, str on py3.
+        return "".join(b)  # bytes on py2, str on py3.
 
     def write(self, s):
         if isinstance(s, bytes):
-            s = s.decode(self.encoding, errors='replace')
+            s = s.decode(self.encoding, errors="replace")
         self.buflist.append(s)
 
     def isatty(self):
@@ -145,7 +145,6 @@ class IOBuf:
 
 
 class _RedirectInfo(object):
-
     def __init__(self, original, redirect_to):
         self.original = original
         self.redirect_to = redirect_to
@@ -160,25 +159,25 @@ class _RedirectionsHolder:
     _pydevd_stderr_redirect_ = None
 
 
-def start_redirect(keep_original_redirection=False, std='stdout', redirect_to=None):
-    '''
+def start_redirect(keep_original_redirection=False, std="stdout", redirect_to=None):
+    """
     @param std: 'stdout', 'stderr', or 'both'
-    '''
+    """
     with _RedirectionsHolder._lock:
         if redirect_to is None:
             redirect_to = IOBuf()
 
-        if std == 'both':
-            config_stds = ['stdout', 'stderr']
+        if std == "both":
+            config_stds = ["stdout", "stderr"]
         else:
             config_stds = [std]
 
         for std in config_stds:
             original = getattr(sys, std)
-            stack = getattr(_RedirectionsHolder, '_stack_%s' % std)
+            stack = getattr(_RedirectionsHolder, "_stack_%s" % std)
 
             if keep_original_redirection:
-                wrap_buffer = True if hasattr(redirect_to, 'buffer') else False
+                wrap_buffer = True if hasattr(redirect_to, "buffer") else False
                 new_std_instance = IORedirector(getattr(sys, std), redirect_to, wrap_buffer=wrap_buffer)
                 setattr(sys, std, new_std_instance)
             else:
@@ -190,33 +189,33 @@ def start_redirect(keep_original_redirection=False, std='stdout', redirect_to=No
         return redirect_to
 
 
-def end_redirect(std='stdout'):
+def end_redirect(std="stdout"):
     with _RedirectionsHolder._lock:
-        if std == 'both':
-            config_stds = ['stdout', 'stderr']
+        if std == "both":
+            config_stds = ["stdout", "stderr"]
         else:
             config_stds = [std]
         for std in config_stds:
-            stack = getattr(_RedirectionsHolder, '_stack_%s' % std)
+            stack = getattr(_RedirectionsHolder, "_stack_%s" % std)
             redirect_info = stack.pop()
             setattr(sys, std, redirect_info.original)
 
 
 def redirect_stream_to_pydb_io_messages(std):
-    '''
+    """
     :param std:
         'stdout' or 'stderr'
-    '''
+    """
     with _RedirectionsHolder._lock:
-        redirect_to_name = '_pydevd_%s_redirect_' % (std,)
+        redirect_to_name = "_pydevd_%s_redirect_" % (std,)
         if getattr(_RedirectionsHolder, redirect_to_name) is None:
             wrap_buffer = True
             original = getattr(sys, std)
 
-            redirect_to = RedirectToPyDBIoMessages(1 if std == 'stdout' else 2, original, wrap_buffer)
+            redirect_to = RedirectToPyDBIoMessages(1 if std == "stdout" else 2, original, wrap_buffer)
             start_redirect(keep_original_redirection=True, std=std, redirect_to=redirect_to)
 
-            stack = getattr(_RedirectionsHolder, '_stack_%s' % std)
+            stack = getattr(_RedirectionsHolder, "_stack_%s" % std)
             setattr(_RedirectionsHolder, redirect_to_name, stack[-1])
             return True
 
@@ -224,17 +223,17 @@ def redirect_stream_to_pydb_io_messages(std):
 
 
 def stop_redirect_stream_to_pydb_io_messages(std):
-    '''
+    """
     :param std:
         'stdout' or 'stderr'
-    '''
+    """
     with _RedirectionsHolder._lock:
-        redirect_to_name = '_pydevd_%s_redirect_' % (std,)
+        redirect_to_name = "_pydevd_%s_redirect_" % (std,)
         redirect_info = getattr(_RedirectionsHolder, redirect_to_name)
         if redirect_info is not None:  # :type redirect_info: _RedirectInfo
             setattr(_RedirectionsHolder, redirect_to_name, None)
 
-            stack = getattr(_RedirectionsHolder, '_stack_%s' % std)
+            stack = getattr(_RedirectionsHolder, "_stack_%s" % std)
             prev_info = stack.pop()
 
             curr = getattr(sys, std)
@@ -246,7 +245,7 @@ def stop_redirect_stream_to_pydb_io_messages(std):
 def redirect_stream_to_pydb_io_messages_context():
     with _RedirectionsHolder._lock:
         redirecting = []
-        for std in ('stdout', 'stderr'):
+        for std in ("stdout", "stderr"):
             if redirect_stream_to_pydb_io_messages(std):
                 redirecting.append(std)
 
@@ -255,4 +254,3 @@ def redirect_stream_to_pydb_io_messages_context():
         finally:
             for std in redirecting:
                 stop_redirect_stream_to_pydb_io_messages(std)
-

debugpy-1.8.6/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_json_debug_options.py

@@ -0,0 +1,200 @@
+import json
+import urllib.parse as urllib_parse
+
+
+class DebugOptions(object):
+    __slots__ = [
+        "just_my_code",
+        "redirect_output",
+        "show_return_value",
+        "break_system_exit_zero",
+        "django_debug",
+        "flask_debug",
+        "stop_on_entry",
+        "max_exception_stack_frames",
+        "gui_event_loop",
+        "client_os",
+    ]
+
+    def __init__(self):
+        self.just_my_code = True
+        self.redirect_output = False
+        self.show_return_value = False
+        self.break_system_exit_zero = False
+        self.django_debug = False
+        self.flask_debug = False
+        self.stop_on_entry = False
+        self.max_exception_stack_frames = 0
+        self.gui_event_loop = "matplotlib"
+        self.client_os = None
+
+    def to_json(self):
+        dct = {}
+        for s in self.__slots__:
+            dct[s] = getattr(self, s)
+        return json.dumps(dct)
+
+    def update_fom_debug_options(self, debug_options):
+        if "DEBUG_STDLIB" in debug_options:
+            self.just_my_code = not debug_options.get("DEBUG_STDLIB")
+
+        if "REDIRECT_OUTPUT" in debug_options:
+            self.redirect_output = debug_options.get("REDIRECT_OUTPUT")
+
+        if "SHOW_RETURN_VALUE" in debug_options:
+            self.show_return_value = debug_options.get("SHOW_RETURN_VALUE")
+
+        if "BREAK_SYSTEMEXIT_ZERO" in debug_options:
+            self.break_system_exit_zero = debug_options.get("BREAK_SYSTEMEXIT_ZERO")
+
+        if "DJANGO_DEBUG" in debug_options:
+            self.django_debug = debug_options.get("DJANGO_DEBUG")
+
+        if "FLASK_DEBUG" in debug_options:
+            self.flask_debug = debug_options.get("FLASK_DEBUG")
+
+        if "STOP_ON_ENTRY" in debug_options:
+            self.stop_on_entry = debug_options.get("STOP_ON_ENTRY")
+
+        if "CLIENT_OS_TYPE" in debug_options:
+            self.client_os = debug_options.get("CLIENT_OS_TYPE")
+
+        # Note: _max_exception_stack_frames cannot be set by debug options.
+
+    def update_from_args(self, args):
+        if "justMyCode" in args:
+            self.just_my_code = bool_parser(args["justMyCode"])
+        else:
+            # i.e.: if justMyCode is provided, don't check the deprecated value
+            if "debugStdLib" in args:
+                self.just_my_code = not bool_parser(args["debugStdLib"])
+
+        if "redirectOutput" in args:
+            self.redirect_output = bool_parser(args["redirectOutput"])
+
+        if "showReturnValue" in args:
+            self.show_return_value = bool_parser(args["showReturnValue"])
+
+        if "breakOnSystemExitZero" in args:
+            self.break_system_exit_zero = bool_parser(args["breakOnSystemExitZero"])
+
+        if "django" in args:
+            self.django_debug = bool_parser(args["django"])
+
+        if "flask" in args:
+            self.flask_debug = bool_parser(args["flask"])
+
+        if "jinja" in args:
+            self.flask_debug = bool_parser(args["jinja"])
+
+        if "stopOnEntry" in args:
+            self.stop_on_entry = bool_parser(args["stopOnEntry"])
+
+        self.max_exception_stack_frames = int_parser(args.get("maxExceptionStackFrames", 0))
+
+        if "guiEventLoop" in args:
+            self.gui_event_loop = str(args["guiEventLoop"])
+
+        if "clientOS" in args:
+            self.client_os = str(args["clientOS"]).upper()
+
+
+def int_parser(s, default_value=0):
+    try:
+        return int(s)
+    except Exception:
+        return default_value
+
+
+def bool_parser(s):
+    return s in ("True", "true", "1", True, 1)
+
+
+def unquote(s):
+    return None if s is None else urllib_parse.unquote(s)
+
+
+DEBUG_OPTIONS_PARSER = {
+    "WAIT_ON_ABNORMAL_EXIT": bool_parser,
+    "WAIT_ON_NORMAL_EXIT": bool_parser,
+    "BREAK_SYSTEMEXIT_ZERO": bool_parser,
+    "REDIRECT_OUTPUT": bool_parser,
+    "DJANGO_DEBUG": bool_parser,
+    "FLASK_DEBUG": bool_parser,
+    "FIX_FILE_PATH_CASE": bool_parser,
+    "CLIENT_OS_TYPE": unquote,
+    "DEBUG_STDLIB": bool_parser,
+    "STOP_ON_ENTRY": bool_parser,
+    "SHOW_RETURN_VALUE": bool_parser,
+    "MULTIPROCESS": bool_parser,
+}
+
+DEBUG_OPTIONS_BY_FLAG = {
+    "RedirectOutput": "REDIRECT_OUTPUT=True",
+    "WaitOnNormalExit": "WAIT_ON_NORMAL_EXIT=True",
+    "WaitOnAbnormalExit": "WAIT_ON_ABNORMAL_EXIT=True",
+    "BreakOnSystemExitZero": "BREAK_SYSTEMEXIT_ZERO=True",
+    "Django": "DJANGO_DEBUG=True",
+    "Flask": "FLASK_DEBUG=True",
+    "Jinja": "FLASK_DEBUG=True",
+    "FixFilePathCase": "FIX_FILE_PATH_CASE=True",
+    "DebugStdLib": "DEBUG_STDLIB=True",
+    "WindowsClient": "CLIENT_OS_TYPE=WINDOWS",
+    "UnixClient": "CLIENT_OS_TYPE=UNIX",
+    "StopOnEntry": "STOP_ON_ENTRY=True",
+    "ShowReturnValue": "SHOW_RETURN_VALUE=True",
+    "Multiprocess": "MULTIPROCESS=True",
+}
+
+
+def _build_debug_options(flags):
+    """Build string representation of debug options from the launch config."""
+    return ";".join(DEBUG_OPTIONS_BY_FLAG[flag] for flag in flags or [] if flag in DEBUG_OPTIONS_BY_FLAG)
+
+
+def _parse_debug_options(opts):
+    """Debug options are semicolon separated key=value pairs"""
+    options = {}
+    if not opts:
+        return options
+
+    for opt in opts.split(";"):
+        try:
+            key, value = opt.split("=")
+        except ValueError:
+            continue
+        try:
+            options[key] = DEBUG_OPTIONS_PARSER[key](value)
+        except KeyError:
+            continue
+
+    return options
+
+
+def _extract_debug_options(opts, flags=None):
+    """Return the debug options encoded in the given value.
+
+    "opts" is a semicolon-separated string of "key=value" pairs.
+    "flags" is a list of strings.
+
+    If flags is provided then it is used as a fallback.
+
+    The values come from the launch config:
+
+     {
+         type:'python',
+         request:'launch'|'attach',
+         name:'friendly name for debug config',
+         debugOptions:[
+             'RedirectOutput', 'Django'
+         ],
+         options:'REDIRECT_OUTPUT=True;DJANGO_DEBUG=True'
+     }
+
+    Further information can be found here:
+
+    https://code.visualstudio.com/docs/editor/debugging#_launchjson-attributes
+    """
+    if not opts:
+        opts = _build_debug_options(flags)
+    return _parse_debug_options(opts)

{debugpy-1.8.3 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_net_command.py

@@ -1,15 +1,17 @@
-from _pydevd_bundle.pydevd_constants import DebugInfoHolder, \
-    get_global_debugger, GetGlobalDebugger, set_global_debugger  # Keep for backward compatibility @UnusedImport
+from _pydevd_bundle.pydevd_constants import (
+    DebugInfoHolder,
+    get_global_debugger,
+    GetGlobalDebugger,
+    set_global_debugger,
+)  # Keep for backward compatibility @UnusedImport
 from _pydevd_bundle.pydevd_utils import quote_smart as quote, to_string
 from _pydevd_bundle.pydevd_comm_constants import ID_TO_MEANING, CMD_EXIT
-from _pydevd_bundle.pydevd_constants import HTTP_PROTOCOL, HTTP_JSON_PROTOCOL, \
-    get_protocol, IS_JYTHON, ForkSafeLock
+from _pydevd_bundle.pydevd_constants import HTTP_PROTOCOL, HTTP_JSON_PROTOCOL, get_protocol, IS_JYTHON, ForkSafeLock
 import json
 from _pydev_bundle import pydev_log
 
 
 class _BaseNetCommand(object):
-
     # Command id. Should be set in instance.
     id = -1
 
@@ -28,7 +30,6 @@ class _NullNetCommand(_BaseNetCommand):
 
 
 class _NullExitCommand(_NullNetCommand):
-
     id = CMD_EXIT
 
 
@@ -46,6 +47,7 @@ class NetCommand(_BaseNetCommand):
     Command can represent command received from the debugger,
     or one to be sent by daemon.
     """
+
     next_seq = 0  # sequence numbers
 
     _showing_debug_info = 0
@@ -67,13 +69,13 @@ class NetCommand(_BaseNetCommand):
         self.seq = seq
 
         if is_json:
-            if hasattr(text, 'to_dict'):
+            if hasattr(text, "to_dict"):
                 as_dict = text.to_dict(update_ids_to_dap=True)
             else:
                 assert isinstance(text, dict)
                 as_dict = text
-            as_dict['pydevd_cmd_id'] = cmd_id
-            as_dict['seq'] = seq
+            as_dict["pydevd_cmd_id"] = cmd_id
+            as_dict["seq"] = seq
             self.as_dict = as_dict
             text = json.dumps(as_dict)
 
@@ -87,13 +89,13 @@ class NetCommand(_BaseNetCommand):
         else:
             if protocol not in (HTTP_PROTOCOL, HTTP_JSON_PROTOCOL):
                 encoded = quote(to_string(text), '/<>_=" \t')
-                msg = '%s\t%s\t%s\n' % (cmd_id, seq, encoded)
+                msg = "%s\t%s\t%s\n" % (cmd_id, seq, encoded)
 
             else:
-                msg = '%s\t%s\t%s' % (cmd_id, seq, text)
+                msg = "%s\t%s\t%s" % (cmd_id, seq, text)
 
         if isinstance(msg, str):
-            msg = msg.encode('utf-8')
+            msg = msg.encode("utf-8")
 
         assert isinstance(msg, bytes)
         as_bytes = msg
@@ -103,7 +105,7 @@ class NetCommand(_BaseNetCommand):
         as_bytes = self._as_bytes
         try:
             if get_protocol() in (HTTP_PROTOCOL, HTTP_JSON_PROTOCOL):
-                sock.sendall(('Content-Length: %s\r\n\r\n' % len(as_bytes)).encode('ascii'))
+                sock.sendall(("Content-Length: %s\r\n\r\n" % len(as_bytes)).encode("ascii"))
             sock.sendall(as_bytes)
             if self._after_send:
                 for method in self._after_send:
@@ -133,14 +135,13 @@ class NetCommand(_BaseNetCommand):
 
             cls._showing_debug_info += 1
             try:
-                out_message = 'sending cmd (%s) --> ' % (get_protocol(),)
-                out_message += "%20s" % ID_TO_MEANING.get(str(cmd_id), 'UNKNOWN')
-                out_message += ' '
-                out_message += text.replace('\n', ' ')
+                out_message = "sending cmd (%s) --> " % (get_protocol(),)
+                out_message += "%20s" % ID_TO_MEANING.get(str(cmd_id), "UNKNOWN")
+                out_message += " "
+                out_message += text.replace("\n", " ")
                 try:
-                    pydev_log.critical('%s\n', out_message)
+                    pydev_log.critical("%s\n", out_message)
                 except:
                     pass
             finally:
                 cls._showing_debug_info -= 1
-