debugpy 1.8.5__zip → 1.8.7__zip

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

@@ -1,4 +1,4 @@
-''' pydevd - a debugging daemon
+""" pydevd - a debugging daemon
 This is the daemon you launch for python remote debugging.
 
 Protocol:
@@ -61,24 +61,38 @@ each command has a format:
 
     * JAVA - remote debugger, the java end
     * PYDB - pydevd, the python end
-'''
+"""
 
 import linecache
 import os
 
 from _pydev_bundle.pydev_imports import _queue
-from _pydev_bundle._pydev_saved_modules import time
-from _pydev_bundle._pydev_saved_modules import threading
+from _pydev_bundle._pydev_saved_modules import time, ThreadingEvent
 from _pydev_bundle._pydev_saved_modules import socket as socket_module
-from _pydevd_bundle.pydevd_constants import (DebugInfoHolder, IS_WINDOWS, IS_JYTHON, IS_WASM,
-    IS_PY36_OR_GREATER, STATE_RUN, ASYNC_EVAL_TIMEOUT_SEC,
-    get_global_debugger, GetGlobalDebugger, set_global_debugger,  # Keep for backward compatibility @UnusedImport
-    silence_warnings_decorator, filter_all_warnings, IS_PY311_OR_GREATER)
+from _pydevd_bundle.pydevd_constants import (
+    DebugInfoHolder,
+    IS_WINDOWS,
+    IS_JYTHON,
+    IS_WASM,
+    IS_PY36_OR_GREATER,
+    STATE_RUN,
+    ASYNC_EVAL_TIMEOUT_SEC,
+    get_global_debugger,
+    GetGlobalDebugger,
+    set_global_debugger,  # Keep for backward compatibility @UnusedImport
+    silence_warnings_decorator,
+    filter_all_warnings,
+    IS_PY311_OR_GREATER,
+)
 from _pydev_bundle.pydev_override import overrides
 import weakref
 from _pydev_bundle._pydev_completer import extract_token_and_qualifier
-from _pydevd_bundle._debug_adapter.pydevd_schema import VariablesResponseBody, \
-    SetVariableResponseBody, StepInTarget, StepInTargetsResponseBody
+from _pydevd_bundle._debug_adapter.pydevd_schema import (
+    VariablesResponseBody,
+    SetVariableResponseBody,
+    StepInTarget,
+    StepInTargetsResponseBody,
+)
 from _pydevd_bundle._debug_adapter import pydevd_base_schema, pydevd_schema
 from _pydevd_bundle.pydevd_net_command import NetCommand
 from _pydevd_bundle.pydevd_xml import ExceptionOnEvaluate
@@ -97,8 +111,16 @@ from _pydevd_bundle import pydevd_xml
 from _pydevd_bundle import pydevd_vm_type
 import sys
 import traceback
-from _pydevd_bundle.pydevd_utils import quote_smart as quote, compare_object_attrs_key, \
-    notify_about_gevent_if_needed, isinstance_checked, ScopeRequest, getattr_checked, Timer
+from _pydevd_bundle.pydevd_utils import (
+    quote_smart as quote,
+    compare_object_attrs_key,
+    notify_about_gevent_if_needed,
+    isinstance_checked,
+    ScopeRequest,
+    getattr_checked,
+    Timer,
+    is_current_thread_main_thread,
+)
 from _pydev_bundle import pydev_log, fsnotify
 from _pydev_bundle.pydev_log import exception as pydev_log_exception
 from _pydev_bundle import _pydev_completer
@@ -112,8 +134,9 @@ from io import StringIO
 from _pydevd_bundle.pydevd_comm_constants import *  # @UnusedWildImport
 
 # Socket import aliases:
-AF_INET, SOCK_STREAM, SHUT_WR, SOL_SOCKET, IPPROTO_TCP, socket = (
+AF_INET, AF_INET6, SOCK_STREAM, SHUT_WR, SOL_SOCKET, IPPROTO_TCP, socket = (
     socket_module.AF_INET,
+    socket_module.AF_INET6,
     socket_module.SOCK_STREAM,
     socket_module.SHUT_WR,
     socket_module.SOL_SOCKET,
@@ -128,7 +151,7 @@ if not IS_WASM:
 
 
 class ReaderThread(PyDBDaemonThread):
-    ''' reader thread reads and dispatches commands in an infinite loop '''
+    """reader thread reads and dispatches commands in an infinite loop"""
 
     def __init__(self, sock, py_db, PyDevJsonCommandProcessor, process_net_command, terminate_on_socket_close=True):
         assert sock is not None
@@ -136,7 +159,7 @@ class ReaderThread(PyDBDaemonThread):
         self.__terminate_on_socket_close = terminate_on_socket_close
 
         self.sock = sock
-        self._buffer = b''
+        self._buffer = b""
         self.name = "pydevd.Reader"
         self.process_net_command = process_net_command
         self.process_net_command_json = PyDevJsonCommandProcessor(self._from_json).process_net_command_json
@@ -175,7 +198,7 @@ class ReaderThread(PyDBDaemonThread):
             buffer_len = len(self._buffer)
             if buffer_len == size:
                 ret = self._buffer
-                self._buffer = b''
+                self._buffer = b""
                 return ret
 
             if buffer_len > size:
@@ -186,14 +209,14 @@ class ReaderThread(PyDBDaemonThread):
             try:
                 r = self.sock.recv(max(size - buffer_len, 1024))
             except OSError:
-                return b''
+                return b""
             if not r:
-                return b''
+                return b""
             self._buffer += r
 
     def _read_line(self):
         while True:
-            i = self._buffer.find(b'\n')
+            i = self._buffer.find(b"\n")
             if i != -1:
                 i += 1  # Add the newline to the return
                 ret = self._buffer[:i]
@@ -203,9 +226,9 @@ class ReaderThread(PyDBDaemonThread):
                 try:
                     r = self.sock.recv(1024)
                 except OSError:
-                    return b''
+                    return b""
                 if not r:
-                    return b''
+                    return b""
                 self._buffer += r
 
     @overrides(PyDBDaemonThread._on_run)
@@ -222,26 +245,26 @@ class ReaderThread(PyDBDaemonThread):
                     line = self._read_line()
 
                     if len(line) == 0:
-                        pydev_log.debug('ReaderThread: empty contents received (len(line) == 0).')
+                        pydev_log.debug("ReaderThread: empty contents received (len(line) == 0).")
                         self._terminate_on_socket_close()
                         return  # Finished communication.
 
                     if self._kill_received:
                         continue
 
-                    if line.startswith(b'Content-Length:'):
-                        content_len = int(line.strip().split(b':', 1)[1])
+                    if line.startswith(b"Content-Length:"):
+                        content_len = int(line.strip().split(b":", 1)[1])
                         continue
 
                     if content_len != -1:
                         # If we previously received a content length, read until a '\r\n'.
-                        if line == b'\r\n':
+                        if line == b"\r\n":
                             json_contents = self._read(content_len)
 
                             content_len = -1
 
                             if len(json_contents) == 0:
-                                pydev_log.debug('ReaderThread: empty contents received (len(json_contents) == 0).')
+                                pydev_log.debug("ReaderThread: empty contents received (len(json_contents) == 0).")
                                 self._terminate_on_socket_close()
                                 return  # Finished communication.
 
@@ -254,13 +277,13 @@ class ReaderThread(PyDBDaemonThread):
                         continue
                     else:
                         # No content len, regular line-based protocol message (remove trailing new-line).
-                        if line.endswith(b'\n\n'):
+                        if line.endswith(b"\n\n"):
                             line = line[:-2]
 
-                        elif line.endswith(b'\n'):
+                        elif line.endswith(b"\n"):
                             line = line[:-1]
 
-                        elif line.endswith(b'\r'):
+                        elif line.endswith(b"\r"):
                             line = line[:-1]
                 except:
                     if not self._kill_received:
@@ -271,17 +294,17 @@ class ReaderThread(PyDBDaemonThread):
                 # Note: the java backend is always expected to pass utf-8 encoded strings. We now work with str
                 # internally and thus, we may need to convert to the actual encoding where needed (i.e.: filenames
                 # on python 2 may need to be converted to the filesystem encoding).
-                if hasattr(line, 'decode'):
-                    line = line.decode('utf-8')
+                if hasattr(line, "decode"):
+                    line = line.decode("utf-8")
 
                 if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3:
-                    pydev_log.debug('debugger: received >>%s<<\n', line)
+                    pydev_log.debug("debugger: received >>%s<<\n", line)
 
-                args = line.split('\t', 2)
+                args = line.split("\t", 2)
                 try:
                     cmd_id = int(args[0])
                     if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3:
-                        pydev_log.debug('Received command: %s %s\n', ID_TO_MEANING.get(str(cmd_id), '???'), line)
+                        pydev_log.debug("Received command: %s %s\n", ID_TO_MEANING.get(str(cmd_id), "???"), line)
                     self.process_command(cmd_id, int(args[1]), args[2])
                 except:
                     if sys is not None and pydev_log_exception is not None:  # Could happen at interpreter shutdown
@@ -294,7 +317,7 @@ class ReaderThread(PyDBDaemonThread):
 
             self._terminate_on_socket_close()
         finally:
-            pydev_log.debug('ReaderThread: exit')
+            pydev_log.debug("ReaderThread: exit")
 
     def _terminate_on_socket_close(self):
         if self.__terminate_on_socket_close:
@@ -305,7 +328,6 @@ class ReaderThread(PyDBDaemonThread):
 
 
 class FSNotifyThread(PyDBDaemonThread):
-
     def __init__(self, py_db, api, watch_dirs):
         PyDBDaemonThread.__init__(self, py_db)
         self.api = api
@@ -316,7 +338,7 @@ class FSNotifyThread(PyDBDaemonThread):
     @overrides(PyDBDaemonThread._on_run)
     def _on_run(self):
         try:
-            pydev_log.info('Watching directories for code reload:\n---\n%s\n---' % ('\n'.join(sorted(self.watch_dirs))))
+            pydev_log.info("Watching directories for code reload:\n---\n%s\n---" % ("\n".join(sorted(self.watch_dirs))))
 
             # i.e.: The first call to set_tracked_paths will do a full scan, so, do it in the thread
             # too (after everything is configured).
@@ -325,12 +347,12 @@ class FSNotifyThread(PyDBDaemonThread):
                 for change_enum, change_path in self.watcher.iter_changes():
                     # We're only interested in modified events
                     if change_enum == fsnotify.Change.modified:
-                        pydev_log.info('Modified: %s', change_path)
+                        pydev_log.info("Modified: %s", change_path)
                         self.api.request_reload_code(self.py_db, -1, None, change_path)
                     else:
-                        pydev_log.info('Ignored (add or remove) change in: %s', change_path)
+                        pydev_log.info("Ignored (add or remove) change in: %s", change_path)
         except:
-            pydev_log.exception('Error when waiting for filesystem changes in FSNotifyThread.')
+            pydev_log.exception("Error when waiting for filesystem changes in FSNotifyThread.")
 
     @overrides(PyDBDaemonThread.do_kill_pydev_thread)
     def do_kill_pydev_thread(self):
@@ -339,7 +361,7 @@ class FSNotifyThread(PyDBDaemonThread):
 
 
 class WriterThread(PyDBDaemonThread):
-    ''' writer thread writes out the commands in an infinite loop '''
+    """writer thread writes out the commands in an infinite loop"""
 
     def __init__(self, sock, py_db, terminate_on_socket_close=True):
         PyDBDaemonThread.__init__(self, py_db)
@@ -347,19 +369,19 @@ class WriterThread(PyDBDaemonThread):
         self.__terminate_on_socket_close = terminate_on_socket_close
         self.name = "pydevd.Writer"
         self._cmd_queue = _queue.Queue()
-        if pydevd_vm_type.get_vm_type() == 'python':
+        if pydevd_vm_type.get_vm_type() == "python":
             self.timeout = 0
         else:
             self.timeout = 0.1
 
     def add_command(self, cmd):
-        ''' cmd is NetCommand '''
+        """cmd is NetCommand"""
         if not self._kill_received:  # we don't take new data after everybody die
             self._cmd_queue.put(cmd, False)
 
     @overrides(PyDBDaemonThread._on_run)
     def _on_run(self):
-        ''' just loop and write responses '''
+        """just loop and write responses"""
 
         try:
             while True:
@@ -368,7 +390,7 @@ class WriterThread(PyDBDaemonThread):
                         cmd = self._cmd_queue.get(True, 0.1)
                     except _queue.Empty:
                         if self._kill_received:
-                            pydev_log.debug('WriterThread: kill_received (sock.shutdown(SHUT_WR))')
+                            pydev_log.debug("WriterThread: kill_received (sock.shutdown(SHUT_WR))")
                             try:
                                 self.sock.shutdown(SHUT_WR)
                             except:
@@ -400,7 +422,7 @@ class WriterThread(PyDBDaemonThread):
                 cmd.send(self.sock)
 
                 if cmd.id == CMD_EXIT:
-                    pydev_log.debug('WriterThread: CMD_EXIT received')
+                    pydev_log.debug("WriterThread: CMD_EXIT received")
                     break
                 if time is None:
                     break  # interpreter shutdown
@@ -411,7 +433,7 @@ class WriterThread(PyDBDaemonThread):
                 if DebugInfoHolder.DEBUG_TRACE_LEVEL > 0:
                     pydev_log_exception()
         finally:
-            pydev_log.debug('WriterThread: exit')
+            pydev_log.debug("WriterThread: exit")
 
     def empty(self):
         return self._cmd_queue.empty()
@@ -444,11 +466,17 @@ def create_server_socket(host, port):
 
 
 def start_server(port):
-    ''' binds to a port, waits for the debugger to connect '''
-    s = create_server_socket(host='', port=port)
+    """binds to a port, waits for the debugger to connect"""
+    s = create_server_socket(host="", port=port)
 
     try:
         s.listen(1)
+        # Let the user know it's halted waiting for the connection.
+        host, port = s.getsockname()
+        msg = f"pydevd: waiting for connection at: {host}:{port}"
+        print(msg, file=sys.stderr)
+        pydev_log.info(msg)
+
         new_socket, _addr = s.accept()
         pydev_log.info("Connection accepted")
         # closing server socket is not necessary but we don't need it
@@ -460,10 +488,20 @@ def start_server(port):
 
 
 def start_client(host, port):
-    ''' connects to a host/port '''
+    """connects to a host/port"""
     pydev_log.info("Connecting to %s:%s", host, port)
 
-    s = socket(AF_INET, SOCK_STREAM)
+    address_family = AF_INET
+    for res in socket_module.getaddrinfo(host, port, 0, SOCK_STREAM):
+        if res[0] == AF_INET:
+            address_family = res[0]
+            # Prefer IPv4 addresses for backward compat.
+            break
+        if res[0] == AF_INET6:
+            # Don't break after this - if the socket is dual-stack prefer IPv4.
+            address_family = res[0]
+
+    s = socket(address_family, SOCK_STREAM)
 
     #  Set TCP keepalive on an open socket.
     #  It activates after 1 second (TCP_KEEPIDLE,) of idleness,
@@ -488,11 +526,11 @@ def start_client(host, port):
 
     try:
         # 10 seconds default timeout
-        timeout = int(os.environ.get('PYDEVD_CONNECT_TIMEOUT', 10))
+        timeout = int(os.environ.get("PYDEVD_CONNECT_TIMEOUT", 10))
         s.settimeout(timeout)
         s.connect((host, port))
         s.settimeout(None)  # no timeout after connected
-        pydev_log.info("Connected.")
+        pydev_log.info(f"Connected to: {s}.")
         return s
     except:
         pydev_log.exception("Could not connect to %s: %s", host, port)
@@ -504,12 +542,12 @@ INTERNAL_SUSPEND_THREAD = 2
 
 
 class InternalThreadCommand(object):
-    ''' internal commands are generated/executed by the debugger.
+    """internal commands are generated/executed by the debugger.
 
     The reason for their existence is that some commands have to be executed
     on specific threads. These are the InternalThreadCommands that get
     get posted to PyDB.
