debugpy 1.8.5__zip → 1.8.7__zip

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

@@ -1,8 +1,7 @@
 from contextlib import contextmanager
 import sys
 
-from _pydevd_bundle.pydevd_constants import get_frame, RETURN_VALUES_DICT, \
-    ForkSafeLock, GENERATED_LEN_ATTR_NAME, silence_warnings_decorator
+from _pydevd_bundle.pydevd_constants import get_frame, RETURN_VALUES_DICT, ForkSafeLock, GENERATED_LEN_ATTR_NAME, silence_warnings_decorator
 from _pydevd_bundle.pydevd_xml import get_variable_details, get_type
 from _pydev_bundle.pydev_override import overrides
 from _pydevd_bundle.pydevd_resolver import sorted_attributes_key, TOO_LARGE_ATTR, get_var_scope
@@ -16,7 +15,6 @@ from typing import Optional
 
 
 class _AbstractVariable(object):
-
     # Default attributes in class, set in instance.
 
     name = None
@@ -36,8 +34,8 @@ class _AbstractVariable(object):
     def get_variable_reference(self):
         return id(self.value)
 
-    def get_var_data(self, fmt: Optional[dict]=None, context: Optional[str]=None, **safe_repr_custom_attrs):
-        '''
+    def get_var_data(self, fmt: Optional[dict] = None, context: Optional[str] = None, **safe_repr_custom_attrs):
+        """
         :param dict fmt:
             Format expected by the DAP (keys: 'hex': bool, 'rawString': bool)
 
@@ -47,58 +45,59 @@ class _AbstractVariable(object):
                 "repl",
                 "hover",
                 "clipboard"
-        '''
+        """
         timer = Timer()
         safe_repr = SafeRepr()
         if fmt is not None:
-            safe_repr.convert_to_hex = fmt.get('hex', False)
-            safe_repr.raw_value = fmt.get('rawString', False)
+            safe_repr.convert_to_hex = fmt.get("hex", False)
+            safe_repr.raw_value = fmt.get("rawString", False)
         for key, val in safe_repr_custom_attrs.items():
             setattr(safe_repr, key, val)
 
         type_name, _type_qualifier, _is_exception_on_eval, resolver, value = get_variable_details(
-            self.value, to_string=safe_repr, context=context)
+            self.value, to_string=safe_repr, context=context
+        )
 
-        is_raw_string = type_name in ('str', 'bytes', 'bytearray')
+        is_raw_string = type_name in ("str", "bytes", "bytearray")
 
         attributes = []
 
         if is_raw_string:
-            attributes.append('rawString')
+            attributes.append("rawString")
 
         name = self.name
 
         if self._is_return_value:
-            attributes.append('readOnly')
-            name = '(return) %s' % (name,)
+            attributes.append("readOnly")
+            name = "(return) %s" % (name,)
 
         elif name in (TOO_LARGE_ATTR, GENERATED_LEN_ATTR_NAME):
-            attributes.append('readOnly')
+            attributes.append("readOnly")
 
         try:
             if self.value.__class__ == DAPGrouper:
-                type_name = ''
+                type_name = ""
         except:
             pass  # Ignore errors accessing __class__.
 
         var_data = {
-            'name': name,
-            'value': value,
-            'type': type_name,
+            "name": name,
+            "value": value,
+            "type": type_name,
         }
 
         if self.evaluate_name is not None:
-            var_data['evaluateName'] = self.evaluate_name
+            var_data["evaluateName"] = self.evaluate_name
 
         if resolver is not None:  # I.e.: it's a container
-            var_data['variablesReference'] = self.get_variable_reference()
+            var_data["variablesReference"] = self.get_variable_reference()
         else:
-            var_data['variablesReference'] = 0  # It's mandatory (although if == 0 it doesn't have children).
+            var_data["variablesReference"] = 0  # It's mandatory (although if == 0 it doesn't have children).
 
         if len(attributes) > 0:
-            var_data['presentationHint'] = {'attributes': attributes}
+            var_data["presentationHint"] = {"attributes": attributes}
 
-        timer.report_if_compute_repr_attr_slow('', name, type_name)
+        timer.report_if_compute_repr_attr_slow("", name, type_name)
         return var_data
 
     def get_children_variables(self, fmt=None, scope=None):
@@ -126,10 +125,10 @@ class _AbstractVariable(object):
                 entry = (attr_name, attr_value, evaluate_name)
                 if scope:
                     presentation = get_presentation(scope)
-                    if presentation == 'hide':
+                    if presentation == "hide":
                         continue
 
-                    elif presentation == 'inline':
+                    elif presentation == "inline":
                         new_lst.append(entry)
 
                     else:  # group
@@ -153,7 +152,6 @@ class _AbstractVariable(object):
 
 
 class _ObjectVariable(_AbstractVariable):
-
     def __init__(self, py_db, name, value, register_variable, is_return_value=False, evaluate_name=None, frame=None):
         _AbstractVariable.__init__(self, py_db)
         self.frame = frame
@@ -171,7 +169,7 @@ class _ObjectVariable(_AbstractVariable):
 
         children_variables = []
         if resolver is not None:  # i.e.: it's a container.
-            if hasattr(resolver, 'get_contents_debug_adapter_protocol'):
+            if hasattr(resolver, "get_contents_debug_adapter_protocol"):
                 # The get_contents_debug_adapter_protocol needs to return sorted.
                 lst = resolver.get_contents_debug_adapter_protocol(self.value, fmt=fmt)
             else:
@@ -192,8 +190,7 @@ class _ObjectVariable(_AbstractVariable):
                             evaluate_name = evaluate_name(parent_evaluate_name)
                         else:
                             evaluate_name = parent_evaluate_name + evaluate_name
-                    variable = _ObjectVariable(
-                        self.py_db, key, val, self._register_variable, evaluate_name=evaluate_name, frame=self.frame)
+                    variable = _ObjectVariable(self.py_db, key, val, self._register_variable, evaluate_name=evaluate_name, frame=self.frame)
                     children_variables.append(variable)
             else:
                 for key, val, evaluate_name in lst:
@@ -204,13 +201,12 @@ class _ObjectVariable(_AbstractVariable):
         return children_variables
 
     def change_variable(self, name, value, py_db, fmt=None):
-
         children_variable = self.get_child_variable_named(name)
         if children_variable is None:
             return None
 
         var_data = children_variable.get_var_data()
-        evaluate_name = var_data.get('evaluateName')
+        evaluate_name = var_data.get("evaluateName")
 
         if not evaluate_name:
             # Note: right now we only pass control to the resolver in the cases where
@@ -218,15 +214,14 @@ class _ObjectVariable(_AbstractVariable):
             # we can use that evaluation to set the value too -- if in the future
             # a case where this isn't true is found this logic may need to be changed).
             _type, _type_name, container_resolver = get_type(self.value)
-            if hasattr(container_resolver, 'change_var_from_name'):
+            if hasattr(container_resolver, "change_var_from_name"):
                 try:
                     new_value = eval(value)
                 except:
                     return None
                 new_key = container_resolver.change_var_from_name(self.value, name, new_value)
                 if new_key is not None:
-                    return _ObjectVariable(
-                        self.py_db, new_key, new_value, self._register_variable, evaluate_name=None, frame=self.frame)
+                    return _ObjectVariable(self.py_db, new_key, new_value, self._register_variable, evaluate_name=None, frame=self.frame)
 
                 return None
             else:
@@ -238,7 +233,7 @@ class _ObjectVariable(_AbstractVariable):
 
         try:
             # This handles the simple cases (such as dict, list, object)
-            Exec('%s=%s' % (evaluate_name, value), frame.f_globals, frame.f_locals)
+            Exec("%s=%s" % (evaluate_name, value), frame.f_globals, frame.f_locals)
         except:
             return None
 
@@ -250,7 +245,6 @@ def sorted_variables_key(obj):
 
 
 class _FrameVariable(_AbstractVariable):
-
     def __init__(self, py_db, frame, register_variable):
         _AbstractVariable.__init__(self, py_db)
         self.frame = frame
@@ -276,19 +270,21 @@ class _FrameVariable(_AbstractVariable):
             assert isinstance(scope, ScopeRequest)
             scope = scope.scope
 
-        if scope in ('locals', None):
+        if scope in ("locals", None):
             dct = self.frame.f_locals
-        elif scope == 'globals':
+        elif scope == "globals":
             dct = self.frame.f_globals
         else:
-            raise AssertionError('Unexpected scope: %s' % (scope,))
+            raise AssertionError("Unexpected scope: %s" % (scope,))
 
-        lst, group_entries = self._group_entries([(x[0], x[1], None) for x in list(dct.items()) if x[0] != '_pydev_stop_at_break'], handle_return_values=True)
+        lst, group_entries = self._group_entries(
+            [(x[0], x[1], None) for x in list(dct.items()) if x[0] != "_pydev_stop_at_break"], handle_return_values=True
+        )
         group_variables = []
 
         for key, val, _ in group_entries:
             # Make sure that the contents in the group are also sorted.
-            val.contents_debug_adapter_protocol.sort(key=lambda v:sorted_attributes_key(v[0]))
+            val.contents_debug_adapter_protocol.sort(key=lambda v: sorted_attributes_key(v[0]))
             variable = _ObjectVariable(self.py_db, key, val, self._register_variable, False, key, frame=self.frame)
             group_variables.append(variable)
 
@@ -297,7 +293,14 @@ class _FrameVariable(_AbstractVariable):
             if is_return_value:
                 for return_key, return_value in val.items():
                     variable = _ObjectVariable(
-                        self.py_db, return_key, return_value, self._register_variable, is_return_value, '%s[%r]' % (key, return_key), frame=self.frame)
+                        self.py_db,
+                        return_key,
+                        return_value,
+                        self._register_variable,
+                        is_return_value,
+                        "%s[%r]" % (key, return_key),
+                        frame=self.frame,
+                    )
                     children_variables.append(variable)
             else:
                 variable = _ObjectVariable(self.py_db, key, val, self._register_variable, is_return_value, key, frame=self.frame)
@@ -313,9 +316,9 @@ class _FrameVariable(_AbstractVariable):
 
 
 class _FramesTracker(object):
-    '''
+    """
     This is a helper class to be used to track frames when a thread becomes suspended.
