debugpy 1.8.5__zip → 1.8.7__zip

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

@@ -4,21 +4,46 @@ import os
 import sys
 import socket as socket_module
 
-from _pydev_bundle._pydev_imports_tipper import TYPE_IMPORT, TYPE_CLASS, TYPE_FUNCTION, TYPE_ATTR, \
-    TYPE_BUILTIN, TYPE_PARAM
+from _pydev_bundle._pydev_imports_tipper import TYPE_IMPORT, TYPE_CLASS, TYPE_FUNCTION, TYPE_ATTR, TYPE_BUILTIN, TYPE_PARAM
 from _pydev_bundle.pydev_is_thread_alive import is_thread_alive
 from _pydev_bundle.pydev_override import overrides
 from _pydevd_bundle._debug_adapter import pydevd_schema
-from _pydevd_bundle._debug_adapter.pydevd_schema import ModuleEvent, ModuleEventBody, Module, \
-    OutputEventBody, OutputEvent, ContinuedEventBody, ExitedEventBody, \
-    ExitedEvent
-from _pydevd_bundle.pydevd_comm_constants import CMD_THREAD_CREATE, CMD_RETURN, CMD_MODULE_EVENT, \
-    CMD_WRITE_TO_CONSOLE, CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, \
-    CMD_STEP_RETURN, CMD_STEP_CAUGHT_EXCEPTION, CMD_ADD_EXCEPTION_BREAK, CMD_SET_BREAK, \
-    CMD_SET_NEXT_STATEMENT, CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION, \
-    CMD_THREAD_RESUME_SINGLE_NOTIFICATION, CMD_THREAD_KILL, CMD_STOP_ON_START, CMD_INPUT_REQUESTED, \
-    CMD_EXIT, CMD_STEP_INTO_COROUTINE, CMD_STEP_RETURN_MY_CODE, CMD_SMART_STEP_INTO, \
-    CMD_SET_FUNCTION_BREAK
+from _pydevd_bundle._debug_adapter.pydevd_schema import (
+    ModuleEvent,
+    ModuleEventBody,
+    Module,
+    OutputEventBody,
+    OutputEvent,
+    ContinuedEventBody,
+    ExitedEventBody,
+    ExitedEvent,
+)
+from _pydevd_bundle.pydevd_comm_constants import (
+    CMD_THREAD_CREATE,
+    CMD_RETURN,
+    CMD_MODULE_EVENT,
+    CMD_WRITE_TO_CONSOLE,
+    CMD_STEP_INTO,
+    CMD_STEP_INTO_MY_CODE,
+    CMD_STEP_OVER,
+    CMD_STEP_OVER_MY_CODE,
+    CMD_STEP_RETURN,
+    CMD_STEP_CAUGHT_EXCEPTION,
+    CMD_ADD_EXCEPTION_BREAK,
+    CMD_SET_BREAK,
+    CMD_SET_NEXT_STATEMENT,
+    CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION,
+    CMD_THREAD_RESUME_SINGLE_NOTIFICATION,
+    CMD_THREAD_KILL,
+    CMD_STOP_ON_START,
+    CMD_INPUT_REQUESTED,
+    CMD_EXIT,
+    CMD_STEP_INTO_COROUTINE,
+    CMD_STEP_RETURN_MY_CODE,
+    CMD_SMART_STEP_INTO,
+    CMD_SET_FUNCTION_BREAK,
+    CMD_THREAD_RUN,
+)
 from _pydevd_bundle.pydevd_constants import get_thread_id, ForkSafeLock, DebugInfoHolder
 from _pydevd_bundle.pydevd_net_command import NetCommand, NULL_NET_COMMAND
 from _pydevd_bundle.pydevd_net_command_factory_xml import NetCommandFactory
@@ -33,17 +58,16 @@ from _pydev_bundle import pydev_log
 
 
 class ModulesManager(object):
-
     def __init__(self):
         self._lock = ForkSafeLock()
         self._modules = {}
         self._next_id = partial(next, itertools.count(0))
 
     def track_module(self, filename_in_utf8, module_name, frame):