-    '''
+    """
 
     def __init__(self, thread_id, method=None, *args, **kwargs):
         self.thread_id = thread_id
@@ -518,9 +556,8 @@ class InternalThreadCommand(object):
         self.kwargs = kwargs
 
     def can_be_executed_by(self, thread_id):
-        '''By default, it must be in the same thread to be executed
-        '''
-        return self.thread_id == thread_id or self.thread_id.endswith('|' + thread_id)
+        """By default, it must be in the same thread to be executed"""
+        return self.thread_id == thread_id or self.thread_id.endswith("|" + thread_id)
 
     def do_it(self, dbg):
         try:
@@ -533,15 +570,14 @@ class InternalThreadCommand(object):
             self.kwargs = None
 
     def __str__(self):
-        return 'InternalThreadCommands(%s, %s, %s)' % (self.method, self.args, self.kwargs)
+        return "InternalThreadCommands(%s, %s, %s)" % (self.method, self.args, self.kwargs)
 
     __repr__ = __str__
 
 
 class InternalThreadCommandForAnyThread(InternalThreadCommand):
-
     def __init__(self, thread_id, method=None, *args, **kwargs):
-        assert thread_id == '*'
+        assert thread_id == "*"
 
         InternalThreadCommand.__init__(self, thread_id, method, *args, **kwargs)
 
@@ -572,8 +608,8 @@ def internal_reload_code(dbg, seq, module_name, filename):
         if module_name is not None:
             module_name = module_name
             if module_name not in sys.modules:
-                if '.' in module_name:
-                    new_module_name = module_name.split('.')[-1]
+                if "." in module_name:
+                    new_module_name = module_name.split(".")[-1]
                     if new_module_name in sys.modules:
                         module_name = new_module_name
 
@@ -585,9 +621,9 @@ def internal_reload_code(dbg, seq, module_name, filename):
         if filename:
             filename = pydevd_file_utils.normcase(filename)
             for module_name, module in sys.modules.copy().items():
-                f = getattr_checked(module, '__file__')
+                f = getattr_checked(module, "__file__")
                 if f is not None:
-                    if f.endswith(('.pyc', '.pyo')):
+                    if f.endswith((".pyc", ".pyo")):
                         f = f[:-1]
 
                     if pydevd_file_utils.normcase(f) == filename:
@@ -595,11 +631,11 @@ def internal_reload_code(dbg, seq, module_name, filename):
 
         if not modules_to_reload:
             if filename and module_name:
-                _send_io_message(dbg, 'code reload: Unable to find module %s to reload for path: %s\n' % (module_name, filename))
+                _send_io_message(dbg, "code reload: Unable to find module %s to reload for path: %s\n" % (module_name, filename))
             elif filename:
-                _send_io_message(dbg, 'code reload: Unable to find module to reload for path: %s\n' % (filename,))
+                _send_io_message(dbg, "code reload: Unable to find module to reload for path: %s\n" % (filename,))
             elif module_name:
-                _send_io_message(dbg, 'code reload: Unable to find module to reload: %s\n' % (module_name,))
+                _send_io_message(dbg, "code reload: Unable to find module to reload: %s\n" % (module_name,))
 
         else:
             # Too much info...
@@ -609,25 +645,25 @@ def internal_reload_code(dbg, seq, module_name, filename):
                 found_module_to_reload = True
 
                 if pydevd_reload.xreload(module):
-                    _send_io_message(dbg, 'code reload: reload finished\n')
+                    _send_io_message(dbg, "code reload: reload finished\n")
                 else:
-                    _send_io_message(dbg, 'code reload: reload finished without applying any change\n')
+                    _send_io_message(dbg, "code reload: reload finished without applying any change\n")
 
         cmd = dbg.cmd_factory.make_reloaded_code_message(seq, found_module_to_reload)
         dbg.writer.add_command(cmd)
     except:
-        pydev_log.exception('Error reloading code')
+        pydev_log.exception("Error reloading code")
 
 
 class InternalGetThreadStack(InternalThreadCommand):
-    '''
+    """
     This command will either wait for a given thread to be paused to get its stack or will provide
     it anyways after a timeout (in which case the stack will be gotten but local variables won't
     be available and it'll not be possible to interact with the frame as it's not actually
     stopped in a breakpoint).
-    '''
+    """
 