-    '''
+    """
 
     def __init__(self, suspended_frames_manager, py_db):
         self._suspended_frames_manager = suspended_frames_manager
@@ -342,7 +345,7 @@ class _FramesTracker(object):
         self._untracked = False
 
         # We need to be thread-safe!
-        self._lock = ForkSafeLock()
+        self._lock = ForkSafeLock(rlock=True)
 
         self._variable_reference_to_variable = {}
 
@@ -361,7 +364,8 @@ class _FramesTracker(object):
 
         # Still not created, let's do it now.
         return _ObjectVariable(
-            self.py_db, name, value, self._register_variable, is_return_value=False, evaluate_name=evaluate_name, frame=frame)
+            self.py_db, name, value, self._register_variable, is_return_value=False, evaluate_name=evaluate_name, frame=frame
+        )
 
     def get_main_thread_id(self):
         return self._main_thread_id
@@ -370,7 +374,7 @@ class _FramesTracker(object):
         return self._variable_reference_to_variable[variable_reference]
 
     def track(self, thread_id, frames_list, frame_custom_thread_id=None):
-        '''
+        """
         :param thread_id:
             The thread id to be used for this frame.
 
@@ -379,19 +383,18 @@ class _FramesTracker(object):
 
         :param frame_custom_thread_id:
             If None this this is the id of the thread id for the custom frame (i.e.: coroutine).
-        '''
+        """
         assert frames_list.__class__ == FramesList
         with self._lock:
             coroutine_or_main_thread_id = frame_custom_thread_id or thread_id
 
             if coroutine_or_main_thread_id in self._suspended_frames_manager._thread_id_to_tracker:
-                sys.stderr.write('pydevd: Something is wrong. Tracker being added twice to the same thread id.\n')
+                sys.stderr.write("pydevd: Something is wrong. Tracker being added twice to the same thread id.\n")
 
             self._suspended_frames_manager._thread_id_to_tracker[coroutine_or_main_thread_id] = self
             self._main_thread_id = thread_id
 
-            frame_ids_from_thread = self._thread_id_to_frame_ids.setdefault(
-                coroutine_or_main_thread_id, [])
+            frame_ids_from_thread = self._thread_id_to_frame_ids.setdefault(coroutine_or_main_thread_id, [])
 
             self._thread_id_to_frames_list[coroutine_or_main_thread_id] = frames_list
             for frame in frames_list:
@@ -433,20 +436,20 @@ class _FramesTracker(object):
         with self._lock:
             return self._frame_id_to_frame.get(frame_id)
 
-    def create_thread_suspend_command(self, thread_id, stop_reason, message, suspend_type):
+    def create_thread_suspend_command(self, thread_id, stop_reason, message, trace_suspend_type, thread, additional_info):
         with self._lock:
             # First one is topmost frame suspended.
             frames_list = self._thread_id_to_frames_list[thread_id]
 
             cmd = self.py_db.cmd_factory.make_thread_suspend_message(
-                self.py_db, thread_id, frames_list, stop_reason, message, suspend_type)
+                self.py_db, thread_id, frames_list, stop_reason, message, trace_suspend_type, thread, additional_info
+            )
 
             frames_list = None
             return cmd
 
 
 class SuspendedFramesManager(object):