-        '''
+        """
         :return list(NetCommand):
             Returns a list with the module events to be sent.
-        '''
+        """
         if filename_in_utf8 in self._modules:
             return []
 
@@ -54,14 +78,14 @@ class ModulesManager(object):
                 return
 
             try:
-                version = str(frame.f_globals.get('__version__', ''))
+                version = str(frame.f_globals.get("__version__", ""))
             except:
-                version = '<unknown>'
+                version = "<unknown>"
 
             try:
-                package_name = str(frame.f_globals.get('__package__', ''))
+                package_name = str(frame.f_globals.get("__package__", ""))
             except:
-                package_name = '<unknown>'
+                package_name = "<unknown>"
 
             module_id = self._next_id()
 
@@ -71,9 +95,9 @@ class ModulesManager(object):
 
             if package_name:
                 # Note: package doesn't appear in the docs but seems to be expected?
-                module.kwargs['package'] = package_name
+                module.kwargs["package"] = package_name
 
-            module_event = ModuleEvent(ModuleEventBody('new', module))
+            module_event = ModuleEvent(ModuleEventBody("new", module))
 
             module_events.append(NetCommand(CMD_MODULE_EVENT, 0, module_event, is_json=True))
 
@@ -81,15 +105,15 @@ class ModulesManager(object):
         return module_events
 
     def get_modules_info(self):
-        '''
+        """
         :return list(Module)
-        '''
+        """
         with self._lock:
             return list(self._modules.values())
 
 
 class NetCommandFactoryJson(NetCommandFactory):
-    '''
+    """
     Factory for commands which will provide messages as json (they should be
     similar to the debug adapter where possible, although some differences
     are currently Ok).
@@ -98,7 +122,7 @@ class NetCommandFactoryJson(NetCommandFactory):
     can be done one at a time (any message not overridden will currently
     use the xml version) -- after having all messages handled, it should
     no longer use NetCommandFactory as the base class.
-    '''
+    """
 
     def __init__(self):
         NetCommandFactory.__init__(self)
@@ -114,11 +138,10 @@ class NetCommandFactoryJson(NetCommandFactory):
 
     @overrides(NetCommandFactory.make_thread_created_message)
     def make_thread_created_message(self, thread):
-
         # Note: the thread id for the debug adapter must be an int
         # (make the actual id from get_thread_id respect that later on).
         msg = pydevd_schema.ThreadEvent(
-            pydevd_schema.ThreadEventBody('started', get_thread_id(thread)),
+            pydevd_schema.ThreadEventBody("started", get_thread_id(thread)),
         )
 
         return NetCommand(CMD_THREAD_CREATE, 0, msg, is_json=True)
@@ -127,7 +150,7 @@ class NetCommandFactoryJson(NetCommandFactory):
     def make_custom_frame_created_message(self, frame_id, frame_description):
         self._additional_thread_id_to_thread_name[frame_id] = frame_description
         msg = pydevd_schema.ThreadEvent(
-            pydevd_schema.ThreadEventBody('started', frame_id),
+            pydevd_schema.ThreadEventBody("started", frame_id),
         )
 
         return NetCommand(CMD_THREAD_CREATE, 0, msg, is_json=True)
@@ -136,7 +159,7 @@ class NetCommandFactoryJson(NetCommandFactory):
     def make_thread_killed_message(self, tid):
         self._additional_thread_id_to_thread_name.pop(tid, None)
         msg = pydevd_schema.ThreadEvent(
-            pydevd_schema.ThreadEventBody('exited', tid),
+            pydevd_schema.ThreadEventBody("exited", tid),
         )
 
         return NetCommand(CMD_THREAD_KILL, 0, msg, is_json=True)
@@ -159,8 +182,7 @@ class NetCommandFactoryJson(NetCommandFactory):
             threads.append(thread_schema.to_dict())
 
         body = pydevd_schema.ThreadsResponseBody(threads)
-        response = pydevd_schema.ThreadsResponse(
-            request_seq=seq, success=True, command='threads', body=body)
+        response = pydevd_schema.ThreadsResponse(request_seq=seq, success=True, command="threads", body=body)
 
         return NetCommand(CMD_RETURN, 0, response, is_json=True)
 
@@ -182,34 +204,34 @@ class NetCommandFactoryJson(NetCommandFactory):
             label = completion[0]
             if label.lower().startswith(qualifier):
                 completion = pydevd_schema.CompletionItem(
-                    label=label, type=COMPLETION_TYPE_LOOK_UP[completion[3]], start=start, length=qualifier_len)
+                    label=label, type=COMPLETION_TYPE_LOOK_UP[completion[3]], start=start, length=qualifier_len
+                )
                 targets.append(completion.to_dict())
 
         body = pydevd_schema.CompletionsResponseBody(targets)