-    def __init__(self, seq, thread_id, py_db, set_additional_thread_info, fmt, timeout=.5, start_frame=0, levels=0):
+    def __init__(self, seq, thread_id, py_db, set_additional_thread_info, fmt, timeout=0.5, start_frame=0, levels=0):
         InternalThreadCommand.__init__(self, thread_id)
         self._py_db = weakref.ref(py_db)
         self._timeout = time.time() + timeout
@@ -648,12 +684,20 @@ class InternalGetThreadStack(InternalThreadCommand):
         py_db = self._py_db()
         t = pydevd_find_thread_by_id(self.thread_id)
         frame = None
-        if t and not getattr(t, 'pydev_do_not_trace', None):
+        if t and not getattr(t, "pydev_do_not_trace", None):
             additional_info = self._set_additional_thread_info(t)
             frame = additional_info.get_topmost_frame(t)
         try:
             self._cmd = py_db.cmd_factory.make_get_thread_stack_message(
-                py_db, self.seq, self.thread_id, frame, self._fmt, must_be_suspended=not timed_out, start_frame=self._start_frame, levels=self._levels)
+                py_db,
+                self.seq,
+                self.thread_id,
+                frame,
+                self._fmt,
+                must_be_suspended=not timed_out,
+                start_frame=self._start_frame,
+                levels=self._levels,
+            )
         finally:
             frame = None
             t = None