-
     def __init__(self):
         self._thread_id_to_fake_frames = {}
         self._thread_id_to_tracker = {}
@@ -470,7 +473,7 @@ class SuspendedFramesManager(object):
         return None
 
     def get_thread_id_for_variable_reference(self, variable_reference):
-        '''
+        """
         We can't evaluate variable references values on any thread, only in the suspended
         thread (the main reason for this is that in UI frameworks inspecting a UI object
         from a different thread can potentially crash the application).
@@ -482,7 +485,7 @@ class SuspendedFramesManager(object):
         :return str:
             The thread id for the thread to be used to inspect the given variable reference or
             None if the thread was already resumed.
-        '''
+        """
         frames_tracker = self._get_tracker_for_variable_reference(variable_reference)
         if frames_tracker is not None:
             return frames_tracker.get_main_thread_id()
@@ -492,9 +495,9 @@ class SuspendedFramesManager(object):
         return self._thread_id_to_tracker.get(thread_id)
 
     def get_variable(self, variable_reference):
-        '''
+        """
         :raises KeyError
-        '''
+        """
         frames_tracker = self._get_tracker_for_variable_reference(variable_reference)
         if frames_tracker is None:
             raise KeyError()

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

@@ -1,9 +1,11 @@
 from _pydevd_bundle import pydevd_utils
 from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info
 from _pydevd_bundle.pydevd_comm_constants import CMD_STEP_INTO, CMD_THREAD_SUSPEND
-from _pydevd_bundle.pydevd_constants import PYTHON_SUSPEND, STATE_SUSPEND, get_thread_id, STATE_RUN
+from _pydevd_bundle.pydevd_constants import PYTHON_SUSPEND, STATE_SUSPEND, get_thread_id, STATE_RUN, PYDEVD_USE_SYS_MONITORING
 from _pydev_bundle._pydev_saved_modules import threading
 from _pydev_bundle import pydev_log
+import sys
+from _pydevd_sys_monitoring import pydevd_sys_monitoring
 
 
 def pydevd_find_thread_by_id(thread_id):
@@ -11,7 +13,7 @@ def pydevd_find_thread_by_id(thread_id):
         threads = threading.enumerate()
         for i in threads:
             tid = get_thread_id(i)
-            if thread_id == tid or thread_id.endswith('|' + tid):
+            if thread_id == tid or thread_id.endswith("|" + tid):
                 return i
 
         # This can happen when a request comes for a thread which was previously removed.
@@ -23,7 +25,7 @@ def pydevd_find_thread_by_id(thread_id):
     return None
 
 
-def mark_thread_suspended(thread, stop_reason, original_step_cmd=-1):
+def mark_thread_suspended(thread, stop_reason: int, original_step_cmd: int = -1):
     info = set_additional_thread_info(thread)
     info.suspend_type = PYTHON_SUSPEND
     if original_step_cmd != -1:
@@ -40,7 +42,7 @@ def mark_thread_suspended(thread, stop_reason, original_step_cmd=-1):
 
     # Mark as suspended as the last thing.
     info.pydev_state = STATE_SUSPEND
-
+    info.update_stepping_info()
     return info
 
 
@@ -50,15 +52,16 @@ def internal_run_thread(thread, set_additional_thread_info):
     info.pydev_step_cmd = -1
     info.pydev_step_stop = None
     info.pydev_state = STATE_RUN
+    info.update_stepping_info()
 
 
 def resume_threads(thread_id, except_thread=None):
-    pydev_log.info('Resuming threads: %s (except thread: %s)', thread_id, except_thread)
+    pydev_log.info("Resuming threads: %s (except thread: %s)", thread_id, except_thread)
     threads = []
-    if thread_id == '*':
+    if thread_id == "*":
         threads = pydevd_utils.get_non_pydevd_threads()
 
-    elif thread_id.startswith('__frame__:'):
+    elif thread_id.startswith("__frame__:"):
         pydev_log.critical("Can't make tasklet run: %s", thread_id)
 
     else:
@@ -66,21 +69,24 @@ def resume_threads(thread_id, except_thread=None):
 
     for t in threads:
         if t is None or t is except_thread:
-            pydev_log.info('Skipped resuming thread: %s', t)
+            pydev_log.info("Skipped resuming thread: %s", t)
             continue
 
         internal_run_thread(t, set_additional_thread_info=set_additional_thread_info)
 
 
 def suspend_all_threads(py_db, except_thread):
-    '''
+    """
     Suspend all except the one passed as a parameter.
     :param except_thread:
-    '''
-    pydev_log.info('Suspending all threads except: %s', except_thread)
+    """
+    if PYDEVD_USE_SYS_MONITORING:
+        pydevd_sys_monitoring.update_monitor_events(suspend_requested=True)
+
+    pydev_log.info("Suspending all threads except: %s", except_thread)
     all_threads = pydevd_utils.get_non_pydevd_threads()
     for t in all_threads:
-        if getattr(t, 'pydev_do_not_trace', None):
+        if getattr(t, "pydev_do_not_trace", None):
             pass  # skip some other threads, i.e. ipython history saving thread from debug console
         else:
             if t is except_thread:
@@ -91,6 +97,10 @@ def suspend_all_threads(py_db, except_thread):
             # Reset the tracing as in this case as it could've set scopes to be untraced.
             if frame is not None:
                 try:
-                    py_db.set_trace_for_frame_and_parents(frame)
+                    py_db.set_trace_for_frame_and_parents(t.ident, frame)
                 finally:
                     frame = None
+
+    if PYDEVD_USE_SYS_MONITORING:
+        # After suspending the frames we need the monitoring to be reset.
+        pydevd_sys_monitoring.restart_events()

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

@@ -1,4 +1,4 @@
-from _pydev_bundle._pydev_saved_modules import threading
+from _pydev_bundle._pydev_saved_modules import ThreadingEvent, ThreadingLock, threading_current_thread
 from _pydevd_bundle.pydevd_daemon_thread import PyDBDaemonThread
 from _pydevd_bundle.pydevd_constants import thread_get_ident, IS_CPYTHON, NULL
 import ctypes
@@ -12,7 +12,7 @@ _DEBUG = False  # Default should be False as this can be very verbose.
 
 
 class _TimeoutThread(PyDBDaemonThread):