-        response = pydevd_schema.CompletionsResponse(
-            request_seq=seq, success=True, command='completions', body=body)
+        response = pydevd_schema.CompletionsResponse(request_seq=seq, success=True, command="completions", body=body)
         return NetCommand(CMD_RETURN, 0, response, is_json=True)
 
     def _format_frame_name(self, fmt, initial_name, module_name, line, path):
         if fmt is None:
             return initial_name
         frame_name = initial_name
-        if fmt.get('module', False):
+        if fmt.get("module", False):
             if module_name:
-                if initial_name == '<module>':
+                if initial_name == "<module>":
                     frame_name = module_name
                 else:
-                    frame_name = '%s.%s' % (module_name, initial_name)
+                    frame_name = "%s.%s" % (module_name, initial_name)
             else:
                 basename = os.path.basename(path)
-                basename = basename[0:-3] if basename.lower().endswith('.py') else basename
-                if initial_name == '<module>':
-                    frame_name = '%s in %s' % (initial_name, basename)
+                basename = basename[0:-3] if basename.lower().endswith(".py") else basename
+                if initial_name == "<module>":
+                    frame_name = "%s in %s" % (initial_name, basename)
                 else:
-                    frame_name = '%s.%s' % (basename, initial_name)
+                    frame_name = "%s.%s" % (basename, initial_name)
 
-        if fmt.get('line', False):
-            frame_name = '%s : %d' % (frame_name, line)
+        if fmt.get("line", False):
+            frame_name = "%s : %d" % (frame_name, line)
 
         return frame_name
 
@@ -229,32 +251,39 @@ class NetCommandFactoryJson(NetCommandFactory):
                 else:
                     frames_list = pydevd_frame_utils.create_frames_list_from_frame(topmost_frame)
 
-            for frame_id, frame, method_name, original_filename, filename_in_utf8, lineno, applied_mapping, show_as_current_frame, line_col_info in self._iter_visible_frames_info(
-                    py_db, frames_list, flatten_chained=True
-                ):
-
+            for (
+                frame_id,
+                frame,
+                method_name,
+                original_filename,
+                filename_in_utf8,
+                lineno,
+                applied_mapping,
+                show_as_current_frame,
+                line_col_info,
+            ) in self._iter_visible_frames_info(py_db, frames_list, flatten_chained=True):
                 try:
-                    module_name = str(frame.f_globals.get('__name__', ''))
+                    module_name = str(frame.f_globals.get("__name__", ""))
                 except:
-                    module_name = '<unknown>'
+                    module_name = "<unknown>"
 
                 module_events.extend(self.modules_manager.track_module(filename_in_utf8, module_name, frame))
 
                 presentation_hint = None
-                if not getattr(frame, 'IS_PLUGIN_FRAME', False):  # Never filter out plugin frames!
+                if not getattr(frame, "IS_PLUGIN_FRAME", False):  # Never filter out plugin frames!
                     if py_db.is_files_filter_enabled and py_db.apply_files_filter(frame, original_filename, False):
                         continue
 
                     if not py_db.in_project_scope(frame):
-                        presentation_hint = 'subtle'
+                        presentation_hint = "subtle"
 
                 formatted_name = self._format_frame_name(fmt, method_name, module_name, lineno, filename_in_utf8)
                 if show_as_current_frame:
-                    formatted_name += ' (Current frame)'
+                    formatted_name += " (Current frame)"
                 source_reference = pydevd_file_utils.get_client_filename_source_reference(filename_in_utf8)
 
                 if not source_reference and not applied_mapping and not os.path.exists(original_filename):
-                    if getattr(frame.f_code, 'co_lines', None) or getattr(frame.f_code, 'co_lnotab', None):
+                    if getattr(frame.f_code, "co_lines", None) or getattr(frame.f_code, "co_lnotab", None):
                         # Create a source-reference to be used where we provide the source by decompiling the code.
                         # Note: When the time comes to retrieve the source reference in this case, we'll
                         # check the linecache first (see: get_decompiled_source_from_frame_id).