@@ -675,9 +719,10 @@ def internal_step_in_thread(py_db, thread_id, cmd_id, set_additional_thread_info
         info.pydev_step_cmd = cmd_id
         info.pydev_step_stop = None
         info.pydev_state = STATE_RUN
+        info.update_stepping_info()
 
     if py_db.stepping_resumes_all_threads:
-        resume_threads('*', except_thread=thread_to_step)
+        resume_threads("*", except_thread=thread_to_step)
 
 
 def internal_smart_step_into(py_db, thread_id, offset, child_offset, set_additional_thread_info):
@@ -690,21 +735,21 @@ def internal_smart_step_into(py_db, thread_id, offset, child_offset, set_additio
         info.pydev_smart_parent_offset = int(offset)
         info.pydev_smart_child_offset = int(child_offset)
         info.pydev_state = STATE_RUN
+        info.update_stepping_info()
 
     if py_db.stepping_resumes_all_threads:
-        resume_threads('*', except_thread=thread_to_step)
+        resume_threads("*", except_thread=thread_to_step)
 
 
 class InternalSetNextStatementThread(InternalThreadCommand):
-
     def __init__(self, thread_id, cmd_id, line, func_name, seq=0):
-        '''
+        """
         cmd_id may actually be one of:
 
         CMD_RUN_TO_LINE
         CMD_SET_NEXT_STATEMENT
         CMD_SMART_STEP_INTO
-        '''
+        """
         self.thread_id = thread_id
         self.cmd_id = cmd_id
         self.line = line
@@ -725,13 +770,14 @@ class InternalSetNextStatementThread(InternalThreadCommand):
             info.pydev_smart_parent_offset = -1
             info.pydev_smart_child_offset = -1
             info.pydev_state = STATE_RUN
+            info.update_stepping_info()
 
 
 @silence_warnings_decorator
 def internal_get_variable_json(py_db, request):
-    '''
-        :param VariablesRequest request:
-    '''
+    """
+    :param VariablesRequest request:
+    """
     arguments = request.arguments  # : :type arguments: VariablesArguments
     variables_reference = arguments.variablesReference
     scope = None
@@ -740,7 +786,7 @@ def internal_get_variable_json(py_db, request):
         variables_reference = variables_reference.variable_reference
 
     fmt = arguments.format
-    if hasattr(fmt, 'to_dict'):
+    if hasattr(fmt, "to_dict"):
         fmt = fmt.to_dict()
 
     variables = []
@@ -755,25 +801,20 @@ def internal_get_variable_json(py_db, request):
     except:
         try:
             exc, exc_type, tb = sys.exc_info()
-            err = ''.join(traceback.format_exception(exc, exc_type, tb))
-            variables = [{
-                'name': '<error>',
-                'value': err,
-                'type': '<error>',
-                'variablesReference': 0
-            }]
+            err = "".join(traceback.format_exception(exc, exc_type, tb))
+            variables = [{"name": "<error>", "value": err, "type": "<error>", "variablesReference": 0}]
         except:
-            err = '<Internal error - unable to get traceback when getting variables>'
+            err = "<Internal error - unable to get traceback when getting variables>"
             pydev_log.exception(err)
             variables = []
 
     body = VariablesResponseBody(variables)
-    variables_response = pydevd_base_schema.build_response(request, kwargs={'body':body})
+    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body})
     py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
 class InternalGetVariable(InternalThreadCommand):
-    ''' gets the value of a variable '''
+    """gets the value of a variable"""
 
     def __init__(self, seq, thread_id, frame_id, scope, attrs):
         self.sequence = seq
@@ -784,12 +825,13 @@ class InternalGetVariable(InternalThreadCommand):
 
     @silence_warnings_decorator
     def do_it(self, dbg):
-        ''' Converts request into python variable '''
+        """Converts request into python variable"""
         try:
             xml = StringIO()
             xml.write("<xml>")
             type_name, val_dict = pydevd_vars.resolve_compound_variable_fields(
-                dbg, self.thread_id, self.frame_id, self.scope, self.attributes)
+                dbg, self.thread_id, self.frame_id, self.scope, self.attributes
+            )
             if val_dict is None:
                 val_dict = {}
 
@@ -811,13 +853,11 @@ class InternalGetVariable(InternalThreadCommand):
             xml.close()
             dbg.writer.add_command(cmd)
         except Exception:
-            cmd = dbg.cmd_factory.make_error_message(
-                self.sequence, "Error resolving variables %s" % (get_exception_traceback_str(),))
+            cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error resolving variables %s" % (get_exception_traceback_str(),))
             dbg.writer.add_command(cmd)
 
 
 class InternalGetArray(InternalThreadCommand):
-
     def __init__(self, seq, roffset, coffset, rows, cols, format, thread_id, frame_id, scope, attrs):
         self.sequence = seq
         self.thread_id = thread_id
@@ -844,7 +884,7 @@ class InternalGetArray(InternalThreadCommand):
 
 
 def internal_change_variable(dbg, seq, thread_id, frame_id, scope, attr, value):
-    ''' Changes the value of a variable '''
+    """Changes the value of a variable"""
     try:
         frame = dbg.find_frame(thread_id, frame_id)
         if frame is not None:
@@ -857,18 +897,20 @@ def internal_change_variable(dbg, seq, thread_id, frame_id, scope, attr, value):
         cmd = dbg.cmd_factory.make_variable_changed_message(seq, xml)
         dbg.writer.add_command(cmd)
     except Exception:
-        cmd = dbg.cmd_factory.make_error_message(seq, "Error changing variable attr:%s expression:%s traceback:%s" % (attr, value, get_exception_traceback_str()))
+        cmd = dbg.cmd_factory.make_error_message(
+            seq, "Error changing variable attr:%s expression:%s traceback:%s" % (attr, value, get_exception_traceback_str())
+        )
         dbg.writer.add_command(cmd)
 
 
 def internal_change_variable_json(py_db, request):
-    '''
+    """
     The pydevd_vars.change_attr_expression(thread_id, frame_id, attr, value, dbg) can only
     deal with changing at a frame level, so, currently changing the contents of something
     in a different scope is currently not supported.
 
     :param SetVariableRequest request:
-    '''
+    """
     # : :type arguments: SetVariableArguments
     arguments = request.arguments
     variables_reference = arguments.variablesReference
@@ -878,7 +920,7 @@ def internal_change_variable_json(py_db, request):
         variables_reference = variables_reference.variable_reference
 
     fmt = arguments.format
-    if hasattr(fmt, 'to_dict'):
+    if hasattr(fmt, "to_dict"):
         fmt = fmt.to_dict()
 
     try:
@@ -888,44 +930,38 @@ def internal_change_variable_json(py_db, request):
 
     if variable is None:
         _write_variable_response(
-            py_db, request, value='', success=False, message='Unable to find variable container to change: %s.' % (variables_reference,))
+            py_db, request, value="", success=False, message="Unable to find variable container to change: %s." % (variables_reference,)
+        )
         return
 
     child_var = variable.change_variable(arguments.name, arguments.value, py_db, fmt=fmt)
 
     if child_var is None:
-        _write_variable_response(
-            py_db, request, value='', success=False, message='Unable to change: %s.' % (arguments.name,))
+        _write_variable_response(py_db, request, value="", success=False, message="Unable to change: %s." % (arguments.name,))
         return
 
     var_data = child_var.get_var_data(fmt=fmt)
     body = SetVariableResponseBody(
-        value=var_data['value'],
-        type=var_data['type'],
-        variablesReference=var_data.get('variablesReference'),
-        namedVariables=var_data.get('namedVariables'),
-        indexedVariables=var_data.get('indexedVariables'),
+        value=var_data["value"],
+        type=var_data["type"],
+        variablesReference=var_data.get("variablesReference"),
+        namedVariables=var_data.get("namedVariables"),
+        indexedVariables=var_data.get("indexedVariables"),
     )
-    variables_response = pydevd_base_schema.build_response(request, kwargs={'body':body})
+    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body})
     py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
 def _write_variable_response(py_db, request, value, success, message):
-    body = SetVariableResponseBody('')
-    variables_response = pydevd_base_schema.build_response(
-        request,
-        kwargs={
-            'body':body,
-            'success': False,
-            'message': message
-    })
+    body = SetVariableResponseBody("")
+    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body, "success": False, "message": message})
     cmd = NetCommand(CMD_RETURN, 0, variables_response, is_json=True)
     py_db.writer.add_command(cmd)
 
 
 @silence_warnings_decorator
 def internal_get_frame(dbg, seq, thread_id, frame_id):
-    ''' Converts request into python variable '''
+    """Converts request into python variable"""
     try:
         frame = dbg.find_frame(thread_id, frame_id)
         if frame is not None:
@@ -972,21 +1008,33 @@ def internal_get_smart_step_into_variants(dbg, seq, thread_id, frame_id, start_l
                 for child_variant in variant.children_variants:
                     # If there are child variants, the current one is just an intermediary, so,
                     # just create variants for the child (notifying properly about the parent too).
-                    xml += '<variant name="%s" isVisited="%s" line="%s" offset="%s" childOffset="%s" callOrder="%s"/>' % (
-                        quote(child_variant.name),
-                        str(child_variant.is_visited).lower(),
-                        child_variant.line,
-                        variant.offset,
-                        child_variant.offset,
-                        child_variant.call_order,
+                    xml += (
+                        '<variant name="%s" isVisited="%s" line="%s" offset="%s" childOffset="%s" callOrder="%s" endlineno="%s" startcol="%s" endcol="%s"/>'
+                        % (
+                            quote(child_variant.name),
+                            str(child_variant.is_visited).lower(),
+                            child_variant.line,
+                            variant.offset,
+                            child_variant.offset,
+                            child_variant.call_order,
+                            variant.endlineno,
+                            variant.startcol,
+                            variant.endcol,
+                        )
                     )
             else:
-                xml += '<variant name="%s" isVisited="%s" line="%s" offset="%s" childOffset="-1" callOrder="%s"/>' % (
-                    quote(variant.name),
-                    str(variant.is_visited).lower(),
-                    variant.line,
-                    variant.offset,
-                    variant.call_order,
+                xml += (
+                    '<variant name="%s" isVisited="%s" line="%s" offset="%s" childOffset="-1" callOrder="%s" endlineno="%s" startcol="%s" endcol="%s"/>'
+                    % (
+                        quote(variant.name),
+                        str(variant.is_visited).lower(),
+                        variant.line,
+                        variant.offset,
+                        variant.call_order,
+                        variant.endlineno,
+                        variant.startcol,
+                        variant.endcol,
+                    )
                 )
 
         xml += "</xml>"
@@ -994,10 +1042,10 @@ def internal_get_smart_step_into_variants(dbg, seq, thread_id, frame_id, start_l
         dbg.writer.add_command(cmd)
     except:
         # Error is expected (if `dis` module cannot be used -- i.e.: Jython).
-        pydev_log.exception('Error calculating Smart Step Into Variants.')
+        pydev_log.exception("Error calculating Smart Step Into Variants.")
         cmd = dbg.cmd_factory.make_error_message(
-            seq, "Error getting smart step into variants for frame: %s from thread: %s"
-            % (frame_id, thread_id))
+            seq, "Error getting smart step into variants for frame: %s from thread: %s" % (frame_id, thread_id)
+        )
         dbg.writer.add_command(cmd)
 
 
@@ -1009,12 +1057,8 @@ def internal_get_step_in_targets_json(dbg, seq, thread_id, frame_id, request, se
         if thread is None or frame is None:
             body = StepInTargetsResponseBody([])
             variables_response = pydevd_base_schema.build_response(
-                request,
-                kwargs={
-                    'body': body,
-                    'success': False,
-                    'message': 'Thread to get step in targets seems to have resumed already.'
-                })
+                request, kwargs={"body": body, "success": False, "message": "Thread to get step in targets seems to have resumed already."}
+            )
             cmd = NetCommand(CMD_RETURN, 0, variables_response, is_json=True)
             dbg.writer.add_command(cmd)
             return
@@ -1037,7 +1081,12 @@ def internal_get_step_in_targets_json(dbg, seq, thread_id, frame_id, request, se
                         target_id = next(counter)
 
                         if child_variant.call_order > 1:
-                            targets.append(StepInTarget(id=target_id, label='%s (call %s)' % (child_variant.name, child_variant.call_order),))
+                            targets.append(
+                                StepInTarget(
+                                    id=target_id,
+                                    label="%s (call %s)" % (child_variant.name, child_variant.call_order),
+                                )
+                            )
                         else:
                             targets.append(StepInTarget(id=target_id, label=child_variant.name))
                         target_id_to_variant[target_id] = child_variant
@@ -1047,7 +1096,12 @@ def internal_get_step_in_targets_json(dbg, seq, thread_id, frame_id, request, se
                 else:
                     target_id = next(counter)
                     if variant.call_order > 1:
-                        targets.append(StepInTarget(id=target_id, label='%s (call %s)' % (variant.name, variant.call_order),))
+                        targets.append(
+                            StepInTarget(
+                                id=target_id,
+                                label="%s (call %s)" % (variant.name, variant.call_order),
+                            )
+                        )
                     else:
                         targets.append(StepInTarget(id=target_id, label=variant.name))
                     target_id_to_variant[target_id] = variant
@@ -1060,26 +1114,20 @@ def internal_get_step_in_targets_json(dbg, seq, thread_id, frame_id, request, se
         info.target_id_to_smart_step_into_variant = target_id_to_variant
 
         body = StepInTargetsResponseBody(targets=targets)
-        response = pydevd_base_schema.build_response(request, kwargs={'body': body})
+        response = pydevd_base_schema.build_response(request, kwargs={"body": body})
         cmd = NetCommand(CMD_RETURN, 0, response, is_json=True)
         dbg.writer.add_command(cmd)
     except Exception as e:
         # Error is expected (if `dis` module cannot be used -- i.e.: Jython).
-        pydev_log.exception('Error calculating Smart Step Into Variants.')
+        pydev_log.exception("Error calculating Smart Step Into Variants.")
         body = StepInTargetsResponseBody([])
-        variables_response = pydevd_base_schema.build_response(
-            request,
-            kwargs={
-                'body': body,
-                'success': False,
-                'message': str(e)
-            })
+        variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body, "success": False, "message": str(e)})
         cmd = NetCommand(CMD_RETURN, 0, variables_response, is_json=True)
         dbg.writer.add_command(cmd)
 
 
 def internal_get_next_statement_targets(dbg, seq, thread_id, frame_id):
-    ''' gets the valid line numbers for use with set next statement '''
+    """gets the valid line numbers for use with set next statement"""
     try:
         frame = dbg.find_frame(thread_id, frame_id)
         if frame is not None:
@@ -1105,18 +1153,17 @@ def internal_get_next_statement_targets(dbg, seq, thread_id, frame_id):
         dbg.writer.add_command(cmd)
 
 
-def _evaluate_response(py_db, request, result, error_message=''):
+def _evaluate_response(py_db, request, result, error_message=""):
     is_error = isinstance(result, ExceptionOnEvaluate)
     if is_error:
         result = result.result
     if not error_message:
         body = pydevd_schema.EvaluateResponseBody(result=result, variablesReference=0)
-        variables_response = pydevd_base_schema.build_response(request, kwargs={'body':body})
+        variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body})
         py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
     else:
         body = pydevd_schema.EvaluateResponseBody(result=result, variablesReference=0)
-        variables_response = pydevd_base_schema.build_response(request, kwargs={
-            'body':body, 'success':False, 'message': error_message})
+        variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body, "success": False, "message": error_message})
         py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
@@ -1124,9 +1171,9 @@ _global_frame = None
 
 
 def internal_evaluate_expression_json(py_db, request, thread_id):
-    '''
+    """
     :param EvaluateRequest request:
-    '''
+    """
     global _global_frame
     # : :type arguments: EvaluateArguments
 
@@ -1135,11 +1182,11 @@ def internal_evaluate_expression_json(py_db, request, thread_id):
     frame_id = arguments.frameId
     context = arguments.context
     fmt = arguments.format
-    if hasattr(fmt, 'to_dict'):
+    if hasattr(fmt, "to_dict"):
         fmt = fmt.to_dict()
 
     ctx = NULL
-    if context == 'repl':
+    if context == "repl":
         if not py_db.is_output_redirected:
             ctx = pydevd_io.redirect_stream_to_pydb_io_messages_context()
     else:
@@ -1166,14 +1213,16 @@ def internal_evaluate_expression_json(py_db, request, thread_id):
             eval_result = pydevd_vars.evaluate_expression(py_db, frame, expression, is_exec=False)
             is_error = isinstance_checked(eval_result, ExceptionOnEvaluate)
             if is_error:
-                if context == 'hover':  # In a hover it doesn't make sense to do an exec.
-                    _evaluate_response(py_db, request, result='', error_message='Exception occurred during evaluation.')
+                if context == "hover":  # In a hover it doesn't make sense to do an exec.
+                    _evaluate_response(py_db, request, result="", error_message="Exception occurred during evaluation.")
                     return
-                elif context == 'watch':
+                elif context == "watch":
                     # If it's a watch, don't show it as an exception object, rather, format
                     # it and show it as a string (with success=False).
-                    msg = '%s: %s' % (
-                        eval_result.result.__class__.__name__, eval_result.result,)
+                    msg = "%s: %s" % (
+                        eval_result.result.__class__.__name__,
+                        eval_result.result,
+                    )
                     _evaluate_response(py_db, request, result=msg, error_message=msg)
                     return
                 else:
@@ -1182,10 +1231,10 @@ def internal_evaluate_expression_json(py_db, request, thread_id):
                     try:
                         pydevd_vars.compile_as_eval(expression)
                     except Exception:
-                        try_exec = context == 'repl'
+                        try_exec = context == "repl"
                     else:
                         try_exec = False
-                        if context == 'repl':
+                        if context == "repl":
                             # In the repl we should show the exception to the user.
                             _evaluate_response_return_exception(py_db, request, eval_result.etype, eval_result.result, eval_result.tb)
                             return
@@ -1197,29 +1246,29 @@ def internal_evaluate_expression_json(py_db, request, thread_id):
                 _evaluate_response_return_exception(py_db, request, *sys.exc_info())
                 return
             # No result on exec.
-            _evaluate_response(py_db, request, result='')
+            _evaluate_response(py_db, request, result="")
             return
 
         # Ok, we have the result (could be an error), let's put it into the saved variables.
         frame_tracker = py_db.suspended_frames_manager.get_frame_tracker(thread_id)
         if frame_tracker is None:
             # This is not really expected.
-            _evaluate_response(py_db, request, result='', error_message='Thread id: %s is not current thread id.' % (thread_id,))
+            _evaluate_response(py_db, request, result="", error_message="Thread id: %s is not current thread id." % (thread_id,))
             return
 
         safe_repr_custom_attrs = {}
-        if context == 'clipboard':
+        if context == "clipboard":
             safe_repr_custom_attrs = dict(
-                maxstring_outer=2 ** 64,
-                maxstring_inner=2 ** 64,
-                maxother_outer=2 ** 64,
-                maxother_inner=2 ** 64,
+                maxstring_outer=2**64,
+                maxstring_inner=2**64,
+                maxother_outer=2**64,
+                maxother_inner=2**64,
             )
 
-        if context == 'repl' and eval_result is None:
+        if context == "repl" and eval_result is None:
             # We don't want "None" to appear when typing in the repl.
             body = pydevd_schema.EvaluateResponseBody(
-                result='',
+                result="",
                 variablesReference=0,
             )
 
@@ -1228,14 +1277,14 @@ def internal_evaluate_expression_json(py_db, request, thread_id):
             var_data = variable.get_var_data(fmt=fmt, context=context, **safe_repr_custom_attrs)
 
             body = pydevd_schema.EvaluateResponseBody(
-                result=var_data['value'],
-                variablesReference=var_data.get('variablesReference', 0),
-                type=var_data.get('type'),
-                presentationHint=var_data.get('presentationHint'),
-                namedVariables=var_data.get('namedVariables'),
-                indexedVariables=var_data.get('indexedVariables'),
+                result=var_data["value"],
+                variablesReference=var_data.get("variablesReference", 0),
+                type=var_data.get("type"),
+                presentationHint=var_data.get("presentationHint"),
+                namedVariables=var_data.get("namedVariables"),
+                indexedVariables=var_data.get("indexedVariables"),
             )
-        variables_response = pydevd_base_schema.build_response(request, kwargs={'body':body})
+        variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body})
         py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