-    '''
+    """
     The idea in this class is that it should be usually stopped waiting
     for the next event to be called (paused in a threading.Event.wait).
 
@@ -20,26 +20,26 @@ class _TimeoutThread(PyDBDaemonThread):
     then keeps on waiting as needed again.
 
     This is done so that it's a bit more optimized than creating many Timer threads.
-    '''
+    """
 
     def __init__(self, py_db):
         PyDBDaemonThread.__init__(self, py_db)
-        self._event = threading.Event()
+        self._event = ThreadingEvent()
         self._handles = []
 
         # We could probably do things valid without this lock so that it's possible to add
         # handles while processing, but the implementation would also be harder to follow,
         # so, for now, we're either processing or adding handles, not both at the same time.
-        self._lock = threading.Lock()
+        self._lock = ThreadingLock()
 
     def _on_run(self):
         wait_time = None
         while not self._kill_received:
             if _DEBUG:
                 if wait_time is None:
-                    pydev_log.critical('pydevd_timeout: Wait until a new handle is added.')
+                    pydev_log.critical("pydevd_timeout: Wait until a new handle is added.")
                 else:
-                    pydev_log.critical('pydevd_timeout: Next wait time: %s.', wait_time)
+                    pydev_log.critical("pydevd_timeout: Next wait time: %s.", wait_time)
             self._event.wait(wait_time)
 
             if self._kill_received:
@@ -49,13 +49,13 @@ class _TimeoutThread(PyDBDaemonThread):
             wait_time = self.process_handles()
 
     def process_handles(self):
-        '''
+        """
         :return int:
             Returns the time we should be waiting for to process the next event properly.
-        '''
+        """
         with self._lock:
             if _DEBUG:
-                pydev_log.critical('pydevd_timeout: Processing handles')
+                pydev_log.critical("pydevd_timeout: Processing handles")
             self._event.clear()
             handles = self._handles
             new_handles = self._handles = []
@@ -71,7 +71,7 @@ class _TimeoutThread(PyDBDaemonThread):
                 if curtime < handle.abs_timeout and not handle.disposed:
                     # It still didn't time out.
                     if _DEBUG:
-                        pydev_log.critical('pydevd_timeout: Handle NOT processed: %s', handle)
+                        pydev_log.critical("pydevd_timeout: Handle NOT processed: %s", handle)
                     new_handles.append(handle)
                     if min_handle_timeout is None:
                         min_handle_timeout = handle.abs_timeout
@@ -81,7 +81,7 @@ class _TimeoutThread(PyDBDaemonThread):
 
                 else:
                     if _DEBUG:
-                        pydev_log.critical('pydevd_timeout: Handle processed: %s', handle)
+                        pydev_log.critical("pydevd_timeout: Handle processed: %s", handle)
                     # Timed out (or disposed), so, let's execute it (should be no-op if disposed).
                     handle.exec_on_timeout()
 
@@ -90,7 +90,7 @@ class _TimeoutThread(PyDBDaemonThread):
             else:
                 timeout = min_handle_timeout - curtime
                 if timeout <= 0:
-                    pydev_log.critical('pydevd_timeout: Expected timeout to be > 0. Found: %s', timeout)
+                    pydev_log.critical("pydevd_timeout: Expected timeout to be > 0. Found: %s", timeout)
 
                 return timeout
 
@@ -106,9 +106,8 @@ class _TimeoutThread(PyDBDaemonThread):
 
 
 class _OnTimeoutHandle(object):
-
     def __init__(self, tracker, abs_timeout, on_timeout, kwargs):
-        self._str = '_OnTimeoutHandle(%s)' % (on_timeout,)
+        self._str = "_OnTimeoutHandle(%s)" % (on_timeout,)
 
         self._tracker = weakref.ref(tracker)
         self.abs_timeout = abs_timeout
@@ -130,11 +129,11 @@ class _OnTimeoutHandle(object):
 
             try:
                 if _DEBUG:
-                    pydev_log.critical('pydevd_timeout: Calling on timeout: %s with kwargs: %s', on_timeout, kwargs)
+                    pydev_log.critical("pydevd_timeout: Calling on timeout: %s with kwargs: %s", on_timeout, kwargs)
 
                 on_timeout(**kwargs)
             except Exception:
-                pydev_log.exception('pydevd_timeout: Exception on callback timeout.')
+                pydev_log.exception("pydevd_timeout: Exception on callback timeout.")
 
     def __enter__(self):
         pass
@@ -159,17 +158,17 @@ class _OnTimeoutHandle(object):
 
 
 class TimeoutTracker(object):
-    '''
+    """
     This is a helper class to track the timeout of something.
-    '''
+    """
 
     def __init__(self, py_db):
         self._thread = None
