pydevd-pycharm 251.23774.123__tar.gz → 251.23774.354__tar.gz

{pydevd_pycharm-251.23774.123/pydevd_pycharm.egg-info → pydevd_pycharm-251.23774.354}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydevd-pycharm
-Version: 251.23774.123
+Version: 251.23774.354
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others

pydevd_pycharm-251.23774.354/VERSION

@@ -0,0 +1 @@
+251.23774.354

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydev_bundle/pydev_monkey.py

@@ -14,7 +14,7 @@ except:
     xrange = range
 
 
-PYTHON_NAMES = ['python', 'jython', 'pypy']
+PYTHON_NAMES = ['python', 'jython', 'pypy', "python3"]
 
 #===============================================================================
 # Things that are dependent on having the pydevd debugger
@@ -440,12 +440,12 @@ def warn_bytes_args():
 
 def create_warn_multiproc(original_name):
 
-    def new_warn_multiproc(*args):
+    def new_warn_multiproc(*args, **kwargs):
         import os
 
         warn_multiproc()
 
-        result = getattr(os, original_name)(*args)
+        result = getattr(os, original_name)(*args, **kwargs)
 
         if original_name == _ORIGINAL_PREFIX + 'fork':
             pid = result

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_additional_thread_info_regular.py

@@ -7,7 +7,7 @@ from _pydev_bundle import pydev_log
 from _pydevd_bundle.pydevd_frame import PyDBFrame
 # ENDIF
 
-version = 52
+version = 54
 
 if not hasattr(sys, '_current_frames'):
 

pydevd_pycharm-251.23774.354/_pydevd_bundle/pydevd_bytecode_utils.py

@@ -0,0 +1,95 @@
+"""Bytecode analyzing utils."""
+
+from _pydevd_bundle.smart_step_into import get_stepping_variants
+from _pydevd_bundle.pydevd_constants import IS_PY311_OR_GREATER, IS_PY39_OR_GREATER
+import dis
+
+
+def find_last_func_call_order(frame, start_line):
+    """Find the call order of the last function call between ``start_line``
+    and last executed instruction.
+
+    :param frame: A frame inside which we are looking for the function call.
+    :type frame: :py:class:`types.FrameType`
+    :param start_line:
+    :return: call order or -1 if we fail to find the call order for some
+      reason.
+    :rtype: int
+    """
+    code = frame.f_code
+    lasti = frame.f_lasti
+    cache = {}
+    call_order = -1
+
+    def process_instructions(order, start_offset=None, end_offset=None, find_reraise=False):
+        """Processes instructions within the given bytecode offsets."""
+        stepping_generator = get_stepping_variants(code)
+        for inst in stepping_generator:
+            if end_offset is not None and inst.offset > end_offset:
+                if not find_reraise:
+                    break
+                else:
+                    for forward in get_stepping_variants(code):
+                        if forward.lineno > frame.f_lineno:
+                            break
+                        cache_for_reraise = cache.copy()
+                        name = forward.argval
+                        call_order_reraise = cache_for_reraise.setdefault(name, -1)
+                        call_order_reraise += 1
+                        cache_for_reraise[name] = call_order_reraise
+                        if name == "RERAISE":
+                            order = call_order_reraise
+                            break
+                    break
+
+            if start_offset is not None and inst.offset < start_offset:
+                continue
+            if start_line <= inst.lineno <= frame.f_lineno:
+                name = inst.argval
+                order = cache.setdefault(name, -1)
+                order += 1
+                cache[name] = order
+        return order
+
+    if IS_PY311_OR_GREATER:
+        exception_table = dis._parse_exception_table(code)
+        if exception_table:
+            for i, entry in enumerate(exception_table):
+                if entry.start < lasti < entry.end:
+                    target_entry = None
+                    for next_entry in exception_table[i + 1:]:
+                        if next_entry.start == entry.target:
+                            target_entry = next_entry
+                            break
+                    if target_entry is not None:
+                        call_order = process_instructions(call_order, target_entry.start, target_entry.end)
+                        break
+            else:
+                call_order = process_instructions(call_order, None, lasti)
+        else:
+            call_order = process_instructions(call_order, None, lasti)
+    elif IS_PY39_OR_GREATER:
+        call_order = process_instructions(call_order, None, lasti, find_reraise=True)
+    else:
+        call_order = process_instructions(call_order, None, lasti)
+
+    return call_order
+
+
+def find_last_call_name(frame):
+    """Find the name of the last call made in the frame.
+
+    :param frame: A frame inside which we are looking the last call.
+    :type frame: :py:class:`types.FrameType`
+    :return: The name of a function or method that has been called last.
+    :rtype: str
+    """
+    last_call_name = None
+    code = frame.f_code
+    last_instruction = frame.f_lasti
+    for inst in get_stepping_variants(code):
+        if inst.offset > last_instruction:
+            break
+        last_call_name = inst.argval
+
+    return last_call_name

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_comm.py