@@ -1252,7 +1301,7 @@ def _evaluate_response_return_exception(py_db, request, exc_type, exc, initial_t
 
         if tb is None:
             tb = initial_tb
-        err = ''.join(traceback.format_exception(exc_type, exc, tb))
+        err = "".join(traceback.format_exception(exc_type, exc, tb))
 
         # Make sure we don't keep references to them.
         exc = None
@@ -1261,7 +1310,7 @@ def _evaluate_response_return_exception(py_db, request, exc_type, exc, initial_t
         temp_tb = None
         initial_tb = None
     except:
-        err = '<Internal error - unable to get traceback when evaluating expression>'
+        err = "<Internal error - unable to get traceback when evaluating expression>"
         pydev_log.exception(err)
 
     # Currently there is an issue in VSC where returning success=false for an
@@ -1272,7 +1321,7 @@ def _evaluate_response_return_exception(py_db, request, exc_type, exc, initial_t
 
 @silence_warnings_decorator
 def internal_evaluate_expression(dbg, seq, thread_id, frame_id, expression, is_exec, trim_if_too_big, attr_to_set_result):
-    ''' gets the value of a variable '''
+    """gets the value of a variable"""
     try:
         frame = dbg.find_frame(thread_id, frame_id)
         if frame is not None:
@@ -1294,9 +1343,8 @@ def internal_evaluate_expression(dbg, seq, thread_id, frame_id, expression, is_e
 
 
 def _set_expression_response(py_db, request, result, error_message):
-    body = pydevd_schema.SetExpressionResponseBody(result='', variablesReference=0)
-    variables_response = pydevd_base_schema.build_response(request, kwargs={
-        'body':body, 'success':False, 'message': error_message})
+    body = pydevd_schema.SetExpressionResponseBody(result="", variablesReference=0)
+    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body, "success": False, "message": error_message})
     py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
@@ -1308,23 +1356,23 @@ def internal_set_expression_json(py_db, request, thread_id):
     frame_id = arguments.frameId
     value = arguments.value
     fmt = arguments.format
-    if hasattr(fmt, 'to_dict'):
+    if hasattr(fmt, "to_dict"):
         fmt = fmt.to_dict()
 
     frame = py_db.find_frame(thread_id, frame_id)
-    exec_code = '%s = (%s)' % (expression, value)
+    exec_code = "%s = (%s)" % (expression, value)
     result = pydevd_vars.evaluate_expression(py_db, frame, exec_code, is_exec=True)
     is_error = isinstance(result, ExceptionOnEvaluate)
 
     if is_error:
-        _set_expression_response(py_db, request, result, error_message='Error executing: %s' % (exec_code,))
+        _set_expression_response(py_db, request, result, error_message="Error executing: %s" % (exec_code,))
         return
 
     # Ok, we have the result (could be an error), let's put it into the saved variables.
     frame_tracker = py_db.suspended_frames_manager.get_frame_tracker(thread_id)
     if frame_tracker is None:
         # This is not really expected.
-        _set_expression_response(py_db, request, result, error_message='Thread id: %s is not current thread id.' % (thread_id,))
+        _set_expression_response(py_db, request, result, error_message="Thread id: %s is not current thread id." % (thread_id,))
         return
 
     # Now that the exec is done, get the actual value changed to return.
@@ -1333,31 +1381,31 @@ def internal_set_expression_json(py_db, request, thread_id):
     var_data = variable.get_var_data(fmt=fmt)
 
     body = pydevd_schema.SetExpressionResponseBody(
-        value=var_data['value'],
-        variablesReference=var_data.get('variablesReference', 0),
-        type=var_data.get('type'),
-        presentationHint=var_data.get('presentationHint'),
-        namedVariables=var_data.get('namedVariables'),
-        indexedVariables=var_data.get('indexedVariables'),
+        value=var_data["value"],
+        variablesReference=var_data.get("variablesReference", 0),
+        type=var_data.get("type"),
+        presentationHint=var_data.get("presentationHint"),
+        namedVariables=var_data.get("namedVariables"),
+        indexedVariables=var_data.get("indexedVariables"),
     )
-    variables_response = pydevd_base_schema.build_response(request, kwargs={'body':body})
+    variables_response = pydevd_base_schema.build_response(request, kwargs={"body": body})
     py_db.writer.add_command(NetCommand(CMD_RETURN, 0, variables_response, is_json=True))
 
 
 def internal_get_completions(dbg, seq, thread_id, frame_id, act_tok, line=-1, column=-1):
-    '''
+    """
     Note that if the column is >= 0, the act_tok is considered text and the actual
     activation token/qualifier is computed in this command.
-    '''
+    """
     try:
         remove_path = None
         try:
-            qualifier = ''
+            qualifier = ""
             if column >= 0:
                 token_and_qualifier = extract_token_and_qualifier(act_tok, line, column)
                 act_tok = token_and_qualifier[0]
                 if act_tok:
-                    act_tok += '.'
+                    act_tok += "."
                 qualifier = token_and_qualifier[1]
 
             frame = dbg.find_frame(thread_id, frame_id)
@@ -1367,11 +1415,12 @@ def internal_get_completions(dbg, seq, thread_id, frame_id, act_tok, line=-1, co
                 # Note that qualifier and start are only actually valid for the
                 # Debug Adapter Protocol (for the line-based protocol, the IDE
                 # is required to filter the completions returned).
-                cmd = dbg.cmd_factory.make_get_completions_message(
-                    seq, completions, qualifier, start=column - len(qualifier))
+                cmd = dbg.cmd_factory.make_get_completions_message(seq, completions, qualifier, start=column - len(qualifier))
                 dbg.writer.add_command(cmd)
             else:
-                cmd = dbg.cmd_factory.make_error_message(seq, "internal_get_completions: Frame not found: %s from thread: %s" % (frame_id, thread_id))
+                cmd = dbg.cmd_factory.make_error_message(
+                    seq, "internal_get_completions: Frame not found: %s from thread: %s" % (frame_id, thread_id)
+                )
                 dbg.writer.add_command(cmd)
 
         finally:
@@ -1380,18 +1429,17 @@ def internal_get_completions(dbg, seq, thread_id, frame_id, act_tok, line=-1, co
 
     except:
         exc = get_exception_traceback_str()
-        sys.stderr.write('%s\n' % (exc,))
+        sys.stderr.write("%s\n" % (exc,))
         cmd = dbg.cmd_factory.make_error_message(seq, "Error evaluating expression " + exc)
         dbg.writer.add_command(cmd)
 
 
 def internal_get_description(dbg, seq, thread_id, frame_id, expression):
-    ''' Fetch the variable description stub from the debug console
-    '''
+    """Fetch the variable description stub from the debug console"""
     try:
         frame = dbg.find_frame(thread_id, frame_id)
         description = pydevd_console.get_description(frame, thread_id, frame_id, expression)
-        description = pydevd_xml.make_valid_xml_value(quote(description, '/>_= \t'))
+        description = pydevd_xml.make_valid_xml_value(quote(description, "/>_= \t"))
         description_xml = '<xml><var name="" type="" value="%s"/></xml>' % description
         cmd = dbg.cmd_factory.make_get_description_message(seq, description_xml)
         dbg.writer.add_command(cmd)
@@ -1402,15 +1450,15 @@ def internal_get_description(dbg, seq, thread_id, frame_id, expression):
 
 
 def build_exception_info_response(dbg, thread_id, thread, request_seq, set_additional_thread_info, iter_visible_frames_info, max_frames):
-    '''
+    """
     :return ExceptionInfoResponse
-    '''
+    """
     additional_info = set_additional_thread_info(thread)
     topmost_frame = additional_info.get_topmost_frame(thread)
 
-    current_paused_frame_name = ''
+    current_paused_frame_name = ""
 
-    source_path = ''  # This is an extra bit of data used by Visual Studio
+    source_path = ""  # This is an extra bit of data used by Visual Studio
     stack_str_lst = []
     name = None
     description = None
@@ -1446,19 +1494,27 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
                             except:
                                 pass
 
-                    for frame_id, frame, method_name, original_filename, filename_in_utf8, lineno, _applied_mapping, show_as_current_frame, line_col_info in \
-                        iter_visible_frames_info(dbg, frames_list):
-
+                    for (
+                        frame_id,
+                        frame,
+                        method_name,
+                        original_filename,
+                        filename_in_utf8,
+                        lineno,
+                        _applied_mapping,
+                        show_as_current_frame,
+                        line_col_info,
+                    ) in iter_visible_frames_info(dbg, frames_list):
                         line_text = linecache.getline(original_filename, lineno)
 
                         # Never filter out plugin frames!
-                        if not getattr(frame, 'IS_PLUGIN_FRAME', False):
+                        if not getattr(frame, "IS_PLUGIN_FRAME", False):
                             if dbg.is_files_filter_enabled and dbg.apply_files_filter(frame, original_filename, False):
                                 continue
 
                         if show_as_current_frame:
                             current_paused_frame_name = method_name
-                            method_name += ' (Current frame)'
+                            method_name += " (Current frame)"
                         frames.append((filename_in_utf8, lineno, method_name, line_text, line_col_info))
 
                     if not source_path and frames:
@@ -1474,11 +1530,11 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
                                 frame_summary.end_colno = line_col_info.end_colno
                             stack_summary.append(frame_summary)
 
-                        stack_str = ''.join(stack_summary.format())
+                        stack_str = "".join(stack_summary.format())
 
                     else:
                         # Note: remove col info (just used in 3.11).
-                        stack_str = ''.join(traceback.format_list((x[:-1] for x in frames[-max_frames:])))
+                        stack_str = "".join(traceback.format_list((x[:-1] for x in frames[-max_frames:])))
 
                     try:
                         stype = frames_list.exc_type.__qualname__
@@ -1486,12 +1542,12 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
                         if smod not in ("__main__", "builtins"):
                             if not isinstance(smod, str):
                                 smod = "<unknown>"
-                            stype = smod + '.' + stype
+                            stype = smod + "." + stype
                     except Exception:
-                        stype = '<unable to get exception type>'
-                        pydev_log.exception('Error getting exception type.')
+                        stype = "<unable to get exception type>"
+                        pydev_log.exception("Error getting exception type.")
 
-                    stack_str += '%s: %s\n' % (stype, frames_list.exc_desc)
+                    stack_str += "%s: %s\n" % (stype, frames_list.exc_desc)
                     stack_str += frames_list.exc_context_msg
                     stack_str_lst.append(stack_str)
 
@@ -1500,18 +1556,18 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
                         break
 
             except:
-                pydev_log.exception('Error on build_exception_info_response.')
+                pydev_log.exception("Error on build_exception_info_response.")
         finally:
             topmost_frame = None
-    full_stack_str = ''.join(reversed(stack_str_lst))
+    full_stack_str = "".join(reversed(stack_str_lst))
 
     if not name:
-        name = 'exception: type unknown'
+        name = "exception: type unknown"
     if not description:
-        description = 'exception: no description'
+        description = "exception: no description"
 
     if current_paused_frame_name:
-        name += '       (note: full exception trace is shown but execution is paused at: %s)' % (current_paused_frame_name,)
+        name += "       (note: full exception trace is shown but execution is paused at: %s)" % (current_paused_frame_name,)
 
     if thread.stop_reason == CMD_STEP_CAUGHT_EXCEPTION:
         break_mode = pydevd_schema.ExceptionBreakMode.ALWAYS
@@ -1521,7 +1577,7 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
     response = pydevd_schema.ExceptionInfoResponse(
         request_seq=request_seq,
         success=True,
-        command='exceptionInfo',
+        command="exceptionInfo",
         body=pydevd_schema.ExceptionInfoResponseBody(
             exceptionId=name,
             description=description,
@@ -1533,29 +1589,28 @@ def build_exception_info_response(dbg, thread_id, thread, request_seq, set_addit
                 source=source_path,
                 # Note: ExceptionDetails actually accepts an 'innerException', but
                 # when passing it, VSCode is not showing the stack trace at all.
-            )
-        )
+            ),
+        ),
     )
     return response
 
 
-def internal_get_exception_details_json(dbg, request, thread_id, thread, max_frames, set_additional_thread_info=None, iter_visible_frames_info=None):
-    ''' Fetch exception details
-    '''
+def internal_get_exception_details_json(
+    dbg, request, thread_id, thread, max_frames, set_additional_thread_info=None, iter_visible_frames_info=None
+):
+    """Fetch exception details"""
     try:
-        response = build_exception_info_response(dbg, thread_id, thread, request.seq, set_additional_thread_info, iter_visible_frames_info, max_frames)
+        response = build_exception_info_response(
+            dbg, thread_id, thread, request.seq, set_additional_thread_info, iter_visible_frames_info, max_frames
+        )
     except:
         exc = get_exception_traceback_str()
-        response = pydevd_base_schema.build_response(request, kwargs={
-            'success': False,
-            'message': exc,
-            'body':{}
-        })
+        response = pydevd_base_schema.build_response(request, kwargs={"success": False, "message": exc, "body": {}})
     dbg.writer.add_command(NetCommand(CMD_RETURN, 0, response, is_json=True))
 
 
 class InternalGetBreakpointException(InternalThreadCommand):
-    ''' Send details of exception raised while evaluating conditional breakpoint '''
+    """Send details of exception raised while evaluating conditional breakpoint"""
 
     def __init__(self, thread_id, exc_type, stacktrace):
         self.sequence = 0
@@ -1575,27 +1630,31 @@ class InternalGetBreakpointException(InternalThreadCommand):
                     # convert it to utf8
                     filename = filename.decode(file_system_encoding).encode("utf-8")
 
-                callstack += '<frame thread_id = "%s" file="%s" line="%s" name="%s" obj="%s" />' \
-                                    % (self.thread_id, makeValid(filename), line, makeValid(methodname), makeValid(methodobj))
+                callstack += '<frame thread_id = "%s" file="%s" line="%s" name="%s" obj="%s" />' % (
+                    self.thread_id,
+                    makeValid(filename),
+                    line,
+                    makeValid(methodname),
+                    makeValid(methodobj),
+                )
             callstack += "</xml>"
 
             cmd = dbg.cmd_factory.make_send_breakpoint_exception_message(self.sequence, self.exc_type + "\t" + callstack)
             dbg.writer.add_command(cmd)
         except:
             exc = get_exception_traceback_str()
-            sys.stderr.write('%s\n' % (exc,))
+            sys.stderr.write("%s\n" % (exc,))
             cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error Sending Exception: " + exc)
             dbg.writer.add_command(cmd)
 
 
 class InternalSendCurrExceptionTrace(InternalThreadCommand):
-    ''' Send details of the exception that was caught and where we've broken in.
-    '''
+    """Send details of the exception that was caught and where we've broken in."""
 
     def __init__(self, thread_id, arg, curr_frame_id):
-        '''
+        """
         :param arg: exception type, description, traceback object
-        '''
+        """
         self.sequence = 0
         self.thread_id = thread_id
         self.curr_frame_id = curr_frame_id
@@ -1608,14 +1667,13 @@ class InternalSendCurrExceptionTrace(InternalThreadCommand):
             dbg.writer.add_command(cmd)
         except:
             exc = get_exception_traceback_str()
-            sys.stderr.write('%s\n' % (exc,))
+            sys.stderr.write("%s\n" % (exc,))
             cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error Sending Current Exception Trace: " + exc)
             dbg.writer.add_command(cmd)
 
 
 class InternalSendCurrExceptionTraceProceeded(InternalThreadCommand):
-    ''' Send details of the exception that was caught and where we've broken in.
-    '''
+    """Send details of the exception that was caught and where we've broken in."""
 
     def __init__(self, thread_id):
         self.sequence = 0
@@ -1627,13 +1685,13 @@ class InternalSendCurrExceptionTraceProceeded(InternalThreadCommand):
             dbg.writer.add_command(cmd)
         except:
             exc = get_exception_traceback_str()
-            sys.stderr.write('%s\n' % (exc,))
+            sys.stderr.write("%s\n" % (exc,))
             cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error Sending Current Exception Trace Proceeded: " + exc)
             dbg.writer.add_command(cmd)
 
 
 class InternalEvaluateConsoleExpression(InternalThreadCommand):
-    ''' Execute the given command in the debug console '''
+    """Execute the given command in the debug console"""
 
     def __init__(self, seq, thread_id, frame_id, line, buffer_output=True):
         self.sequence = seq
@@ -1643,22 +1701,24 @@ class InternalEvaluateConsoleExpression(InternalThreadCommand):
         self.buffer_output = buffer_output
 
     def do_it(self, dbg):
-        ''' Create an XML for console output, error and more (true/false)
+        """Create an XML for console output, error and more (true/false)
         <xml>
             <output message=output_message></output>
             <error message=error_message></error>
             <more>true/false</more>
         </xml>
-        '''
+        """
         try:
             frame = dbg.find_frame(self.thread_id, self.frame_id)
             if frame is not None:
                 console_message = pydevd_console.execute_console_command(
-                    frame, self.thread_id, self.frame_id, self.line, self.buffer_output)
+                    frame, self.thread_id, self.frame_id, self.line, self.buffer_output
+                )
 
                 cmd = dbg.cmd_factory.make_send_console_message(self.sequence, console_message.to_xml())
             else:
                 from _pydevd_bundle.pydevd_console import ConsoleMessage
+
                 console_message = ConsoleMessage()
                 console_message.add_console_message(
                     pydevd_console.CONSOLE_ERROR,
@@ -1672,8 +1732,7 @@ class InternalEvaluateConsoleExpression(InternalThreadCommand):
 
 
 class InternalRunCustomOperation(InternalThreadCommand):
-    ''' Run a custom command on an expression
-    '''
+    """Run a custom command on an expression"""
 
     def __init__(self, seq, thread_id, frame_id, scope, attrs, style, encoded_code_or_file, fnname):
         self.sequence = seq
@@ -1687,8 +1746,9 @@ class InternalRunCustomOperation(InternalThreadCommand):
 
     def do_it(self, dbg):
         try:
-            res = pydevd_vars.custom_operation(dbg, self.thread_id, self.frame_id, self.scope, self.attrs,
-                                              self.style, self.code_or_file, self.fnname)
+            res = pydevd_vars.custom_operation(
+                dbg, self.thread_id, self.frame_id, self.scope, self.attrs, self.style, self.code_or_file, self.fnname
+            )
             resEncoded = quote_plus(res)
             cmd = dbg.cmd_factory.make_custom_operation_message(self.sequence, resEncoded)
             dbg.writer.add_command(cmd)
@@ -1699,8 +1759,7 @@ class InternalRunCustomOperation(InternalThreadCommand):
 
 
 class InternalConsoleGetCompletions(InternalThreadCommand):
-    ''' Fetch the completions in the debug console
-    '''
+    """Fetch the completions in the debug console"""
 
     def __init__(self, seq, thread_id, frame_id, act_tok):
         self.sequence = seq
@@ -1709,8 +1768,7 @@ class InternalConsoleGetCompletions(InternalThreadCommand):
         self.act_tok = act_tok
 
     def do_it(self, dbg):
-        ''' Get completions and write back to the client
-        '''
+        """Get completions and write back to the client"""
         try:
             frame = dbg.find_frame(self.thread_id, self.frame_id)
             completions_xml = pydevd_console.get_completions(frame, self.act_tok)
@@ -1723,7 +1781,7 @@ class InternalConsoleGetCompletions(InternalThreadCommand):
 
 
 class InternalConsoleExec(InternalThreadCommand):
-    ''' gets the value of a variable '''
+    """gets the value of a variable"""
 
     def __init__(self, seq, thread_id, frame_id, expression):
         self.sequence = seq
@@ -1731,24 +1789,40 @@ class InternalConsoleExec(InternalThreadCommand):
         self.frame_id = frame_id
         self.expression = expression
 
-    def do_it(self, dbg):
-        ''' Converts request into python variable '''
+    def init_matplotlib_in_debug_console(self, py_db):
+        # import hook and patches for matplotlib support in debug console
+        from _pydev_bundle.pydev_import_hook import import_hook_manager
+
+        if is_current_thread_main_thread():
+            for module in list(py_db.mpl_modules_for_patching):
+                import_hook_manager.add_module_name(module, py_db.mpl_modules_for_patching.pop(module))
+
+    def do_it(self, py_db):
+        if not py_db.mpl_hooks_in_debug_console and not py_db.gui_in_use:
+            # add import hooks for matplotlib patches if only debug console was started
+            try:
+                self.init_matplotlib_in_debug_console(py_db)
+                py_db.gui_in_use = True
+            except:
+                pydev_log.debug("Matplotlib support in debug console failed", traceback.format_exc())
+            py_db.mpl_hooks_in_debug_console = True
+
         try:
             try:
-                # don't trace new threads created by console command
+                # Don't trace new threads created by console command.
                 disable_trace_thread_modules()
 
-                result = pydevconsole.console_exec(self.thread_id, self.frame_id, self.expression, dbg)
+                result = pydevconsole.console_exec(self.thread_id, self.frame_id, self.expression, py_db)
                 xml = "<xml>"
                 xml += pydevd_xml.var_to_xml(result, "")
                 xml += "</xml>"
-                cmd = dbg.cmd_factory.make_evaluate_expression_message(self.sequence, xml)
-                dbg.writer.add_command(cmd)
+                cmd = py_db.cmd_factory.make_evaluate_expression_message(self.sequence, xml)
+                py_db.writer.add_command(cmd)
             except:
                 exc = get_exception_traceback_str()
-                sys.stderr.write('%s\n' % (exc,))
-                cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error evaluating console expression " + exc)
-                dbg.writer.add_command(cmd)
+                sys.stderr.write("%s\n" % (exc,))
+                cmd = py_db.cmd_factory.make_error_message(self.sequence, "Error evaluating console expression " + exc)
+                py_db.writer.add_command(cmd)
         finally:
             enable_trace_thread_modules()
 
@@ -1757,9 +1831,9 @@ class InternalConsoleExec(InternalThreadCommand):
 
 
 class InternalLoadFullValue(InternalThreadCommand):
-    '''
+    """
     Loads values asynchronously
-    '''
+    """
 
     def __init__(self, seq, thread_id, frame_id, vars):
         self.sequence = seq
@@ -1769,14 +1843,14 @@ class InternalLoadFullValue(InternalThreadCommand):
 
     @silence_warnings_decorator
     def do_it(self, dbg):
-        '''Starts a thread that will load values asynchronously'''
+        """Starts a thread that will load values asynchronously"""
         try:
             var_objects = []
             for variable in self.vars:
                 variable = variable.strip()
                 if len(variable) > 0:
-                    if '\t' in variable:  # there are attributes beyond scope
-                        scope, attrs = variable.split('\t', 1)
+                    if "\t" in variable:  # there are attributes beyond scope
+                        scope, attrs = variable.split("\t", 1)
                         name = attrs[0]
                     else:
                         scope, attrs = (variable, None)
@@ -1788,22 +1862,22 @@ class InternalLoadFullValue(InternalThreadCommand):
             t.start()
         except:
             exc = get_exception_traceback_str()
-            sys.stderr.write('%s\n' % (exc,))
+            sys.stderr.write("%s\n" % (exc,))
             cmd = dbg.cmd_factory.make_error_message(self.sequence, "Error evaluating variable %s " % exc)
             dbg.writer.add_command(cmd)
 
 
 class AbstractGetValueAsyncThread(PyDBDaemonThread):
-    '''
+    """
     Abstract class for a thread, which evaluates values for async variables
-    '''
+    """
 
     def __init__(self, py_db, frame_accessor, seq, var_objects):
         PyDBDaemonThread.__init__(self, py_db)
         self.frame_accessor = frame_accessor
         self.seq = seq
         self.var_objs = var_objects
-        self.cancel_event = threading.Event()
+        self.cancel_event = ThreadingEvent()
 
     def send_result(self, xml):
         raise NotImplementedError()
@@ -1813,7 +1887,7 @@ class AbstractGetValueAsyncThread(PyDBDaemonThread):
         start = time.time()
         xml = StringIO()
         xml.write("<xml>")
-        for (var_obj, name) in self.var_objs:
+        for var_obj, name in self.var_objs:
             current_time = time.time()
             if current_time - start > ASYNC_EVAL_TIMEOUT_SEC or self.cancel_event.is_set():
                 break
@@ -1824,10 +1898,10 @@ class AbstractGetValueAsyncThread(PyDBDaemonThread):
 
 
 class GetValueAsyncThreadDebug(AbstractGetValueAsyncThread):
-    '''
+    """
     A thread for evaluation async values, which returns result for debugger
     Create message and send it via writer thread
-    '''
+    """
 
     def send_result(self, xml):
         if self.frame_accessor is not None:
@@ -1836,12 +1910,11 @@ class GetValueAsyncThreadDebug(AbstractGetValueAsyncThread):
 
 
 class GetValueAsyncThreadConsole(AbstractGetValueAsyncThread):
-    '''
+    """
     A thread for evaluation async values, which returns result for Console
     Send result directly to Console's server
-    '''
+    """
 
     def send_result(self, xml):
         if self.frame_accessor is not None:
             self.frame_accessor.ReturnFullValue(self.seq, xml.getvalue())
-