@@ -262,8 +291,7 @@ class NetCommandFactoryJson(NetCommandFactory):
                     else:
                         # Check if someone added a source reference to the linecache (Python attrs does this).
                         if linecache.getline(original_filename, 1):
-                            source_reference = pydevd_file_utils.create_source_reference_for_linecache(
-                                original_filename)
+                            source_reference = pydevd_file_utils.create_source_reference_for_linecache(original_filename)
 
                 column = 1
                 endcol = None
@@ -272,7 +300,7 @@ class NetCommandFactoryJson(NetCommandFactory):
                         line_text = linecache.getline(original_filename, lineno)
                     except:
                         if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 2:
-                            pydev_log.exception('Unable to get line from linecache for file: %s', original_filename)
+                            pydev_log.exception("Unable to get line from linecache for file: %s", original_filename)
                     else:
                         if line_text:
                             colno, endcolno = line_col_info.map_columns_to_line(line_text)
@@ -280,12 +308,20 @@ class NetCommandFactoryJson(NetCommandFactory):
                             if line_col_info.lineno == line_col_info.end_lineno:
                                 endcol = endcolno + 1
 
-                frames.append(pydevd_schema.StackFrame(
-                    frame_id, formatted_name, lineno, column=column, endColumn=endcol, source={
-                        'path': filename_in_utf8,
-                        'sourceReference': source_reference,
-                    },
-                    presentationHint=presentation_hint).to_dict())
+                frames.append(
+                    pydevd_schema.StackFrame(
+                        frame_id,
+                        formatted_name,
+                        lineno,
+                        column=column,
+                        endColumn=endcol,
+                        source={
+                            "path": filename_in_utf8,
+                            "sourceReference": source_reference,
+                        },
+                        presentationHint=presentation_hint,
+                    ).to_dict()
+                )
         finally:
             topmost_frame = None
 
@@ -302,47 +338,52 @@ class NetCommandFactoryJson(NetCommandFactory):
         response = pydevd_schema.StackTraceResponse(
             request_seq=seq,
             success=True,
-            command='stackTrace',
-            body=pydevd_schema.StackTraceResponseBody(stackFrames=stack_frames, totalFrames=total_frames))
+            command="stackTrace",
+            body=pydevd_schema.StackTraceResponseBody(stackFrames=stack_frames, totalFrames=total_frames),
+        )
         return NetCommand(CMD_RETURN, 0, response, is_json=True)
 
     @overrides(NetCommandFactory.make_warning_message)
     def make_warning_message(self, msg):
-        category = 'important'
+        category = "important"
         body = OutputEventBody(msg, category)
         event = OutputEvent(body)
         return NetCommand(CMD_WRITE_TO_CONSOLE, 0, event, is_json=True)
 
     @overrides(NetCommandFactory.make_io_message)
     def make_io_message(self, msg, ctx):
-        category = 'stdout' if int(ctx) == 1 else 'stderr'
+        category = "stdout" if int(ctx) == 1 else "stderr"
         body = OutputEventBody(msg, category)
         event = OutputEvent(body)
         return NetCommand(CMD_WRITE_TO_CONSOLE, 0, event, is_json=True)
 
     @overrides(NetCommandFactory.make_console_message)
     def make_console_message(self, msg):
-        category = 'console'
+        category = "console"
         body = OutputEventBody(msg, category)
         event = OutputEvent(body)
         return NetCommand(CMD_WRITE_TO_CONSOLE, 0, event, is_json=True)
 
-    _STEP_REASONS = set([
-        CMD_STEP_INTO,
-        CMD_STEP_INTO_MY_CODE,
-        CMD_STEP_OVER,
-        CMD_STEP_OVER_MY_CODE,
-        CMD_STEP_RETURN,
-        CMD_STEP_RETURN_MY_CODE,
-        CMD_STEP_INTO_MY_CODE,
-        CMD_STOP_ON_START,
-        CMD_STEP_INTO_COROUTINE,
-        CMD_SMART_STEP_INTO,
-    ])
-    _EXCEPTION_REASONS = set([
-        CMD_STEP_CAUGHT_EXCEPTION,
-        CMD_ADD_EXCEPTION_BREAK,
-    ])
+    _STEP_REASONS = set(
+        [
+            CMD_STEP_INTO,
+            CMD_STEP_INTO_MY_CODE,
+            CMD_STEP_OVER,
+            CMD_STEP_OVER_MY_CODE,
+            CMD_STEP_RETURN,
+            CMD_STEP_RETURN_MY_CODE,
+            CMD_STEP_INTO_MY_CODE,
+            CMD_STOP_ON_START,
+            CMD_STEP_INTO_COROUTINE,
+            CMD_SMART_STEP_INTO,
+        ]
+    )
+    _EXCEPTION_REASONS = set(
+        [
+            CMD_STEP_CAUGHT_EXCEPTION,
+            CMD_ADD_EXCEPTION_BREAK,
+        ]
+    )
 
     @overrides(NetCommandFactory.make_thread_suspend_single_notification)
     def make_thread_suspend_single_notification(self, py_db, thread_id, thread, stop_reason):