-        self._lock = threading.Lock()
+        self._lock = ThreadingLock()
         self._py_db = weakref.ref(py_db)
 
     def call_on_timeout(self, timeout, on_timeout, kwargs=None):
-        '''
+        """
         This can be called regularly to always execute the given function after a given timeout:
 
         call_on_timeout(py_db, 10, on_timeout)
@@ -182,11 +181,11 @@ class TimeoutTracker(object):
             ...
 
         Note: the callback will be called from a PyDBDaemonThread.
-        '''
+        """
         with self._lock:
             if self._thread is None:
                 if _DEBUG:
-                    pydev_log.critical('pydevd_timeout: Created _TimeoutThread.')
+                    pydev_log.critical("pydevd_timeout: Created _TimeoutThread.")
 
                 self._thread = _TimeoutThread(self._py_db())
                 self._thread.start()
@@ -194,13 +193,13 @@ class TimeoutTracker(object):
             curtime = time.time()
             handle = _OnTimeoutHandle(self, curtime + timeout, on_timeout, kwargs)
             if _DEBUG:
-                pydev_log.critical('pydevd_timeout: Added handle: %s.', handle)
+                pydev_log.critical("pydevd_timeout: Added handle: %s.", handle)
             self._thread.add_on_timeout_handle(handle)
             return handle
 
 
 def create_interrupt_this_thread_callback():
-    '''
+    """
     The idea here is returning a callback that when called will generate a KeyboardInterrupt
     in the thread that called this function.
 
@@ -214,26 +213,25 @@ def create_interrupt_this_thread_callback():
     :return callable:
         Returns a callback that will interrupt the current thread (this may be called
         from an auxiliary thread).
-    '''
+    """
     tid = thread_get_ident()
 
     if is_current_thread_main_thread():
-        main_thread = threading.current_thread()
+        main_thread = threading_current_thread()
 
         def raise_on_this_thread():
-            pydev_log.debug('Callback to interrupt main thread.')
+            pydev_log.debug("Callback to interrupt main thread.")
             pydevd_utils.interrupt_main_thread(main_thread)
 
     else:
-
         # Note: this works in the sense that it can stop some cpu-intensive slow operation,
         # but we can't really interrupt the thread out of some sleep or I/O operation
         # (this will only be raised when Python is about to execute the next instruction).
         def raise_on_this_thread():
             if IS_CPYTHON:
-                pydev_log.debug('Interrupt thread: %s', tid)
+                pydev_log.debug("Interrupt thread: %s", tid)
                 ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), ctypes.py_object(KeyboardInterrupt))
             else:
-                pydev_log.debug('It is only possible to interrupt non-main threads in CPython.')
+                pydev_log.debug("It is only possible to interrupt non-main threads in CPython.")
 
     return raise_on_this_thread