@@ -148,7 +148,7 @@ from _pydevd_bundle.pydevd_comm_constants import (
 MAX_IO_MSG_SIZE = 1000  #if the io is too big, we'll not send all (could make the debugger too non-responsive)
 #this number can be changed if there's need to do so
 
-VERSION_STRING = "251.23774.123"
+VERSION_STRING = "251.23774.354"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()
@@ -546,8 +546,10 @@ class NetCommand:
         as_bytes = self._as_bytes
         if self.protocol == self.HTTP_PROTOCOL:
             sock.sendall(('Content-Length: %s\r\n\r\n' % len(as_bytes)).encode('ascii'))
-
-        sock.sendall(as_bytes)
+        try:
+            sock.sendall(as_bytes)
+        except BrokenPipeError:
+            print("Connection closed unexpectedly!")
 
     @classmethod
     def _show_debug_info(cls, cmd_id, seq, text):

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_cython.c

@@ -3618,7 +3618,7 @@ typedef struct {
   PyObject *__pyx_n_s_writer;
   PyObject *__pyx_int_0;
   PyObject *__pyx_int_1;
-  PyObject *__pyx_int_52;
+  PyObject *__pyx_int_54;
   PyObject *__pyx_int_160;
   PyObject *__pyx_int_18997755;
   PyObject *__pyx_int_19394913;
@@ -4161,7 +4161,7 @@ static int __pyx_m_clear(PyObject *m) {
   Py_CLEAR(clear_module_state->__pyx_n_s_writer);
   Py_CLEAR(clear_module_state->__pyx_int_0);
   Py_CLEAR(clear_module_state->__pyx_int_1);
-  Py_CLEAR(clear_module_state->__pyx_int_52);
+  Py_CLEAR(clear_module_state->__pyx_int_54);
   Py_CLEAR(clear_module_state->__pyx_int_160);
   Py_CLEAR(clear_module_state->__pyx_int_18997755);
   Py_CLEAR(clear_module_state->__pyx_int_19394913);
@@ -4682,7 +4682,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
   Py_VISIT(traverse_module_state->__pyx_n_s_writer);
   Py_VISIT(traverse_module_state->__pyx_int_0);
   Py_VISIT(traverse_module_state->__pyx_int_1);
-  Py_VISIT(traverse_module_state->__pyx_int_52);
+  Py_VISIT(traverse_module_state->__pyx_int_54);
   Py_VISIT(traverse_module_state->__pyx_int_160);
   Py_VISIT(traverse_module_state->__pyx_int_18997755);
   Py_VISIT(traverse_module_state->__pyx_int_19394913);
@@ -5227,7 +5227,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
 #define __pyx_n_s_writer __pyx_mstate_global->__pyx_n_s_writer
 #define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
 #define __pyx_int_1 __pyx_mstate_global->__pyx_int_1
-#define __pyx_int_52 __pyx_mstate_global->__pyx_int_52
+#define __pyx_int_54 __pyx_mstate_global->__pyx_int_54
 #define __pyx_int_160 __pyx_mstate_global->__pyx_int_160
 #define __pyx_int_18997755 __pyx_mstate_global->__pyx_int_18997755
 #define __pyx_int_19394913 __pyx_mstate_global->__pyx_int_19394913
@@ -41767,7 +41767,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
   if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_52 = PyInt_FromLong(52); if (unlikely(!__pyx_int_52)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_54 = PyInt_FromLong(54); if (unlikely(!__pyx_int_54)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_160 = PyInt_FromLong(160); if (unlikely(!__pyx_int_160)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_18997755 = PyInt_FromLong(18997755L); if (unlikely(!__pyx_int_18997755)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_19394913 = PyInt_FromLong(19394913L); if (unlikely(!__pyx_int_19394913)) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -42453,14 +42453,14 @@ if (!__Pyx_RefNanny) {
   /* "_pydevd_bundle/pydevd_cython.pyx":16
  * # ENDIF
  * 
- * version = 52             # <<<<<<<<<<<<<<
+ * version = 54             # <<<<<<<<<<<<<<
  * 
  * if not hasattr(sys, '_current_frames'):
  */
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_int_52) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_int_54) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
 
   /* "_pydevd_bundle/pydevd_cython.pyx":18
- * version = 52
+ * version = 54
  * 
  * if not hasattr(sys, '_current_frames'):             # <<<<<<<<<<<<<<
  * 
@@ -42763,7 +42763,7 @@ if (!__Pyx_RefNanny) {
     __pyx_L3:;
 
     /* "_pydevd_bundle/pydevd_cython.pyx":18
- * version = 52
+ * version = 54
  * 
  * if not hasattr(sys, '_current_frames'):             # <<<<<<<<<<<<<<
  * 

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_cython.pyx

@@ -13,7 +13,7 @@ pydev_log.debug("Using Cython speedups")
 # from _pydevd_bundle.pydevd_frame import PyDBFrame
 # ENDIF
 
-version = 52
+version = 54
 
 if not hasattr(sys, '_current_frames'):
 

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_dont_trace_files.py

@@ -106,12 +106,16 @@ DONT_TRACE = {
     'pydevd_io.py': PYDEV_FILE,
     'pydevd_ipython_console_output.py': PYDEV_FILE,
     'pydevd_kill_all_pydevd_threads.py': PYDEV_FILE,
+    'pydevd_matplotlib_image.py': PYDEV_FILE,
     'pydevd_modify_bytecode.py': PYDEV_FILE,
     'pydevd_numpy.py': PYDEV_FILE,
     'pydevd_numpy_based.py': PYDEV_FILE,
+    'pydevd_numpy_based_image.py': PYDEV_FILE,
+    'pydevd_numpy_image.py': PYDEV_FILE,
     'pydevd_pandas.py': PYDEV_FILE,
     'pydevd_pep_669_tracing.py': PYDEV_FILE,
     'pydevd_pep_669_tracing_wrapper.py': PYDEV_FILE,
+    'pydevd_pillow_image.py': PYDEV_FILE,
     'pydevd_plugin_numpy_types.py': PYDEV_FILE,
     'pydevd_plugin_utils.py': PYDEV_FILE,
     'pydevd_plugins_django_form_str.py': PYDEV_FILE,
@@ -125,8 +129,6 @@ DONT_TRACE = {
     'pydevd_save_locals.py': PYDEV_FILE,
     'pydevd_signature.py': PYDEV_FILE,
     'pydevd_smart_step_into_27.py': PYDEV_FILE,
-    'pydevd_smart_step_into_311.py': PYDEV_FILE,
-    'pydevd_smart_step_into_36_310.py': PYDEV_FILE,
     'pydevd_smart_step_into_util.py': PYDEV_FILE,
     'pydevd_stackless.py': PYDEV_FILE,
     'pydevd_tables.py': PYDEV_FILE,

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_frame_utils.py

@@ -29,7 +29,11 @@ def add_exception_to_frame(frame, exception_info):
 
 
 def remove_exception_from_frame(frame):
-    frame.f_locals.pop('__exception__', None)
+    try:
+        frame.f_locals.pop('__exception__', None)
+    except:
+        if "__exception__" in frame.f_locals:
+           frame.f_locals["__exception__"] = None
 
 
 FILES_WITH_IMPORT_HOOKS = ['pydev_monkey_qt.py', 'pydev_import_hook.py']

{pydevd_pycharm-251.23774.123 → pydevd_pycharm-251.23774.354}/_pydevd_bundle/pydevd_pep_669_tracing.py

@@ -15,7 +15,7 @@ from _pydevd_bundle.pydevd_comm_constants import (
     CMD_STEP_OVER, CMD_SMART_STEP_INTO, CMD_SET_BREAK, CMD_STEP_INTO,
     CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_STEP_RETURN)
 from _pydevd_bundle.pydevd_constants import (
-    PYDEVD_TOOL_NAME, STATE_RUN, STATE_SUSPEND, GlobalDebuggerHolder)
+    PYDEVD_TOOL_NAME, STATE_RUN, STATE_SUSPEND, GlobalDebuggerHolder, IS_CPYTHON)
 from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE, PYDEV_FILE
 from _pydevd_bundle.pydevd_trace_dispatch import (
     set_additional_thread_info, handle_breakpoint_condition,
@@ -24,7 +24,12 @@ from _pydevd_bundle.pydevd_trace_dispatch import (
 from pydevd_file_utils import (
     NORM_PATHS_AND_BASE_CONTAINER, get_abs_path_real_path_and_base_from_frame)
 
-get_current_thread = threading.current_thread
+def get_current_thread():
+    try:
+        return threading.current_thread()
+    except:
+        return None
+
 get_file_type = DONT_TRACE.get
 
 global_cache_skips = {}
@@ -65,7 +70,7 @@ def _get_abs_path_real_path_and_base_from_frame(frame):
     return abs_path_real_path_and_base
 
 
-def _should_enable_line_events_for_code(frame, code, filename, info):
+def _should_enable_line_events_for_code(frame, code, filename, info, will_be_stopped=False):
     line_number = frame.f_lineno
 
     # print('PY_START (should enable line events check) %s %s %s %s' % (line_number, code.co_name, filename, info.pydev_step_cmd))
@@ -81,7 +86,7 @@ def _should_enable_line_events_for_code(frame, code, filename, info):
 
     can_skip = False
 
-    if info.pydev_state == 1:  # STATE_RUN = 1
+    if info.pydev_state == 1 and not will_be_stopped:  # STATE_RUN = 1
         can_skip = (step_cmd == -1 and stop_frame is None) \
                    or (step_cmd in (109, 108) and stop_frame is not frame)
 
@@ -126,9 +131,7 @@ def _should_enable_line_events_for_code(frame, code, filename, info):
                 if breakpoint.func_name in ('None', curr_func_name):
                     has_breakpoint_in_frame = True
                     # New breakpoint was processed -> stop tracing monitoring.events.INSTRUCTION
-                    if getattr(breakpoint, '_not_processed', None):
-                        breakpoint._not_processed = False
-                        _modify_global_events(_EVENT_ACTIONS["REMOVE"], monitoring.events.INSTRUCTION)
+                    remove_breakpoint(breakpoint)
                     break
 
                 # Check is f_back has a breakpoint => need register return event
@@ -208,7 +211,7 @@ def enable_pep669_monitoring():
             (monitoring.events.LINE, py_line_callback),
             (monitoring.events.PY_RETURN, py_return_callback),
             (monitoring.events.RAISE, py_raise_callback),
-            (monitoring.events.INSTRUCTION, instruction_callback),
+            (monitoring.events.CALL, call_callback),
         ):
             monitoring.register_callback(DEBUGGER_ID, event_type, callback)
 
@@ -217,9 +220,16 @@ def enable_pep669_monitoring():
         debugger.is_pep669_monitoring_enabled = True
 
 
-def process_new_breakpoint(breakpoint):
+def add_new_breakpoint(breakpoint):
     breakpoint._not_processed = True
-    _modify_global_events(_EVENT_ACTIONS["ADD"], monitoring.events.INSTRUCTION)
+    monitoring.restart_events()
+    _modify_global_events(_EVENT_ACTIONS["ADD"], monitoring.events.CALL)
+
+
+def remove_breakpoint(breakpoint):
+    if getattr(breakpoint, '_not_processed', None):
+        breakpoint._not_processed = False
+        _modify_global_events(_EVENT_ACTIONS["REMOVE"], monitoring.events.CALL)
 
 
 def _modify_global_events(action, event):
@@ -243,7 +253,7 @@ def _enable_line_tracing(code):
                                 local_events | monitoring.events.LINE)
 
 
-def instruction_callback(code, instruction_offset):
+def call_callback(code, instruction_offset, callable, arg0):
     try:
         py_db = GlobalDebuggerHolder.global_dbg
     except AttributeError:
@@ -252,13 +262,15 @@ def instruction_callback(code, instruction_offset):
         return monitoring.DISABLE
 
     frame = _getframe(1)
-    # print('ENTER: INSTRUCTION ', code.co_filename, frame.f_lineno, code.co_name)
+    # print('ENTER: CALL ', code.co_filename, frame.f_lineno, code.co_name)
 
     try:
         if py_db._finish_debugging_session:
             return monitoring.DISABLE
 
         thread = get_current_thread()
+        if thread is None:
+            return
 
         if not is_thread_alive(thread):
             return
@@ -270,7 +282,7 @@ def instruction_callback(code, instruction_offset):
         is_stepping = pydev_step_cmd != -1
 
         if not is_stepping and frame_cache_key in global_cache_skips:
-            return
+            return monitoring.DISABLE
 
         abs_path_real_path_and_base = _get_abs_path_real_path_and_base_from_frame(frame)
         filename = abs_path_real_path_and_base[1]
@@ -278,7 +290,7 @@ def instruction_callback(code, instruction_offset):
         breakpoints_for_file = (py_db.breakpoints.get(filename)
                                 or py_db.has_plugin_line_breaks)
         if not breakpoints_for_file and not is_stepping:
-            return
+            return monitoring.DISABLE
 
         if _should_enable_line_events_for_code(frame, code, filename, info):
             _enable_line_tracing(code)
@@ -312,6 +324,8 @@ def py_start_callback(code, instruction_offset):
             return monitoring.DISABLE
 
         thread = get_current_thread()
+        if thread is None:
+            return
 
         if not is_thread_alive(thread):
             return
@@ -437,6 +451,9 @@ def py_start_callback(code, instruction_offset):
 def py_line_callback(code, line_number):
     frame = _getframe(1)
     thread = get_current_thread()
+    if thread is None:
+        return
+
     info = _get_additional_info(thread)
 
     # print('LINE %s %s %s %s' % (frame.f_lineno, code.co_name, code.co_filename, info.pydev_step_cmd))
@@ -468,15 +485,15 @@ def py_line_callback(code, line_number):
             exist_result = False
             bp_type = None
             args = (py_db, filename, info, thread)
-            new_frame = frame
             smart_stop_frame = info.pydev_smart_step_context.smart_step_stop
             context_start_line = info.pydev_smart_step_context.start_line
             context_end_line = info.pydev_smart_step_context.end_line
             is_within_context = (context_start_line <= line_number
                                  <= context_end_line)
 
-            if breakpoints_for_file and line_number in breakpoints_for_file:
+            if info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None and line_number in breakpoints_for_file:
                 breakpoint = breakpoints_for_file[line_number]
+                new_frame = frame
                 stop = True
                 if step_cmd == CMD_STEP_OVER:
                     if stop_frame is frame:
@@ -516,6 +533,9 @@ def py_line_callback(code, line_number):
                         # ignore library files while stepping
                         return monitoring.DISABLE
 
+            if py_db.show_return_values or py_db.remove_return_values_flag:
+                manage_return_values(py_db, frame, 'line', None)
+
             if stop:
                 py_db.set_suspend(
                     thread,
@@ -531,6 +551,7 @@ def py_line_callback(code, line_number):
             # if thread has a suspend flag, we suspend with a busy wait
             if info.pydev_state == STATE_SUSPEND:
                 py_db.do_wait_suspend(thread, frame, 'line', None)
+                return
             elif not breakpoint:
                 # No stop from anyone and no breakpoint found in line (cache that).
                 global_cache_frame_skips[line_cache_key] = 0
@@ -562,7 +583,7 @@ def py_line_callback(code, line_number):
                     curr_func_name = ''
 
                 if smart_stop_frame and smart_stop_frame is frame.f_back:
-                    if curr_func_name == info.pydev_func_name:
+                    if curr_func_name == info.pydev_func_name and not IS_CPYTHON:
                         stop = True
                     else:
                         try:
@@ -601,6 +622,8 @@ def py_line_callback(code, line_number):
                     result = py_db.plugin.cmd_step_over(py_db, frame, 'line', args, stop_info, stop)
                     if result:
                         stop, plugin_stop = result
+            else:
+                stop = False
 
             if plugin_stop:
                 py_db.plugin.stop(py_db, frame, 'line', args, stop_info, None, step_cmd)
@@ -613,8 +636,11 @@ def py_line_callback(code, line_number):
             raise
         except:
             traceback.print_exc()
+            info.pydev_step_cmd = -1
             raise
 
+        if py_db.quitting:
+            raise KeyboardInterrupt()
     finally:
         info.is_tracing = False
 
@@ -632,10 +658,12 @@ def py_raise_callback(code, instruction_offset, exception):
     if py_db is None:
         return
 
-    thread = get_current_thread()
-    info = _get_additional_info(thread)
-
     try:
+        thread = get_current_thread()
+        if thread is None:
+            return
+
+        info = _get_additional_info(thread)
         frame = _getframe(1)
         if frame is _get_top_level_frame():
             _stop_on_unhandled_exception(exc_info, py_db, thread)
@@ -659,6 +687,13 @@ def py_raise_callback(code, instruction_offset, exception):
     except KeyboardInterrupt:
         _clear_run_state(info)
         raise
+    except:
+        traceback.print_exc()
+        info.pydev_step_cmd = -1
+        raise
+
+    if py_db.quitting:
+        raise KeyboardInterrupt()
 
 
 def py_return_callback(code, instruction_offset, retval):
@@ -673,6 +708,8 @@ def py_return_callback(code, instruction_offset, retval):
 
     frame = _getframe(1)
     thread = get_current_thread()
+    if thread is None:
+        return
     info = _get_additional_info(thread)
     stop_frame = info.pydev_step_stop
     filename = _get_abs_path_real_path_and_base_from_frame(frame)[1]
@@ -727,10 +764,10 @@ def py_return_callback(code, instruction_offset, retval):
             f_back = frame.f_back
             f_code = getattr(f_back, 'f_code', None)
             if f_code is not None:
+                back_filename = f_code.co_filename
+                base_back_filename = os.path.basename(back_filename)
+                file_type = get_file_type(base_back_filename)
                 if stop != (step_cmd == -1):
-                    back_filename = f_code.co_filename
-                    base_back_filename = os.path.basename(back_filename)
-                    file_type = get_file_type(base_back_filename)
                     if file_type == PYDEV_FILE:
                         stop = False
                     elif not stop and step_cmd == -1:
@@ -746,6 +783,9 @@ def py_return_callback(code, instruction_offset, retval):
                                         _enable_line_tracing(f_code)
                                         _enable_return_tracing(f_code)
                                     break
+                if stop:
+                    _enable_line_tracing(f_code)
+                    _enable_return_tracing(f_code)
 
         if plugin_stop:
             py_db.plugin.stop(py_db, frame, 'return', args, stop_info, None, step_cmd)
@@ -763,3 +803,10 @@ def py_return_callback(code, instruction_offset, retval):
     except KeyboardInterrupt:
         _clear_run_state(info)
         raise
+    except:
+        traceback.print_exc()
+        info.pydev_step_cmd = -1
+        raise
+
+    if py_db.quitting:
+        raise KeyboardInterrupt()