@@ -353,27 +394,27 @@ class NetCommandFactoryJson(NetCommandFactory):
         preserve_focus_hint = False
         if stop_reason in self._STEP_REASONS:
             if info.pydev_original_step_cmd == CMD_STOP_ON_START:
-
                 # Just to make sure that's not set as the original reason anymore.
                 info.pydev_original_step_cmd = -1
-                stop_reason = 'entry'
+                stop_reason = "entry"
             else:
-                stop_reason = 'step'
+                stop_reason = "step"
         elif stop_reason in self._EXCEPTION_REASONS:
-            stop_reason = 'exception'
+            stop_reason = "exception"
         elif stop_reason == CMD_SET_BREAK:
-            stop_reason = 'breakpoint'
+            stop_reason = "breakpoint"
         elif stop_reason == CMD_SET_FUNCTION_BREAK:
-            stop_reason = 'function breakpoint'
+            stop_reason = "function breakpoint"
         elif stop_reason == CMD_SET_NEXT_STATEMENT:
-            stop_reason = 'goto'
+            stop_reason = "goto"
         else:
-            stop_reason = 'pause'
+            stop_reason = "pause"
             preserve_focus_hint = True
 
-        if stop_reason == 'exception':
+        if stop_reason == "exception":
             exception_info_response = build_exception_info_response(
-                py_db, thread_id, thread, -1, set_additional_thread_info, self._iter_visible_frames_info, max_frames=-1)
+                py_db, thread_id, thread, -1, set_additional_thread_info, self._iter_visible_frames_info, max_frames=-1
+            )
             exception_info_response
 
             exc_name = exception_info_response.body.exceptionId
@@ -399,11 +440,8 @@ class NetCommandFactoryJson(NetCommandFactory):
     @overrides(NetCommandFactory.make_set_next_stmnt_status_message)
     def make_set_next_stmnt_status_message(self, seq, is_success, exception_msg):
         response = pydevd_schema.GotoResponse(
-            request_seq=int(seq),
-            success=is_success,
-            command='goto',
-            body={},
-            message=(None if is_success else exception_msg))
+            request_seq=int(seq), success=is_success, command="goto", body={}, message=(None if is_success else exception_msg)
+        )
         return NetCommand(CMD_RETURN, 0, response, is_json=True)
 
     @overrides(NetCommandFactory.make_send_curr_exception_trace_message)
@@ -435,12 +473,63 @@ class NetCommandFactoryJson(NetCommandFactory):
         return cmd
 
     @overrides(NetCommandFactory.make_thread_suspend_message)
-    def make_thread_suspend_message(self, *args, **kwargs):
-        return NULL_NET_COMMAND  # Not a part of the debug adapter protocol
+    def make_thread_suspend_message(self, py_db, thread_id, frames_list, stop_reason, message, trace_suspend_type, thread, info):
+        from _pydevd_bundle.pydevd_comm_constants import CMD_THREAD_SUSPEND
+
+        if py_db.multi_threads_single_notification:
+            pydev_log.debug("Skipping per-thread thread suspend notification.")
+            return NULL_NET_COMMAND  # Don't send per-thread, send a single one.
+        pydev_log.debug("Sending per-thread thread suspend notification (stop_reason: %s)", stop_reason)
+
+        exc_desc = None
+        exc_name = None
+        preserve_focus_hint = False
+        if stop_reason in self._STEP_REASONS:
+            if info.pydev_original_step_cmd == CMD_STOP_ON_START:
+                # Just to make sure that's not set as the original reason anymore.
+                info.pydev_original_step_cmd = -1
+                stop_reason = "entry"
+            else:
+                stop_reason = "step"
+        elif stop_reason in self._EXCEPTION_REASONS:
+            stop_reason = "exception"
+        elif stop_reason == CMD_SET_BREAK:
+            stop_reason = "breakpoint"
+        elif stop_reason == CMD_SET_FUNCTION_BREAK:
+            stop_reason = "function breakpoint"
+        elif stop_reason == CMD_SET_NEXT_STATEMENT:
+            stop_reason = "goto"
+        else:
+            stop_reason = "pause"
+            preserve_focus_hint = True
+
+        if stop_reason == "exception":
+            exception_info_response = build_exception_info_response(
+                py_db, thread_id, thread, -1, set_additional_thread_info, self._iter_visible_frames_info, max_frames=-1
+            )
+            exception_info_response
+
+            exc_name = exception_info_response.body.exceptionId
+            exc_desc = exception_info_response.body.description
+
+        body = pydevd_schema.StoppedEventBody(
+            reason=stop_reason,
+            description=exc_desc,
+            threadId=thread_id,
+            text=exc_name,
+            allThreadsStopped=False,
+            preserveFocusHint=preserve_focus_hint,
+        )
+        event = pydevd_schema.StoppedEvent(body)
+        return NetCommand(CMD_THREAD_SUSPEND, 0, event, is_json=True)
 
     @overrides(NetCommandFactory.make_thread_run_message)
-    def make_thread_run_message(self, *args, **kwargs):
-        return NULL_NET_COMMAND  # Not a part of the debug adapter protocol
+    def make_thread_run_message(self, py_db, thread_id, reason):
+        if py_db.multi_threads_single_notification:
+            return NULL_NET_COMMAND  # Don't send per-thread, send a single one.
+        body = ContinuedEventBody(threadId=thread_id, allThreadsContinued=False)
+        event = pydevd_schema.ContinuedEvent(body)
+        return NetCommand(CMD_THREAD_RUN, 0, event, is_json=True)
 
     @overrides(NetCommandFactory.make_reloaded_code_message)
     def make_reloaded_code_message(self, *args, **kwargs):
@@ -453,15 +542,17 @@ class NetCommandFactoryJson(NetCommandFactory):
 
     @overrides(NetCommandFactory.make_skipped_step_in_because_of_filters)
     def make_skipped_step_in_because_of_filters(self, py_db, frame):
-        msg = 'Frame skipped from debugging during step-in.'
+        msg = "Frame skipped from debugging during step-in."
         if py_db.get_use_libraries_filter():
-            msg += ('\nNote: may have been skipped because of "justMyCode" option (default == true). '
-                    'Try setting \"justMyCode\": false in the debug configuration (e.g., launch.json).\n')
+            msg += (
+                '\nNote: may have been skipped because of "justMyCode" option (default == true). '
+                'Try setting "justMyCode": false in the debug configuration (e.g., launch.json).\n'
+            )
         return self.make_warning_message(msg)
 
     @overrides(NetCommandFactory.make_evaluation_timeout_msg)
     def make_evaluation_timeout_msg(self, py_db, expression, curr_thread):
-        msg = '''Evaluating: %s did not finish after %.2f seconds.
+        msg = """Evaluating: %s did not finish after %.2f seconds.
 This may mean a number of things:
 - This evaluation is really slow and this is expected.
     In this case it's possible to silence this error by raising the timeout, setting the
@@ -481,12 +572,12 @@ This may mean a number of things:
     environment variable to true so that a thread dump is shown along with this message and
     optionally, set the PYDEVD_INTERRUPT_THREAD_TIMEOUT to some value so that the debugger
     tries to interrupt the evaluation (if possible) when this happens.
-''' % (expression, pydevd_constants.PYDEVD_WARN_EVALUATION_TIMEOUT)
+""" % (expression, pydevd_constants.PYDEVD_WARN_EVALUATION_TIMEOUT)
 
         if pydevd_constants.PYDEVD_THREAD_DUMP_ON_WARN_EVALUATION_TIMEOUT:
             stream = StringIO()
             pydevd_utils.dump_threads(stream, show_pydevd_threads=False)
-            msg += '\n\n%s\n' % stream.getvalue()
+            msg += "\n\n%s\n" % stream.getvalue()
         return self.make_warning_message(msg)
 
     @overrides(NetCommandFactory.make_exit_command)